黑马程序员——OC中的协议:protocol

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

一、protocol介绍

（一）、protocol的概念

在OC中，我们会把一些方法的声明写到一个.h的头文件中，这就是protocol，也称为“协议”

协议中声明的方法有两种：

• 必须实现
• 选择实现

（二）、protocol的作用

供其他的类去遵守，如果一个类遵守了一个协议，就应该实现这个协议中定义的必须要实现的方法

二、protocol使用

（一）、protocol的使用流程

1、定义一个协议

@protocol xxx <NSObject>  默认情况下遵守NSObject协议

@end

2、遵守协议

1）遵守一个协议

先导入头文件

@interface 类名 ：NSObject <xxx>

@end

2）遵守多个协议

@interface 类名 ：NSObject <xxx,aaa,bbb>

@end

3、实现协议中的方法

见下面示例

（二）、protocol的基本使用

1、定义协议

baseProtocol.h

#import <Foundation/Foundation.h>@protocol baseProtocol <NSObject>// 声明一些方法-(void)eat;-(void)run;@end

workProtocol.h

#import <Foundation/Foundation.h>@protocol workProtocol <NSObject>-(void) work;@end

2、遵守协议

1）某个类遵守某个协议

Person.h

#import <Foundation/Foundation.h>// 导入头文件#import "baseProtocol.h"@interface Person : NSObject<baseProtocol>@end

2）某个协议遵守多个协议

Person.h

#import <Foundation/Foundation.h>// 导入头文件#import "baseProtocol.h"#import "workProtocol.h"@interface Person : NSObject<baseProtocol,workProtocol>@end

3）协议遵守协议

baseProtocol.h

#import <Foundation/Foundation.h>#import "workProtocol.h"@protocol baseProtocol <NSObject,workProtocol> // 声明一些方法-(void)eat;-(void)run;@end

3、实现协议中的方法

Person.m

#import "Person.h"@implementation Person//实现协议中声明的方法-(void)eat{    NSLog(@"人在吃");}-(void)run{    NSLog(@"人会跑");}-(void) work{    NSLog(@"人在工作");}@end

在main.m中使用

#import <Foundation/Foundation.h>#import "Person.h"int main(int argc, const char * argv[]) {    @autoreleasepool {        //创建对象        Person *p = [Person new];        //调用协议中的方法        [p run];        [p eat];        [p work];    }    return 0;}

（三）、protocol的使用注意

1、Protocol：就一个用途，用来声明一大堆的方法（不能声明成员变量），不能写实现

2、只要某个类遵守了这个协议，就拥有了这个协议中的所有方法声明

3、Protocol声明的方法可以让任何类去实现，protocol就是协议

4、OC不能继承多个类（单继承）但是能够遵守多个协议。继承（:），遵守协议（< >）

5、基协议：<NSObject>是基协议，是最根本的协议，其中声明了很多最基本的方法，每个新的协议都要遵守基协议

6、只要父类遵守了某个协议，那么子类也要遵守

7、协议可以遵守协议，一个协议遵守了另一个协议，就可以拥有另一份协议中的方法声明

8、一个协议可以被多个类遵守

示例：Person类和Cat同时遵守AnimalProtocol协议

AnimalProtocol.h

#import <Foundation/Foundation.h>@protocol AnimalProtocol <NSObject>-(void)run;@end

Cat.h

#import <Foundation/Foundation.h>#import "AnimalProtocol.h"@interface Cat : NSObject<AnimalProtocol>@end

Person.h

#import <Foundation/Foundation.h>#import "AnimalProtocol.h"@interface Person : NSObject<AnimalProtocol>@end

Cat.m

#import "Cat.h"@implementation Cat-(void)run{    NSLog(@"猫在跑");}@end

Person.m

#import "Person.h"@implementation Person-(void)run{    NSLog(@"人在跑");}@end

main.m

