代理必须遵守协议，要看到类文件，主函数，还有协议文件

关键词：协议、委托、代理
协议的声明有两种方式：1.单独建立一个协议（Protocol），声明在类的外部：
@protocol ClassBPtotocol <NSObject>
     -(void)classBMethod;
    @end
2.声明在类的内部。（声明在@interface的上面）声明在类的内部，当然就不用引入了， 但同样要遵循这个协议。
OC中虽然没有多继承，但是可以通过协议的方式实现多继承即一个类遵循多个协议，这样这个类接可以继承这多个协议的方法了。
@interface ClassC : NSObject <ClassBPtotocol, ClassAProtocol> // 同时遵守两个协议
一个类在拥有了一个协议之后，首先要引入这个协议，然后还得遵守协议，这样才能实现协议中的方法。(协议写在类的外部)
在协议中声明方法：-(void)server;
在类中引入协议＋遵守协议：#import "WaiterProtocol.h"
        @interface Waiter : NSObject <WaiterProtocol>
引入代理之后会增强程序的扩展性。如：在引进代理之前，我如果要找房子只能让一类人（如中介）去做我的代理，帮我找房子，而引入代理之后，我可以让更多类的人（如：朋友、同学、亲人。。。。）帮我找房子。只要这些类都遵循找房子的协议并且实现里面的方法即可。和继承有些相似。
代理中，委托人要让代理人帮自己去干某些事，委托人就要调用代理人的某些方法，这时，委托人需要将代理人作为自己的一个属性。
@property (nonatomic, assign) id <PersonProtocol> delegate;
这里用到了id，id可以用来表示各种数据类型，只要是遵循了PersonProtocol协议的代理人，委托人都可以调用他们的方法。
[self.delegate server];
在主函数中要实现找房子这个功能，委托人要指定自己的具体代理人，指定中介，或是朋友又或是同学帮自己去找房子，而他们找房子的结果也是不一定完全相同的，可以让你有更多的选择。
Person * liangsen = [[Person alloc] init];
        Waiter * everyone = [[Waiter alloc] init];
        liangsen.delegate = everyone;
        [liangsen buy];
而委托人和代理人的角色是可以相互转换的。如买饭问题。你去饭店买饭，首先你是委托人负责点菜，服务员是代理人负责送菜。点菜的时候，是吃饭人调用服务员的送菜方法。在你吃完饭以后，这时，服务员成了委托人负责收钱，你是代理人负责付钱。收钱的时候是服务员调用吃饭人的付钱方法。（感觉把一件简简单单的事说的好抽象，好复杂。）
在委托人和代理人角色转换的过程中，会有一个重复引用的问题，即A类引入B类的h文件，然后B类又引入A类的h文件，为了防止这种问题，在A类引入B类的h文件之后，B类只需引入A类遵循的协议即可。
@required  @optional    默认的权限是@required
解析：从外到内，注意模型
用了协议和代理之后感觉程序的可扩展性增强了。
父类指针指向子类的对象

首先我写了两个类,A类和B类.  在B中写了一个协议,然后在B中写了方法触发代理方法.  A类中遵守了B类协议,并且实现了协议.
先解释一下下面的代码,这是重点!!!!!(中午写的,,,,,,楼主给点分吧....)
首先B类中写了一个可选的协议,然后在B类的实现中写了一个方法来调用.
A类中遵守了B类的协议,并且设置实现了代理方法.
main函数中,我创建了一个B类对象,然后调用B中启动代理的方法.之后B类就会寻找遵守B类协议的A类,并且执行在A类中实现的代理方法.
这样的话,我就可以在B对象中执行A类中的方法(实际还是B类的代理方法)
好处:可以进行类与类之间的传值.因为有些时候,类之间耦合性太高,不符合面向对象的特征,因此要使用代理,建立两个类之间的关系
下面是具体的代码
AClass.h

1. #import <Foundation/Foundation.h>
   
2. 
   
3. @interface CDAClass : NSObject
   
4. 
   
5. @end

复制代码

AClass.m

1. #import "CDAClass.h"
   
2. #import "CDBClass.h"
   
3. @interface CDAClass()<CDBClassDelegate><span id="transmark"></span>
   
4. @end
   
5. @implementation CDAClass
   
6. - (void)methodDelegateModal:(CDBClass *)cdbclass{
   
7.     NSLog(@"在A类中执行了%s",__func__);
   
8. }
   
9. @end

复制代码

BClass.h      #import <Foundation/Foundation.h>     @class CDBClass;     @protocol CDBClassDelegate<NSObject>     @optional     - (void)methodDelegateModal:(CDBClass*)cdbclass;     @end     @interface CDBClass : NSObject     @property(nonatomic,copy)NSString* name;     @property(nonatomic,weak)id<CDBClassDelegate> delegate;     - (void)runDelegate;     @end   BClass.m      #import "CDBClass.h"     @implementation CDBClass     - (void)runDelegate{         if ([self.delegate respondsToSelector:@selector(methodDelegateModal:)]){             [self.delegate methodDelegateModal:self];         }     }     @end  main函数      #import <Foundation/Foundation.h>     #import "CDBClass.h"     #import "CDAClass.h"     int main(int argc, const char * argv[]) {         @autoreleasepool {             CDBClass* bClass = [[CDBClass alloc]init];             CDAClass* aClass = [[CDAClass alloc]init];             [bClass setDelegate:aClass];             [bClass runDelegate];         }         return 0;     }  代码的执行结果

