黑马程序员---OC Prorocol代理模式

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

一、什么事代理模式？

        代理模式是在oc中经常遇到的一种设计模式，那什么叫做代理模式呢？ 举个例子：有一个婴儿，他本身不会自己吃饭和洗澡等等一些事情，于是婴儿就请了一个保姆，于是婴儿和保姆之间商定了一个协议，协议中写明了保姆需要做什么事情， 而保姆就是这个代理人，  即：婴儿和保姆之间有个协议，保姆继承该协议，于是保姆就需要实现该协议中的条款成为代理人。 

二、 代理模式的关键点：

     A完成一件事，但是自己不能完成，于是他找个代理人B 替他完成这个事情，他们之间便有个协议 （protocol），B继承该协议来完成A代理给他的事情。  

三、实例分析

    下面来举一个经典的实例，妈妈和保姆的例子：妈妈把孩子委托给保姆照顾，于是将需要完成的事情写成一个协议：协议声明如下：

  #import <Foundation/Foundation.h>  @protocol Job <NSObject>  -(void)takeEat;  -(void)takeSleep;  -(void)takePlay;  -(void)takeShower;  @end  

我们再声明Nurse类 即代理的人： 

 #import <Foundation/Foundation.h>  #import "Job.h"  @interface Nurse : NSObject<Job>//实现该协议  @end  

实现文件：

#import "Nurse.h"  @implementation Nurse  -(void)takeEat  {      NSLog(@"小孩饿了，喂它吃饭");  }  -(void)takeSleep  {      NSLog(@"小孩困了，哄他睡觉");  }  -(void)takePlay  {      NSLog(@"小孩醒来了，陪他玩");  }  -(void)takeShower  {      NSLog(@"晚上给小孩洗澡");  }  -(void)dealloc  {      NSLog(@"Nurse is dealloc");  }  @end  

再声明一个morther类：
 

#import <Foundation/Foundation.h>  #import "Job.h"  @class Nurse;  @interface Morther : NSObject  {      NSString *name;      id<Job> delegate;   //此处声明一个代理人，从而mother可以让代理人完成需要代理的事情  }  -(id)initWithName:(NSString *)_name delagat:(id<Job>)_delagete;  //传入代理人  @property(nonatomic,copy)NSString *name;  -(void)delagateThings;// 被代理的事情  @end  

//实现文件
 

#import "Morther.h"  #import "Nurse.h"  @implementation Morther  -(id)initWithName:(NSString *)_name delagat:(id)_delagete  {      self=[super init];      if (self) {          if (name!=_name) {              [name release];              name=[_name copy];              [delegate release];              delegate=[_delagete retain];          }      }      return self;  }  @synthesize name;  -(void)dealloc  {      [name release];      [delegate release];      NSLog(@"host is dealloc");  }  -(void)delagateThings  {      int i;      switch (i) {          case 1:              [delegate takeEat];              break;          case 2:              [delegate takePlay];              break;          case 3:              [delegate takeShower];              break;          case 4:              [delegate takeSleep];              break;          default:              break;      }      i++;  }  @end  

看看 在 main 文件中是怎么实现的： 
 

#import <Foundation/Foundation.h>  #import "Morther.h"  #import "Nurse.h"  #import "Job.h"  int main (int argc, const charchar * argv[])  {        @autoreleasepool {                    NSString *name=[[NSString alloc] initWithFormat:@"小花"];          Nurse *fengjie=[[Nurse alloc] init];//代理人 fengjie          Morther *morther=[[Morther alloc] initWithName:name delagat:fengjie];//这样就将代理人传入mother 对象中，这样morther对象便可以通过nurse来完成她自己不能坐的事情了。          [name release];          [NSTimer scheduledTimerWithTimeInterval:2 target:morther selector:@selector(delagateThings)userInfo:nil repeats:YES];  //调用机制，  2秒调用一次， 调用的对象是morther ， 调用的方法是delagateThings；          [[NSRunLoop currentRunLoop] run];  //让程序一直运行下去，保证上面的调用可以一直进行          [morther release];          [fengjie release];          }      return 0;  }   