#import <Foundation/Foundation.h>#import "Person.h"#import "Cat.h"int main(int argc, const char * argv[]) {    @autoreleasepool {        Person *p = [Person new];        [p run];                Cat *cat = [Cat new];        [cat run];    }    return 0;}

9、类如果遵守协议后，实现了协议的方法，这些方法也可以被子类继承

示例，在上面例子的基础上，创建Person类的一个子类Student

Student.h

#import "Person.h"@interface Student : Person// 没有方法的声明@end

Student.m

#import "Student.h"@implementation Student-(void)run{    NSLog(@"Student run");}@end

main.m

#import <Foundation/Foundation.h>#import "Person.h"#import "Cat.h"#import "Student.h"int main(int argc, const char * argv[]) {    @autoreleasepool {        Person *p = [Person new];        [p run];                Cat *cat = [Cat new];        [cat run];                Student *stu = [Student new];        [stu run];    }    return 0;}

（四）、protocol中@required和@optional

@required和@optional是协议方法声明中的两个关键字，它们主要用于控制方法是否要实现，用途在于方便程序员之间的交流

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

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

代码示例，runProtocol.h

#import <Foundation/Foundation.h>@protocol runProtocol <NSObject>@required-(void)run;@optional-(void)eat;@end

注意：在protocol中，默认情况下，方法是必须必须要实现的

（五）、protocol与类型限制

设定情景：

某程序员A希望找一个会做饭、洗衣服的女生做女朋友，有国企工作的优先，满足条件的女生都可以给他发送消息

分析可知，要求如下

必需条件：

会做饭

会洗衣服

可选条件：

有份好工作

因此，有协议houseHold.h

#import <Foundation/Foundation.h>@protocol houseHold <NSObject>@required-(void)ZuoFan;-(void)XiYiFu;@optional-(void)goodJob;@end

1、使用id存储对象时，对象的类型限制

格式：id <协议名称> 变量名

创建一个Girl类，并让Girl类遵守协议houseHold

Girl.h

#import <Foundation/Foundation.h>#import "houseHold.h"@interface <span style="font-family:Microsoft YaHei;">Girl</span> : NSObject<houseHold>// 遵守houseHold协议@end

Girl.m

#import "Girl.h"@implementation Gril// 实现houseHold协议中必须实现的方法-(void)ZuoFan{    NSLog(@"Girl 会做饭");}-(void)XiYiFu{    NSLog(@"Girl 会洗衣服");}@end

main.m

#import <Foundation/Foundation.h>#import "Girl.h"#import "Dog.h"int main(int argc, const char * argv[]) {    @autoreleasepool {        Girl *mm = [Girl new];        //增加<houseHold>以后，表示，obj只能赋值遵守了houseHold的对象        id<houseHold> obj = mm;    }    return 0;}

2、对象赋值时类型限制

格式：类名<协议名称> *变量名

main.m

#import <Foundation/Foundation.h>#import "Girl.h"#import "Dog.h"int main(int argc, const char * argv[]) {    @autoreleasepool {      Girl *mm = [Gril new];        //表示，obj赋值的时候，必须是Girl对象，并且其遵守了houseHold协议        Girl<houseHold> *obj = mm;    }    return 0;}

3、对象关联关系下，对象的类型限制

假设，让女孩养一条狗，要求这个狗，必须会跑，那么代码如下

runProtocol.h

#import <Foundation/Foundation.h>@protocol runProtocol <NSObject>-(void)run;@end

Dog.h

#import <Foundation/Foundation.h>#import "runProtocol.h"@interface Dog : NSObject<runProtocol>@end

Dog.m

#import "Dog.h"@implementation Dog-(void)run{    NSLog(@"狗在跑");}@end

Girl.h

#import <Foundation/Foundation.h>#import "Dog.h"#import "runProtocol.h"@interface Girl : NSObject//表示，女孩样的狗必须遵守runProtocol协议@property (nonatomic,strong) Dog<runProtocol> *dog;@end

