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