代理中，需要记住的关键是在发出代理请求的类（A）中声明代理人（B）的实例变量，这样就可以保证A 能通过调用B中B代理的方法来完成B代理的事情，即自己代理给B 的事情 

四、代理的应用（设计模式——代理模式）

MyProtocal1.h://这是协议类 #import <Foundation/Foundation.h>  @protocol MyProtocol1 <NSObject> //这是基协议，一定要遵守  @required //默认required，必须要实现  - (void)test1;  - (void)test2;  @optional //可选实现  - (void)test3;  @end  MyProtocal2.h://这是协议类 #import <Foundation/Foundation.h>  @protocol MyProtocol2  - (void)haha2;  @optional  - (void)haha3;  @end  

只要一个类遵守了一份协议，就能拥有这份协议中的所有方法声明
协议不能写实现，仅仅添加方法声明
协议和分类一样，不能写成员变量
 : 继承父类
 <> 遵守协议

Person.h:

#import <Foundation/Foundation.h>  #import "MyProtocol1.h"  #import "MyProtocol2.h"  @interface Person : NSObject <MyProtocol1,MyProtocol2> //类似java中的接口，OC也可以实现多个协议  @end 

基本用途：
>可以声明一堆方法，单不能声明成员变量
>只要某个类遵守了这个协议，就相当于拥有这个协议中的所有方法声明
>只要父类遵守了某个协议，就相当于子类也遵守了
>用于代理模式和观察者模式
>一个协议可以遵守另一个协议：

@protocol MyProtocol2 <MyProtocol1>  - (void)haha;  @end  

5    代理模式设计

1、代理的设计原理：某个类不想亲自实现某些方法，就定义成员变量或者属性，该成员变量实现了这些方法，就可以通过成员变量去调用方法。这个成员变量指向的对象就叫做代理对象。
2、设计原则：
   (1) 得拥有某个代理对象属性
   (2)清楚代理有哪些方法
   (3)要保证能解耦
3、实现方案：
   (1) 定义一个protocol，在其中声明一些和代理沟通的方法
   (2) 拥有一个代理属性id delegate
   (3) 让代理遵守protocol

TicketDelegate.h 声明一些跑腿方法  

@protocol TicketDelegate <NSObject>     // 返回票价  - (double) ticketPrice;    // 还剩多少张票  - (int) leftTicketsNumber;    @end  

Agent.h，代理对象  

@interface Agent : NSObject <TicketDelegate>     @end    @implementation Agent    //Agent.m  // 剩余的票数  - (int)leftTicketsNumber  {      // ... 亲自跑电影院\或者打电话            return 1;  }    // 每一张票多少钱  - (double)ticketPrice  {      // ... 亲自跑电影院\或者打电话      return 1000;  }  @end  

 NextAgent.h，代理对象  

@interface Agent : NSObject <TicketDelegate>     @end    @implementation Agent    //NextAgent.m  // 剩余的票数  - (int)leftTicketsNumber  {            return 500;  }    // 每一张票多少钱  - (double)ticketPrice  {            return 10;  }  @end  

Person.h  

@interface Person : NSObject    - (void) buyTicket;    // 拥有一个代理属性  // id代表代理的类名随便  // 但必须遵守TicketDelegate协议  @property (nonatomic, retain) id<TicketDelegate>  delegate;    @end    //Person.m  @implementation Person    // 买电影票  - (void)buyTicket  {      // 叫代理去帮自己买票（询问一下票价、询问一下票的剩余张数）      double price = [_delegate ticketPrice];      int number =  [_delegate leftTicketsNumber];            NSLog(@"通过代理的帮忙，票价=%f，还剩%d张票", price, number);  }    - (void)dealloc  {      [_delegate release];      [super dealloc];  }  @end  

  

int main(int argc, const charchar * argv[])  {      // 人      Person *p = [[Person alloc] init];      // 代理      Agent *a = [[Agent alloc] init];  //第一个代理      NextAgent *na = [[NextAgent alloc] init];    //第二个代理        // 设置人的代理      p.delegate = a;            // 人打算看电影      [p buyTicket];            // 设置人的代理      p.delegate = na;            // 人打算看电影      [p buyTicket];          [a release];      [na release];      [p release];        return 0;  }