main.m

#import <Foundation/Foundation.h>#import "Girl.h"#import "Dog.h"int main(int argc, const char * argv[]) {    @autoreleasepool {        Dog *d = [Dog new];        Girl *mm = [Girl new];        Girl *obj = mm;        //第三种类型限制，这里不能给obj.dog随意赋值        obj.dog = d;    }    return 0;}

（六）、protocol与代理模式

1、protocol代理设计模式引入

我们通过一个例子，初步理解什么是代理模式：婴儿需要吃和睡，但是他自己不会，所以要找一个保姆来帮他，因此这个保姆必须会喂婴儿吃饭和哄婴儿睡觉。下面是代码实现：

lookBabyProtocol.h

#import <Foundation/Foundation.h>@class Baby;@protocol lookBabyProtocol <NSObject>// 要求保姆必须会做的-(void)feedBabyEat:(Baby *)baby;-(void)hongBabySleep:(Baby *)baby;@end

BaoMu.h

#import <Foundation/Foundation.h>#import "lookBabyProtocol.h"@interface BaoMu : NSObject<lookBabyProtocol>// 保姆遵守协议@end

BaoMu.m

#import "BaoMu.h"#import "Baby.h"@implementation BaoMu// 实现协议中的方法-(void)feedBabyEat:(Baby *)baby{    baby.blood += 20;    NSLog(@"保姆正在喂婴儿吃东西,baby.blood = %.2f", baby.blood);}-(void)hongBabySleep:(Baby *)baby{    baby.sleep +=10;    NSLog(@"保姆正在哄婴儿睡觉,baby.sleep = %.2f",baby.sleep);}@end

Baby.h

#import <Foundation/Foundation.h>@class BaoMu;#import "lookBabyProtocol.h"@interface Baby : NSObject@property (nonatomic, assign) float blood;@property (nonatomic, assign) float sleep;@property(nonatomic,strong) BaoMu<lookBabyProtocol> *bm;-(void)wantEat;-(void)wantSleep;@end

Baby.m

#import "Baby.h"#import "BaoMu.h"@implementation Baby-(void)wantEat{    NSLog(@"婴儿在哭...");    [self.bm feedBabyEat:self];}-(void)wantSleep{    NSLog(@"婴儿在哭...");    [self.bm hongBabySleep:self];}@end

main.m

#import <Foundation/Foundation.h>#import "BaoMu.h"#import "Baby.h"int main(int argc, const char * argv[]) {    @autoreleasepool {        BaoMu *baomu = [BaoMu new];        Baby *baby = [Baby new];        baby.blood = 30;        baby.sleep = 20;                baby.bm = baomu;                [baby wantEat];        [baby wantSleep];                NSLog(@"%.2f,%.2f",baby.blood,baby.sleep);    }    return 0;}

2、Protocol代理设计模式概念

代理设计模式：传入的对象，代替当前类完成了某个功能，成为代理模式

利用协议实现代理模式的主要思路为：

• 定义一个协议，里面声明代理类需要实现的方法列表
• 创建一个代理类，遵守上面的代理协议
• 在需要代理的类中，定义一个对象，类型为id，且遵守代理协议 的成员变量（delegate）
• 在需要代理的类中调用成员变量代理的方法，调用代理类的方法
• main.m或其他使用需要代理的类的文件中，为需要代理的类的成员变量（代理类）赋值

3、Protocol代理设计模式应用场合

代理设计模式的场合：

• 当对象A发生了一些行为，想告知B（让对象B成为对象A的代理对象）
• 当对象B想监听对象A的一些行为（让对象B成为对象A 的代理对象）
• 当对象A无法处理某些行为的时候，想让对象B帮忙处理（让对象B成为对象A 的代理对象）

1）监听器的场合

2）通知的场合

3）有些事情，不想自己处理，想交给别人处理