协议你就定义一个协议就行了  比如说老板让程序员写代码。 定义一个协议 然后程序员具备写代码的能力，然后给老板代理一个对象  老板.delegate=程序员  然后用程序员老板调用写代码就行了

代理模式的结构
　　所谓代理，就是一个人或者机构代表另一个人或者机构采取行动。在一些情况下，一个客户不想或者不能够直接引用一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。

　　代理模式类图如下：
D:\1.近期学习\下载.png
在代理模式中的角色：

　　●　　抽象对象角色：声明了目标对象和代理对象的共同接口，这样一来在任何可以使用目标对象的地方都可以使用代理对象。

　　●　　目标对象角色：定义了代理对象所代表的目标对象。

　　●　　代理对象角色：代理对象内部含有目标对象的引用，从而可以在任何时候操作目标对象；代理对象提供一个与目标对象相同的接口，以便可以在任何时候替代目标对象。代理对象通常在客户端调用传递给目标对象之前或之后，执行某个操作，而不是单纯地将调用传递给目标对象。
源代码

　　抽象对象角色

1. public abstract class AbstractObject {
   
2.     //操作
   
3.     public abstract void operation();
   
4. }

复制代码

       目标对象角色

1. public class RealObject extends AbstractObject {
   
2.     @Override
   
3.     public void operation() {
   
4.         //一些操作
   
5.         System.out.println("一些操作");
   
6.     }
   
7. }

复制代码

      代理对象角色

1. public class ProxyObject extends AbstractObject{
   
2.     RealObject realObject = new RealObject();
   
3.     @Override
   
4.     public void operation() {
   
5.         //调用目标对象之前可以做相关操作
   
6.         System.out.println("before");        
   
7.         realObject.operation();        
   
8.         //调用目标对象之后可以做相关操作
   
9.         System.out.println("after");
   
10.     }
    
11. }

复制代码

      客户端

1. public class Client {
   
2. 
   
3.     public static void main(String[] args) {
   
4.         // TODO Auto-generated method stub
   
5.         AbstractObject obj = new ProxyObject();
   
6.         obj.operation();
   
7.     }
   
8. 
   
9. }

复制代码

从上面的例子可以看出代理对象将客户端的调用委派给目标对象，在调用目标对象的方法之前跟之后都可以执行特定的操作。

//AViewController.m
@property (strong, nonatomic) BViewController *BVC;

— （void)buttonDidClicked:(id)sender{
    self.BVC = [[BViewController alloc]init];
    [self.navigationController pushViewController:self.BVC animated:YES];
}

比如：保姆照顾婴儿吃饭睡觉，保姆是婴儿的代理人，这时要创建两个类：保姆类和婴儿类，同时需要创建一个照顾婴儿的协议，保姆要遵守。让婴儿有体力值和睡眠值的变化，这样可以更清晰的看到保姆照顾了婴儿的生活。

协议文件：lookBabyProtocol.h
#import <Foundation/Foundation.h>
@class baby;
@protocol lookBabyProtocol <NSObject>
//喂婴儿吃饭
-(void)feetBaByEat:(baby *) baby;
//哄婴儿睡觉
-(void)HongBabySleep:(baby *)baby;
@end
婴儿类
(1)声明
baby.h
#import <Foundation/Foundation.h>
@class Baomu;
#import "lookBabyProtocol.h"

@interface baby : NSObject
//体力值，睡眠值，保姆
@property(nonatomic,assign) int blood;
@property(nonatomic,assign) int sleep;
@property Baomu<lookBabyProtocol> *bm;
-(void)wantEat;
-(void)wantSleep;
@end
(2)实现
baby.m
#import "baby.h"
#import "Baomu.h"
@implementation baby
-(void)wantEat{
    NSLog(@"Baby在哭...");
    [self.bm feetBaByEat:self];
}
-(void)wantSleep{
    NSLog(@"Baby在哭...");
    [self.bm HongBabySleep:self];
}

保姆类
(1)声明
baomu.h
#import <Foundation/Foundation.h>
//保姆想成为baby 的代理人，就必须遵守lookBabyProtocol协议
#import "lookBabyProtocol.h"
@interface Baomu : NSObject <lookBabyProtocol>
@end
(2)实现文件
baomu.m
#import "Baomu.h"
#import "baby.h"
@implementation Baomu
//喂婴儿吃饭
-(void)feetBaByEat:(baby *) baby{
    baby.blood +=20;
    NSLog(@"保姆在喂婴儿吃饭,baby.blood = %d",baby.blood);
}
//哄婴儿睡觉
-(void)HongBabySleep:(baby *) baby{
    baby.sleep +=10;
    NSLog(@"保姆在哄婴儿睡觉,baby.sleep = %d",baby.sleep);
}
@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 *bb = [baby new];
        
        bb.blood = 30;
        bb.sleep = 20;
        //婴儿有个保姆
        bb.bm = baomu;
        [bb wantEat];
        [bb wantSleep];   
    }
    return 0;
}

6666666666666666