iOS开发之OC篇（13）—— Protocol（协议）、Delegate（代理）

#版本
Xcode 8.3.2

#区别和联系
光看名称我就知道：协议不是代理；代理不是协议。
协议是多个类（或者说对象）之间协商的一个公共接口，提供一系列方法的声明给类们使用；而代理是协议的一个典型应用机制。
怎么回事呢？一起来看详情。

#Protocol（协议）
##1、如何理解Protocol

• Protocol用来声明一些方法，或者说，Protocol是由一系列的方法声明组成的。
• 一个类只要遵守了Protocol,就相当于拥有了Protocol的所有方法声明。
• 一个Protocol只要遵守了其他Protocol,就相当于拥有了其他Protocol的所有方法声明。

既然Protocol只能声明方法，那么方法的实现自然写在类的实现文档.m里面。其中，不同的类对方法的实现可以是不同的。
比如说，Protocol里声明一个方法：

- (void)eat;

如果人类Man遵守了这个Protocol，可以这样实现：

- (void)eat {
	NSLog(@"Man eat");
}

如果狗Dog遵守了这个Protocol，可以这样实现：

- (void)eat {
	NSLog(@"Dog eat");
}

如果鱼Fish遵守了这个Protocol，可以这样实现：

- (void)eat {
	NSLog(@"Fish eat");
}

也就是说，每个类的eat实现方法可以不一样。
再者，某类遵循了Protocol，并不一定要全部实现Protocol里声明的方法。
假设Protocol有如下方法：

@required
- (void)eat;

@optional
- (void)watch;

@required之下的方法是必须实现的，不然编译器会发出警报（不会出错，毕竟神仙、神狗、神鱼不用eat）。
@optional之下的方法是可选实现的，鱼才不会帮你看门呢。

##2、怎么使用Protocol
创建一个Protocol：

1 2

然后在Protocol中声明方法：

协议遵守其他协议是这样子的

@interface 协议名  <协议名称1, 协议名称2,…>
// 声明方法
@end

我们看到协议名 Eat 后面加了一个 < NSObject > , 这里NSObject是一个基协议，任何协议最终都会继承自基协议；就像类class一样，最终也都会继承自基类NSObject。

接下来依次创建几个类来遵守Protocol：

1 2 3

类遵守协议是这样子的：
首先导入协议（#import协议的.h文件），然后在@interface最后面加<协议名称>

#import "协议名称.h"

@interface 类名 : 父类 <协议名称1, 协议名称2,…>
// 这里不要再声明协议里已经声明过的方法
@end

然后就可以在类的.m文件里自由实现方法了：

Man的.m文件

Dog的.m文件

Fish的.m文件

然后在main里面使用：

结果如下：

小结：类（或者说对象）遵守了Protocol，那么该类就有了Protocol里面声明的方法。类必须实现@required方法、可选实现@optional方法，具体怎么实现由该类自行决定，Protocol不过问。

#Delegate（代理）
##1、什么是代理？
在上面的例子中，如果man不想看门（watch方法），那么可以请dog来做这件事情，这就是代理。man是被代理方，dog是代理方。
代理方要遵守对应协议, 并实现协议里的方法. 例子中man定义了一个遵守了Eat协议的delegate, 并把这个delegate指向了dog (设置代理), dog就成为了代理方。具体如何实现的呢？

##2、如何使用代理？

具体步骤：
1、创建一个协议；
2、被代理方声明一个代理属性：@property (nonatomic, weak) id<代理协议> delegate;
3、代理方准守协议并实现代理方法（即协议里声明的方法）；
4、设置代理：被代理方对象名.delegate = 代理方对象名;
4、当被代理方需要代理方做事情的时候，用self.delegate调用代理方法，通知代理方干活；
5、代理方对象执行代理方法。

前面例子中我们已经创建了一个协议Eat：

@protocol Eat <NSObject>

@required
- (void)eat;        // 必须实现的方法

@optional
- (void)watch;      // 可选实现的方法

@end

接下来在被代理方man的.h里声明一个代理属性：

@interface Man : NSObject 

// 声明一个指向代理对象的指针变量，遵循Eat,协议一般使用弱引用,若用强引用，会造成双向代理死锁问题
@property (nonatomic, weak) id <Eat> delegate;

@end

然后代理方dog实现代理方法：

@implementation Dog

- (void)eat {
    NSLog(@"Man eat");
}

- (void)watch {
    NSLog(@"Dog watch");
}

@end

设置代理并执行方法：

int main(int argc, const char * argv[]) {
    
    Man     *man    = [[Man alloc] init];
    Dog     *dog    = [[Dog alloc] init];
    
    man.delegate = dog;         // 设置代理
    
    if ([man.delegate respondsToSelector:@selector(watch)]) {
        [man.delegate watch];   // 通知代理方看门
    }
    
    
    return 0;
}

这样，man成功地被dog代理了“看门”这个方法：

main中注意到，代理方通知被代理方执行代理方法的时候，加了一个if判断：

if ([man.delegate respondsToSelector:@selector(watch)]) {
        [man.delegate watch];   // 通知代理方看门
    }

这句话的意思是，当man的代理方man.delegate（即dog）响应了watch这个方法的时候，才执行代理。这是出于安全考虑：因为如果dog中没有实现watch这个方法，那么编译就会出错。