OC协议

协议：Protocol 它可以声明一些必须实现的方法和选择实现的方法

    作用：用来声明一些方法 由一系列的方法声明组成的

一个类可以遵守1个或多个协议

任何类只要遵守了Protocol，就相当于拥有了Protocol的所有方法声明

 

协议和继承的区别：

1.继承之后默认就有实现，而Protocol只有声明没有实现

2.相同类型的类可以使用继承，但是不同类型的类只能使用（Protocol）协议

3.Protocol可以用于存储方法的声明可以将多个类中共同的方法抽取出来，以后让这些类遵守协议即可

 

注意点：

1.协议只能声明方法，不能声明属性

{

     int _age;

}

2.父类遵守了某个协议，那么子类也会自动遵守这个协议

3.在OC中一个类可以遵守1个或多个协议

     注意：OC中的类只能有一个父类，也就是说OC中只有单继承

4.OC中的协议又可以遵守其它的协议，只要一个协议遵守了其它的协议，那么这个协议中就会自动包含其他协议的声明

 

 

基协议：

1.NSobject是一个基类，最根本最基本的类，任何其他类最终都要继承它

2.还有名字叫NSObject的协议，它是一个基协议，最根本最基本的协议

3.NSObject协议中声明很多最基本的方法

     description

     retain

     release

4.建议每个新的协议都要遵守NSObject协议

 

@required和@optional关键字

1.协议中的2个关键字可以控制方法是否要实现（默认是@required，在大多数情况下，用途在于程序员之间的交流）

     @required：这个方法必须要实现（若不实现，编译器会发出警告）

     @optional：这个方法不一定要实现

 

 

#import <Foundation/Foundation.h>

#import "Student.h"
#import "OtherStudent.h"

int main(int argc, const char * argv[]) {
    @autoreleasepool {
       
        OtherStudent *other = [[OtherStudent alloc] init];
   
        Student *stu = [[Student alloc] init];
        //判断是否遵循 lamcoProtocol 协议
        if ([stu conformsToProtocol:@protocol(lamcoProtocol)]) {
            //判断有没有 学习 的能力
            if ([stu respondsToSelector:@selector(study)]) {
                [stu study];
            }
            //判断有没有 帮助找到 工作 的能力
            if ([stu respondsToSelector:@selector(work)]) {
                [stu work];
            }
        }
        //判断是否遵循 BankProtocol 协议
        if ([stu conformsToProtocol:@protocol(BankProtocol)]) {
            //判断有没有 还款 的能力
            if ([stu respondsToSelector:@selector(giveme)]) {
                [stu giveme];
            }
        }
        if ([other conformsToProtocol:@protocol(lamcoProtocol)]) {
            if ([other respondsToSelector:@selector(work)]) {
                NSLog(@"可以参加培训");
            }
        } else {
            NSLog(@"不能参加培训");
        }
       
    }
    return 0;

}

#import <Foundation/Foundation.h>

#import "lamcoProtocol.h"
#import "BankProtocol.h"

@interface Student : NSObject <lamcoProtocol,BankProtocol>

@end

#import "Student.h"

@implementation Student

-(void)study
{
    NSLog(@"每天按时上课，复习，预习，做项目");
}

-(void)work
{
    NSLog(@"保证给你安排一个技术岗位");
}

-(void)giveme
{
    NSLog(@"每月按时还款");
}

@end

 

#import <Foundation/Foundation.h>

#import "lamcoProtocol.h"
#import "BankProtocol.h"

@interface OtherStudent : NSObject <lamcoProtocol>

@end

#import "OtherStudent.h"

@implementation OtherStudent

-(void)study
{
    NSLog(@"每天按时上课，复习，预习，做项目");
}

-(void)work
{
    NSLog(@"保证给你安排一个技术岗位");
}

-(void)giveme
{
    NSLog(@"每月按时还款");
}

@end

 

//BankProtocol 协议

#import <Foundation/Foundation.h>

@protocol BankProtocol <NSObject>

-(void)giveme;

@end

//lamcoProtocol 协议

#import <Foundation/Foundation.h>

@protocol lamcoProtocol <NSObject>

-(void)study;
-(void)work;

@end

 

 

协议的应用场景：

#import <Foundation/Foundation.h>

#import "Person.h"
#import "WifeProtocol.h"

int main(int argc, const char * argv[]) {
    @autoreleasepool {
       
        Person *p = [[Person alloc] init];
        //1.协议的第一个应用场景，可以将协议写在数据类型的右边，明确的标注如果想给该量赋值，那么该对象必须遵守某个协议
//        Wife<WifeProtocol> *w = [[Wife alloc] init];
       
        Wife *w = [[Wife alloc] init];
        p.wife = w;
        [p show];
       
    }
    return 0;

}

 

#import <Foundation/Foundation.h>
#import "Wife.h"

@interface Person : NSObject

//注意：类型限定是写在数据类型的右边
@property(strong,nonatomic) Wife<WifeProtocol> *wife;

-(void)show;

@end

#import "Person.h"

@implementation Person

-(void)show
{
    //注意：虽然在接受某一个对象的时候，对这个对象进行了类型限定（限定它必须实现某个协议），但是并不意味着这个对象真正的实现了该方法，所以每次在调用对象的协议方法时应该进行一次验证
    if ([self.wife respondsToSelector:@selector(cooking)]) {
        [self.wife cooking];
    }
    if ([self.wife respondsToSelector:@selector(washing)]) {
        [self.wife washing];
    }
    if ([self.wife respondsToSelector:@selector(job)]) {
        [self.wife job];
    }
   
}

@end

 

#import <Foundation/Foundation.h>
#import "WifeProtocol.h"

@interface Wife : NSObject <WifeProtocol>

@end

#import "Wife.h"

@implementation Wife

-(void)cooking
{
    NSLog(@"%s",__func__);
}
-(void)washing
{
    NSLog(@"%s",__func__);
}

-(void)job
{
    NSLog(@"%s",__func__);
}

@end

#import <Foundation/Foundation.h>

@protocol WifeProtocol <NSObject>

//会做饭
-(void)cooking;
//会洗衣服
-(void)washing;
//有一份好工作
-(void)job;

@end