OC中的Foundation框架是系统提供了，他就相当于是系统的一套api,和Java中的一些系统jar很相似，又早起的一批人开发的，内部有很多现有的类和功能提供给我们使用。那么今天首先来介绍一下Foundation框架中的第一个类NSObject
在之前介绍了类的相关知识，我们看到我们自定义的类都必须实现NSObject类，这个类内部有很多现有的方法可以供我们使用，比如我们经常使用的alloc和init方法，就是NSObject提供的，下面就在来看一下他的一些其他常用方法：
通过代码来演示每个方法的作用：
Person.h
[objc] view plaincopy
1. //
2. // Person.h
3. // 13_NSObjectMethod
4. //
5. // Created by jiangwei on 14-10-11.
6. // Copyright (c) 2014年 jiangwei. All rights reserved.
7. //
8.
9. #import <Foundation/Foundation.h>
10.
11. @interface Person : NSObject
12.
13. - (void)invoke;
14.
15. @end
Person.m
[objc] view plaincopy
1. //
2. // Person.m
3. // 13_NSObjectMethod
4. //
5. // Created by jiangwei on 14-10-11.
6. // Copyright (c) 2014年 jiangwei. All rights reserved.
7. //
8.
9. #import "Person.h"
10.
11. @implementation Person
12.
13. - (void)invoke{
14. NSLog(@"invoke is Executing...");
15. [self demo1];//对象调用
16.
17. //performSelector方法调用
18. NSString *result = [self performSelector:@selector(demo1)];
19. NSLog(@"%@",result);
20.
21. //调用有一个参数的方法
22. [self performSelector:@selector(demo2:) withObject:@"jiangwei"];
23.
24. //调用有两个参数的方法
25. [self performSelector:@selector(demo3:withName:) withObject:@"jiangwei" withObject:@"man"];
26.
27. //延迟调用一个方法
28. //此处的延迟调用，代码不会停留在此处，为了不阻塞线程
29. [self performSelector:@selector(demo1) withObject:NULL afterDelay:2.5];
30.
31. //如果没有以下代码的话，上面的延迟调用就不会有效果的，因为他不会阻塞当前线程，所以当前线程中后续的代码会继续执行
32. //在main.m中得main方法中，会直接return，这样程序就运行结束了，所以来不及执行2.5s之后方法执行
33. //以下代码让执行过程停在此处
34. [[NSRunLoop currentRunLoop] run];
35.
36. }
37.
38. - (NSString *)demo1{
39. NSLog(@"demo1");
40. return @"demo1";
41. }
42.
43. - (void)demo2:(NSString *)str{
44. NSLog(@"str = %@",str);
45. }
46.
47. - (void)demo3:(NSString *)str withName:(NSString *)name{
48. NSLog(@"str = %@,name = %@",str,name);
49. }
50.
51. @end
main.m
[objc] view plaincopy
1. //
2. // main.m
3. // 13_NSObjectMethod
4. //
5. // Created by jiangwei on 14-10-11.
6. // Copyright (c) 2014年 jiangwei. All rights reserved.
7. //
8.
9. #import <Foundation/Foundation.h>
10.
11. #import "Person.h"
12.
13. //isEqual判断两个指针是否指向同一个对象
14.
15. int main(int argc, const charchar * argv[]) {
16. @autoreleasepool {
17.
18. //1.--------------------isEqual方法
19. NSObject *obj1 = [[NSObject alloc] init];
20. NSObject *obj2 = [[NSObject alloc] init];
21.
22. if([obj1 isEqual:obj2]){
23. NSLog(@"obj1 == obj2");
24. }else{
25. NSLog(@"obj1 != obj2");
26. }
27.
28. //或者直接用等号判断
29. if(obj1 == obj2){
30. //do something...
31. }else{
32. //do something...
33. }
34.
35.
36. //2.--------------------performSelector方法
37. //调用invoke方法
38. //延迟调用某一个方法
39. Person *p = [[Person alloc] init];
40. [p performSelector:@selector(invoke)];
41.
42. //3.--------------------isKindOfClass和isMemberOfClass方法
43. Person *rose = [[Person alloc] init];
44. //判断rose是否属于Person类创建的
45. //BOOL isBelongTo = [rose isMemberOfClass:[Person class]];//返回YES
46. BOOL isBelongTo = [rose isMemberOfClass:[NSObject class]];//返回NO
47. if(isBelongTo == YES){
48. }else{
49. }
50.
51. //判断rose是否属于子类创建的
52. //判断一个类是不是一个类的子类
53. isBelongTo = [rose isKindOfClass:[NSObject class]];//返回NO
54.
55.
56. //4.---------------------respondsToSelector方法
57. //判断类中是否有特定的方法(有实现的方法全部返回YES,如果只在.h文件中定义了，返回的是NO)
58. //同时这种方式可以实现调用所谓的私有方法
59. Person *task = [[Person alloc] init];
60. isBelongTo = [task respondsToSelector:@selector(invoke)];
61. if(isBelongTo){
62. }else{
63. }
64.
65. }
66. return 0;
67. }
下面来一一介绍一下方法的作用
1、isEqual方法
[java] view plaincopy
1. //1.--------------------isEqual方法
2. NSObject *obj1 = [[NSObject alloc] init];
3. NSObject *obj2 = [[NSObject alloc] init];
4.
5. if([obj1 isEqual:obj2]){
6. NSLog(@"obj1 == obj2");
7. }else{
8. NSLog(@"obj1 != obj2");
9. }
10.
11. //或者直接用等号判断
12. if(obj1 == obj2){
13. //do something...
14. }else{
15. //do something...
16. }
他的作用就是判断两个指针变量是否指向同一个对象，在OC中他还有一个简单的用法，就是直接使用"=="来进行比较，这两个效果是一样的，但是在Java中是不同的，Java中的"=="是判断两个引用变量是否指向同一个对象，但是其equals方法是判断两个对象的值是否相等(这里的值指的是基本类型，其他对象类型，可以重写这个方法来进行操作)。
2、isMemberOfClass方法
[objc] view plaincopy
1. //3.--------------------isKindOfClass和isMemberOfClass方法
2. Person *rose = [[Person alloc] init];
3. //判断rose是否属于Person类创建的
4. //BOOL isBelongTo = [rose isMemberOfClass:[Person class]];//返回YES
5. BOOL isBelongTo = [rose isMemberOfClass:[NSObject class]];//返回NO
6. if(isBelongTo == YES){
7. }else{
8. }
这个方法的作用是判断一个指针变量指向的对象是不是属于一个类创建的，类似于Java中的obj.getClass()==Person.class效果。
3、isKindOfClass方法
[objc] view plaincopy
1. //判断rose是否属于子类创建的
2. //判断一个类是不是一个类的子类
3. isBelongTo = [rose isKindOfClass:[NSObject class]];//返回NO
这个方法的作用是判断一个指针变量指向的对象是不是一个类的子类，类似于Java中的instanceof关键字的作用
4、respondsToSelector方法
[objc] view plaincopy
1. //4.---------------------respondsToSelector方法
2. //判断类中是否有特定的方法(有实现的方法全部返回YES,如果只在.h文件中定义了，返回的是NO)
3. //同时这种方式可以实现调用所谓的私有方法
4. Person *task = [[Person alloc] init];
5. isBelongTo = [task respondsToSelector:@selector(invoke)];
6. if(isBelongTo){
7. }else{
8. }
这个方法我们在之前的文章中使用过了，他的作用就是判断一个类中是否有某个方法，他的判断是只要这个方法有实现,就返回YES
如果只在.h文件中定义了，没有在.m文件中实现的话，也是返回NO的
如果这个方法没有在.h文件中定义，但是在.m文件中有实现的话(私有方法)，返回YES
只要方法在.m文件中有才会返回YES
这个方法的功能如果在Java中可以使用反射去实现
5、performSelector方法
[objc] view plaincopy
1. - (void)invoke{
2. NSLog(@"invoke is Executing...");
3. [self demo1];//对象调用
4.
5. //performSelector方法调用
6. NSString *result = [self performSelector:@selector(demo1)];
7. NSLog(@"%@",result);
8.
9. //调用有一个参数的方法
10. [self performSelector:@selector(demo2:) withObject:@"jiangwei"];
11.
12. //调用有两个参数的方法
13. [self performSelector:@selector(demo3:withName:) withObject:@"jiangwei" withObject:@"man"];
14.
15. //延迟调用一个方法
16. //此处的延迟调用，代码不会停留在此处，为了不阻塞线程
17. [self performSelector:@selector(demo1) withObject:NULL afterDelay:2.5];
18.
19. //如果没有以下代码的话，上面的延迟调用就不会有效果的，因为他不会阻塞当前线程，所以当前线程中后续的代码会继续执行
20. //在main.m中得main方法中，会直接return，这样程序就运行结束了，所以来不及执行2.5s之后方法执行
21. //以下代码让执行过程停在此处
22. [[NSRunLoop currentRunLoop] run];
23.
24. }
25.
26. - (NSString *)demo1{
27. NSLog(@"demo1");
28. return @"demo1";
29. }
30.
31. - (void)demo2:(NSString *)str{
32. NSLog(@"str = %@",str);
33. }
34.
35. - (void)demo3:(NSString *)str withName:(NSString *)name{
36. NSLog(@"str = %@,name = %@",str,name);
37. }
这个方法的作用就是调用对象中的一个方法，看到上面的例子，这个方法有很多样式：
无参数样式
[objc] view plaincopy
1. [self performSelector:@selector(demo1)]
一个参数的样式
[objc] view plaincopy
1. //调用有一个参数的方法
2. [self performSelector:@selector(demo2:) withObject:@"jiangwei"];
两个参数样式
[objc] view plaincopy
1. //调用有两个参数的方法
2. [self performSelector:@selector(demo3:withName:) withObject:@"jiangwei" withObject:@"man"];
但是我们看到上面的调用方式，感觉不到这个方法的用途，因为我们完全可以直接调用demo1方法
[objc] view plaincopy
1. [self demo1]
在看看他的一种样式
[java] view plaincopy
1. //延迟调用一个方法
2. //此处的延迟调用，代码不会停留在此处，为了不阻塞线程
3. [self performSelector:@selector(demo1) withObject:NULL afterDelay:2.5];
可以延迟的调用一个方法，这才是该方法的核心作用，他的作用类似于Android中的postDelayed(Runnable runable)方法，同样，这个方法会在后面UI使用中经常使用到，能够延迟的调用一个方法。
同时他还有一个作用可以直接调用一个类的私有方法，即只在.m文件中实现了的方法：
[java] view plaincopy
1. Person *task = [[Person alloc] init];
2. isBelongTo = [task respondsToSelector:@selector(demo1)];
3. if(isBelongTo){
4. [task performSelector:@selector(demo1)];
5. NSLog(@"YES");
6. }else{
7. NSLog(@"NO");
8. }
他回经常结合respondsToSelector方法一起使用，这里demo1就是一个私有的方法，如果在Java中需要用到反射，然后还要强暴一下这个私有方法才能调用。在OC中的实现就简单了。
总结