制订协议@protocol

 

1⃣️//1.制定协议

//protocol:协议的关键字

//@protocol 协议名 <基协议>

//NSObject:基协议。自己创建协议时，需要遵守基协议NSObject.

@protocol IOSCoderProtocol <NSObject>

#import <Foundation/Foundation.h>

//protocol:协议的关键字

//@protocol 协议名 <基协议>

//NSObject:基协议。自己创建协议时，需要遵守基协议NSObject.

@protocol IOSCoderProtocol <NSObject>

 

//协议中的方法声明在@protocol和@end这对关键字之间

//1.协议只有声明，没有实现 --> 由遵守协议的类来实现协议中的方法（谁遵守协议，谁实现协议中的方法）

//2.协议只能声明方法（函数，成员方法），不能声明成员变量

-(void)writeIOSCode;

 

//协议使用步骤：

//1.制定协议

 

@end

 

2⃣️2.遵守协议（自定义的协议需要导入协议的头文件）CCoder.h

/#import <Foundation/Foundation.h>

#import "IOSCoderProtocol.h"

 

//2.遵守协议（自定义的协议需要导入协议的头文件）

@interface CCoder : NSObject<IOSCoderProtocol>

 

-(void)listen;

-(void)playGame;

 

@end

3⃣️3.实现协议中的方法 CCoder.m

 #import "CCoder.h"

 

@implementation CCoder

-(void)dealloc{

    [super dealloc];

}

 

-(void)listen{

    NSLog(@"没事听听歌");

}

-(void)playGame{

    NSLog(@"无聊玩会游戏");

}

//3.实现协议中的方法

-(void)writeIOSCode{

    NSLog(@"升级完成，可以写iOS代码了");

}

@end

4⃣️//4.调用协议中的方法

     CCoder *cCoder = [[CCoder alloc]init];

 

        [cCoder listen];

        [cCoder playGame];

        [cCoder writeIOSCode];

    

        //4.调用协议中的方法

        

        //obj1是遵守协议的id类型的指针

        id<IOSCoderProtocol> obj1 = [cCoder retain];

        //协议是用来规范接口，限制对象的行为。

        [obj1 writeIOSCode];

        

        [cCoder release];

        [obj1 release];

        

     //协议使用步骤：

     //制定协议 --> 遵守协议 --> 实现协议中的方法 --> 调用协议中的方法

 

 

 

 

 

1⃣️//1.制定协议

#import <Foundation/Foundation.h>

//1.声明协议

//@protocol 协议名 <基协议>

//自定义的协议，都要遵守基协议

@protocol CompanyProtocol <NSObject>

//这对关键字里面写方法的声明

//1.协议只有声明，没有实现 --> 由遵守协议的类来实现协议中的方法

//2.协议只能声明方法，不能声明成员变量

 

//@required --> 默认关键字是required,声明成required类型的方法，是必须的，在遵守协议的类中，必须实现。

//当协议的方法没有关键字时，这个方法就是默认必须实现的。

-(void)writeIOSCode;

 

@optional   //可选的，遵守协议的类可以实现，也可以不实现该方法

-(void)dancing;

@end

2⃣️2.遵守协议（自定义的协议需要导入协议的头文件）

#import <Foundation/Foundation.h>

#import "CompanyProtocol.h"

 

//2.遵守协议

@interface JavaCoder : NSObject<CompanyProtocol>

 

-(void)writeJavaCode;

 

@end

#import "JavaCoder.h"

3⃣️3.实现协议中的方法

@implementation JavaCoder

-(void)dealloc{

    [super dealloc];

}

 

-(void)writeJavaCode{

    NSLog(@"开开心心写java代码");

}

 

//3.实现协议中的方法

-(void)writeIOSCode{

    NSLog(@"可以写iOS代码了");

}

 

@end

4⃣️//4.调用协议中的方法

#import <Foundation/Foundation.h>

#import "JavaCoder.h"

 

int main(int argc, const char * argv[])

{

 

    @autoreleasepool {

        

        //JavaCoder既会写java代码，又会写iOS代码

        JavaCoder *jc = [[JavaCoder alloc]init];

        [jc writeJavaCode];

        [jc writeIOSCode];

        

        //上班 --> 公司，老板让他做iOS的工作

        //遵守协议的id类型的指针，只能指向遵守了协议的任意对象

        id<CompanyProtocol> obj = [jc retain];

        [obj writeIOSCode];

        

        //判断某个对象是否响应某个方法

//        SEL sel = @selector(dancing);

        if ([obj respondsToSelector:@selector(dancing)]) {

            [obj performSelector:@selector(dancing)];

        }

        else{

            NSLog(@"没有实现这个方法");

        }

        

        [jc release];

        [obj release];

        

        

    }

    return 0;

}

 

 

1. BroadCast.h

  广播站

#import <Foundation/Foundation.h>

 

//协议通常还可以声明在制定协议的一方的类里面

//1.制定协议

@protocol ReceiveMessageProtocol <NSObject>

 

-(void)receiveAndPlayMessage:(NSString *)message;

 

@end

 

 

@interface BroadCast : NSObject

 

//把代理声明成assign类型，是为了避免循环引用。

//循环引用：A类的对象持有B类的对象，B类的对象又持有A类的对象，这样的话，A和B的对象，引用计数都不能减到0，会引起A和B的对象都无法释放。

//相互包含：在A类中包含了B类的头文件，在B类中也包含了A类的头文件，会发生无限展开，根本没办法停下来。解决办法是，要在一个类的.h中使用另外一个类时，使用@class进行前向声明。

//前向声明：@class Dog; --> 表名@class后的Dog是一个类。

@property(assign ,nonatomic) id<ReceiveMessageProtocol> delegate;

//广播站本身是可以发送广播的

-(void)sendMessage:(NSString *)message;

 

@end

2. BroadCast.m

 

#import "BroadCast.h"

 

@implementation BroadCast

-(void)dealloc{

    [super dealloc];

}

-(void)sendMessage:(NSString *)message{

    //广播站发送广播，然后让它的代理接收和播放广播

    SEL sel = @selector(receiveAndPlayMessage:);

    if ([self.delegate respondsToSelector:sel]) {

        //代理中有该方法 --> 让代理执行该方法

//        [self.delegate receiveAndPlayMessage:<#(NSString *)#>]

        [self.delegate performSelector:sel withObject:message];

    }

    else{

        NSLog(@"代理中没有实现该方法");

    }

    

}

 

@end

3.Audio.h

 广播站

 

#import <Foundation/Foundation.h>

#import "BroadCast.h"

 

//遵守协议

@interface Audio : NSObject<ReceiveMessageProtocol>

 

@end

4.Audio.m

#import "Audio.h"

 

@implementation Audio

-(void)dealloc{

    [super dealloc];

}

//实现协议中的方法

-(void)receiveAndPlayMessage:(NSString *)message{

    NSLog(@"audio play message:%@",message);

}

 

@end