OC学习--代理与协议的使用

1.协议

生活角度：协议就是约束遵从协议的人的行为

编程角度：程序中的协议就是约束遵从协议的对象的行为

  规定遵从协议的对象的接口（方法）

  类遵从了协议那么就得实现协议中规定的方法

协议的语法

协议的声明：

#import <Foundation/Foundation.h>

@protocol WriteCodeProtocol <NSObject>// WriteCodeProtocol 协议名

@required//在这里的方法遵从协议的类必须实现

- (void)writeCodeUseOC;

@optional//这里的方法遵从协议的类可以选择实现

- (void)writeCodeUseJava;

@end

协议的特点：

·协议是一种特殊的程序设计结构，用于声明专门被别的类 实现的方法。

·协议本身不是类，是定义其他类可以实现的接口

协议常用的场合：

·声明未知类的接口

·用于两个类之间的通信

遵从协议：

@interface JYMonkey : NSObject<WriteCodeProtocol>

遵从多个协议

<协议1，协议2，协议3，.....>

遵从协议的类要注意：

1>.一个类遵从了协议就要实现协议中规定的方法；一个类遵从了协议该类的对象也就遵从了协议。

2>.遵从协议的id指针，只能指向遵从协议的对象。

3>. 遵从协议的id指针，只能调用协议中规定的方法。

4>.协议中的方法有两类：  @required//在这里的方法遵从协议的类必须实现

@optional//这里的方法遵从协议的类可以选择实现，如果实现了则必须可以调用

协议的作用：

·统一接口

·模拟实现多继承

·实现委托代理

2.代理

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

总而言之，代理模式的基本设计思想就是：两个对象协同解决问题，通常用于对象间的通信。是对象之间数据交换的一种手段。

代理 |  委托方：委托方，制定协议（规定接口）

  | 代理方： 代理方，遵从协议（实现接口）

代理的简单使用：

老板招聘工程师写代码

委托方：老板，制定协议(会写代码)

代理方：工程师，遵从协议(会写代码)

Boss类

//制定协议，规定接口

@protocol WriteCodeProtocol <NSObject>

- (void)writeCode;

@end

@interface JYBoss : NSObject

//要求代理对象必须遵从协议

@property id<WriteCodeProtocol> worker;

- (void)delegateWriteCode;

@end

@implementation JYBoss

- (void)delegateWriteCode

{

    NSLog(@"老板委托工程师写代码");

    [self.worker writeCode];

}

@end

Engineer类

//遵从协议，实现协议中规定的方法

@interface JYEngineer : NSObject<WriteCodeProtocol>

@end

@implementation JYEngineer

- (void)writeCode

{

    NSLog(@"工程师愉快地码着代码");

}

@end

Main

#import "JYBoss.h"

#import "JYEngineer.h"

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

    @autoreleasepool {

        

        JYBoss *boss = [[JYBoss alloc] init];

        JYEngineer *laowang = [[JYEngineer alloc] init];

        //签订劳动合同(建立代理关系)

        boss.worker = laowang;//代理指针指向laowang

        [boss delegateWriteCode];

        

    }

    return 0;

}

代理的作用：

·代理传值

广播站发送消息，收音机接收并播放出来

委托方：广播站，制定协议(接收并播放)

代理方：收音机，遵从协议(能够接收并播放)

//广播类

@protocol receiveAndShowMessage <NSObject>

- (void)receiveAndShowMessage:(NSString *)message;//制定协议要求代理可以接受消息和播放消息

@end

@interface JYBroadcast : NSObject

//定义一个有实现约束的代理

@property id<receiveAndShowMessage> delegate;

//委托需要发送消息

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

@end

@implementation JYBroadcast

- (instancetype)init

{

    if (self = [super init]) {

        JYRadio *radio = [[JYRadio alloc] init];

        //建立代理关系

        _delegate = radio;//遵从协议的id指针，只能指向遵从协议的对象

        //遵从协议的id指针，只能调用遵从协议的方法

    }

    return self;

}

- (void)sendMessage:(NSString *)message

{

    NSLog(@"广播站开始广播");

    [self.delegate receiveAndShowMessage:message];

}

@end

//收音机类

@interface JYRadio : NSObject<receiveAndShowMessage>//遵从协议

@end

@implementation JYRadio

- (void)receiveAndShowMessage:(NSString *)message//实现协议的方法

{

    NSLog(@"%@", message);

}

@end

//Main

#import "JYBroadcast.h"

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

    @autoreleasepool {

        

        JYBroadcast *bbc = [[JYBroadcast alloc] init];

        [bbc sendMessage:@"重大新闻:本周六照常上自习"];

        

    }

    return 0;

}

 代理的回调：

员工要求老板按时发工资

委托方：员工，制定协议(按时发工资)

代理方：老板，遵从协议(必须按时发工资)

员工类

@protocol PayoffOnTime <NSObject>

- (void)payoffWithMoney:(NSUInteger)money;//制定的协议 按时发工资

@end

@interface JYWorker : NSObject

@property id<PayoffOnTime> boss;//定义一个协议类型的指针

- (void)work;//员工应该做的

@end

@implementation JYWorker

- (void)work

{

    NSLog(@"员工努力工作了一个月");

    [_boss payoffWithMoney:15];

}

@end

老板类

@interface JYBoss : NSObject<PayoffOnTime>

@property JYWorker *staff;

- (void)run;

@end

@implementation JYBoss

- (instancetype)init

{

    if (self = [super init]) {

        _staff =[[JYWorker alloc] init];//实例化一个员工//回调用

        //签订劳动合同(建立代理关系)

        _staff.boss = self;//遵从协议的id指针指向JYBoss对象

    }

    return self;

}

- (void)payoffWithMoney:(NSUInteger)money

{

    NSLog(@"老板极不情愿地拿出%luK",money);

}

- (void)run

{

    NSLog(@"公司开始运营");

    [_staff work];

}

@end