OC-035.协议

协议:对象之间一种约定
只有方法声明没有方法实现一种类型

定义一个协议：
1.@protocol 协议名称 <NSObject> 开头
2.@end 结尾
@required 表示遵守这个协议的类必须实现方法(默认) 翻译：需要
@optional 表示可选的,遵守这个协议的类可以不实现的方法 翻译：可选

让类遵守协议
@interface 类名 : NSObject <协议名称>

一个类可以遵守多个协议
一个协议可以被多个类遵守
一个协议也可以遵守多个协议

通过id<协议名称> 定义出来的指针，只能指向实现这个协议的类的实例对象，有多态的特性

它指向任意的实现这个协议的类的实例对象

#import <Foundation/Foundation.h>//------main
#import "LSMe.h"
#import "LSIpad.h"
#import "LSIphone.h"
#import "LSIpod.h"

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        LSMe *me = [[LSMe alloc] init];
        [me callToMum];
        [me playGame];
        
        LSIpad *ipad = [[LSIpad alloc] init];
        LSIpod *ipod = [[LSIpod alloc] init];
        LSIphone *iphone = [[LSIphone alloc] init];
        
//        me.apple = ipod;不能用id<play>去指向没有遵守这个协议的对象
        me.apple = ipad; //指向ipad
        [me playWithApple];//ipad 玩游戏
        
        me.apple = iphone;//指向iphone
        [me playWithApple];//iphone 玩游戏
        
        me.appleNew = ipod;//如果id后面不加协议，是可以指向ipod的
        [me playWithAppleNew];

    }
    return 0;
}

#import <Foundation/Foundation.h>//------call.h

/*
 @protocol 开头
 @end 结尾
 
 @required 表示遵守这个协议的类必须实现方法(默认)         翻译：需要
 @optional 表示可选的,遵守这个协议的类可以不实现的方法     翻译：可选
 */
@protocol call <NSObject> //任何协议首先都是遵守基协议的

@required  //在类中必须实现的
- (void) callToMum;

@optional
- (void) callToDad;
@end

#import <Foundation/Foundation.h>//------play.h

@protocol play <NSObject>
- (void) playGame;
@end

#import <Foundation/Foundation.h>//------LSme.h
//#import "call.h"   //导入协议文件
//#import "play.h"    //一个类可以遵守多个协议、一个协议可以被多个类遵守
#import "all.h"
@interface LSMe : NSObject <all>

//通过id<协议名称> 定义出来的指针，只能指向实现这个协议的类的实例对象，有多态的特性
//它指向任意的实现这个协议的类的实例对象
//如果这个id指向的不是遵守这个协议的对象，那么程序会崩溃
@property (nonatomic,strong) id<play> apple;

@property (nonatomic,strong) id appleNew;//如果id后面不加协议，是可以指向ipod的


-(void) playWithApple;

-(void) playWithAppleNew;

@end

#import "LSMe.h"//------LSMe.m

@implementation LSMe
- (void) callToMum{
    NSLog(@"%s",__func__);
}
- (void) callToDad{       //这个方法可以不实现
    NSLog(@"%s",__func__);
}
-(void)playGame{
    NSLog(@"%s",__func__);
}
-(void) playWithApple{
    [self.apple playGame];    
}
-(void) playWithAppleNew{
    [self.appleNew playGame];
}
@end

#import <Foundation/Foundation.h>//------LSIpad.h
#import "play.h"
@interface LSIpad : NSObject <play>

@end

#import "LSIpad.h"//------LSIpad.m

@implementation LSIpad
-(void)playGame{
    NSLog(@"%s",__func__);
}
@end

#import <Foundation/Foundation.h>//------LSIphone.h
#import "play.h"
@interface LSIphone : NSObject <play>

@end

#import "LSIphone.h"//------LSIphone.m

@implementation LSIphone
-(void)playGame{
    NSLog(@"%s",__func__);
}
@end

#import <Foundation/Foundation.h>//------LSIpod.h

@interface LSIpod : NSObject
-(void)playGame;

@end

#import "LSIpod.h"//------LSIpod.m

@implementation LSIpod
-(void)playGame{
    NSLog(@"%s",__func__);
}

@end

#import <Foundation/Foundation.h>//------all.h 协议
#import "call.h"
#import "play.h"
//一个协议可以同时遵守多个协议
@protocol all <call,play>

@end