适合有java和C基础的同学迅速了解OC

1.        
   
2. #import <Foundation/Foundation.h>
   
3. 
   
4. // ProtocolA comply with root protocol
   
5. @protocol ProtocolA <NSObject>
   
6. // 返回值为遵守了ProtocolA的对象
   
7. - (NSObject<ProtocolA> *)getSelf;
   
8. @end
   
9. 
   
10. // ProtocolB comply with ProtocolA
    
11. @protocol ProtocolB <ProtocolA>
    
12. 
    
13. @required  // 以下方法需要实现
    
14. + (id)getSelfClass;
    
15. - (Class)getSelfClass;
    
16. @end
    
17. 
    
18. @protocol ProtocolC <NSObject>
    
19. 
    
20. @optional  // 以下方法选择性实现
    
21. - (void)methodC;
    
22. @end
    
23. 
    
24. // ClassA comply with ProtocolB and ProtocolC
    
25. @interface ClassA :NSObject <ProtocolB,ProtocolC>
    
26. 
    
27. // _obj成员限定指向实现了ProtocolB的对象
    
28. @property(nonatomic,strong) NSObject<ProtocolB> *obj;
    
29. @end
    
30. 
    
31. @implementation ClassA
    
32. +(id)getSelfClass
    
33. {
    
34.         return self;
    
35. }
    
36. 
    
37. - (NSObject<ProtocolA> *)getSelf
    
38. {
    
39.         return self;
    
40. }
    
41. 
    
42. - (Class)getSelfClass
    
43. {
    
44.         return [self class];
    
45. }
    
46. 
    
47. @end
    
48. 
    
49. int main()
    
50. {
    
51.         ClassA<ProtocolB> *a=[[ClassA alloc] init];
    
52.         // a2限定指向实现了 ProtocolA 的对象
    
53.         id<ProtocolA> a2=[[ClassA alloc] init];
    
54.         [a setObj:a2];
    
55.        
    
56.        
    
57.         NSLog(@"a=%@,aClass=%@,a2Class=%@",
    
58.         [a getSelf],[a getSelfClass],[[a2 class] getSelfClass]);
    
59.        
    
60.         return 0;       
    
61. }

复制代码

protocol:
        概念：
                用来声明方法（也只能声明方法),遵守了该协议的 类或其他协议 就拥有这些方法的声明；
                类似java中的interface，但是由于OC是弱类型语言（java为强类型），
                许多类型上的不匹配都只是warning；
        protocol与 （java中）interface 区别：
        1>interface类型变量只能指向 实现了该interface的对象，
                        而protocol本身不是类型，无法用于声明变量；
                        这种多态的特征在OC中则表现为 指定了protocol 的变量
                        限定指向 遵守了该protocol的对象（OC中此类规则违反仅仅警告）,
                        例:id<ProtocolA> p=[[ClassA alloc] init];(ClassA遵守了ProtocolA）
        2>遵守了protocol却没实现当中方法只是警告，interface中是编译错误

声明protocol：
        //NSObject为基协议，与基类NSObject同名，但不同，
        //基类 NSObject 遵守了 基协议 NSObject
        //与类都继承基类一样，官方建议 协议都遵守基协议
        @protocol ProtocolA <NSObject>
        //协议中声明的方法可以规定为须实现或可选，默认为 required
        @required   // 此后声明的方法都为required,遵守该协议的类中不实现就会警告
        - (id<ProtocolA>)methodA:NSObject<ProtocolA> *obj;
        - (void)methodB;
       
        @optional  // 此后声明的方法都为optional,遵守该协议的类中不实现不会警告
        - (id)methodC:ClassA<ProtocolB> obj;
        - (void)methodD;       
        @end
       
类遵守protocol:
        // OC类是单继承，但可以遵守多个协议
        @interface ClassA :NSObject <ProtocolA,ProtocolB>
        @end
       
        @implementation ClassA
        //这里实现协议中的方法
        @end

使用规范：
        为了提高编译效率，.h一般不import协议，用@protocol ProtocolA,ProtocolB; 这种
        方式来告诉编译器ProtocolA与ProtocolB是协议，而在.m中再import，
        与@class ClassA,ClassB; 方式一样;
       

其实有java基础的同学看一下跟java接口类似，基本就会用了