黑马程序员——OC语言——protocol（协议）的概念及其使用

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一、protocol的基本概念

在写java的时候都会有接口interface这个概念,接口就是一堆方法的声明没有实现,而在OC 里面,Interface是一个类的头文件的声明,并不是真正意义上的接口的意思,在OC中,接口是由一个叫做协议的protocol来实现的。这个里面可以声明一些方法,和java不同的是,它可以声明一些必须实现的方法和选择实现的方法。

二、protocol的使用

（一）协议的使用流程:

定义协议----> 在类中采用指定的协议 ---->实现协议中的方法(注意方法有必须实现和选择实现两种)

（二）协议的定义

@protocol 协议名称 <NSObject>
//方法声明列表
@end;

注意: 协议默认的要采纳NSObject的协议

Run.h
#import<Foundation/Foundation.h>
@protocol Run <NSObject>
-(void)eat;
-(void)run;
@end
 
Work.h
#import<Foundation/Foundation.h>
@protocol Work<NSObject>
-(void)myWork;
@end
 

（三）采纳协议

（1）类遵守协议：创建类的时候遵守某个或者某几个协议

@interface 类名 : 父类 <协议名称>
@end
//引入要采纳的协议
#import "Run.h"
// 采纳协议
@interface Person :NSObject<Run>
@end

（2）协议遵守协议

@protocol 协议名称 <其他协议名称>
@end

（3）多个协议之间用逗号 , 隔开。

@protocol 协议名称 <其他协议名称1, 其他协议名称2>
@end
//引入要采纳的协议
#import "Run.h"
#import"Work.h"
// 采纳协议
@interface Person :NSObject<Run,Work>
@end

（四）)实现协议中的方法

如果一个类遵守了某个协议则只需要在这个类的实现(.m)文件中,实现协议的方法就可以了

Person.h
#import"Person.h"
@implementation Person
-(void)run{
NSLog(@"人会跑");
}
-(void)eat{
NSLog(@"人开始吃东西");
}
-(void)myWork{
NSLog(@"人要工作");
}
@end

三、protocol使用注意

（一）protocol使用注意

（1）Protocol:用来声明一大堆的方法(不能声明成员变量),不能写实现。

（2）只要某个类遵守了这个协议,就拥有了这个协议中的所有方法声明。

（3）只要父类遵守了某个协议,那么子类也遵守。

（4）Protocol声明的方法可以让任何类去实现,protocol就是协议。

（5）)OC不能继承多个类(单继承)但是能够遵守多个协议。

（6）基协议:<NSObject>是基协议,是最根本最基本的协议,其中声明了很多最基本的方法。

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

（二）协议之间可以有继承关系

比如:

@protocol A

-(void)methodA;

@end


@protocol B <A>

    -(void)methodB;

@end

如果你要遵守B协议,那么methodA和methodB都需要实现。

（三）类如果采纳协议后,实现了协议的方法,这些方法可以被子类继承

比如:
Person类采纳了Run和Work两个协议,并实现了两个方法 Student类继承了Person类,则此时Student 类中可以调用和重写协议中的方法(实际上是子类 Student 继承自Person的方法)

（四）protocol基协议介绍

NSObject是一个基类,最根本最基本的类,任何其他类最终都要继承它,它还有名字也叫 NSObject的协议,它是一个基协议,最根本最基本的协议 ，NSObject协议中声明很多最基本的方法，建议每个新的协议都要遵守NSObject协议

四、protocol中@required和@optional

@required和@optional是 协议方法声明中的两个关键字 他们主要用于控制方法是否要实现(默认是@required)

@protocol RunProtocol<NSObject>
//@required表示必须要实现的方法
@required
-(void)run;
//可以选择实现的方法
@optional
-(void)eat;
@end

五、protocol代理模式

（一）protocol代理模式概念

传入的对象,代替当前类完成了某个功能,称为代理模式。

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

（1）  定义一个协议,里面声明代理类需要实现的方法列表, 比如这里一个代理类需要实现feedBaby与HongSleep方法；

（2）  创建一个代理类(比如BaoMu),遵守上面的代理协议；

（3）  在需要代理的类中(Baby),定义一个对象类型为id且遵守代理协议的成员变量；

（4）  在Baby类中调用成员变量_delegate(代理)的方法,调用代理类的方法；

（5）  main.m或其他使用Baby类的文件中,为Baby类的成员变量(代理类)赋值,比如 ：

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>
//保姆想要成为baby的代理人就必须遵守协议
#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(@"保姆正在喂婴儿吃饭,血量 = %.2f",baby.blood);   
}
-(void)HongBabySleep:(Baby *)baby{
    baby.sleep += 10;
    NSLog(@"保姆正在哄婴儿睡觉,体力 = %.2f",baby.sleep);
}
@end

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

Baby.m
#import "Baby.h"
#import "BaoMu.h"
#import "lookBabyProtocol.h"
@implementation Baby
-(void)wantEat{
    NSLog(@"婴儿在哭……");
//    保姆喂吃
    [self.bm feedBabyEat:self];
}
-(void)wangSleep{
    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 = 20;
        baby.sleep = 20;
        baby.bm = baomu;
       
        [baby wantEat];
        [baby wangSleep];
        NSLog(@"血量%.2f 体力%.2f",baby.blood,baby.sleep);
    }
    return 0;
}

（二）protocol代理模式应用场合

代理设计模式的场合:


（1）当对象A发生了一些行为,想告知对象B (让对象B成为对象A的代理对象)；

（2）对象B想监听对象A的一些行为 (让对象B成为对象A的代理对象)；

（3）当对象A无法处理某些行为的时候,想让对象B帮忙处理 (让对象B成为对象A的代理对象)