Tables	Are	PS
1	KVC	YES
2	KVO	YES
3	通知	YES
4	属性	YES
5	协议	YES
6	几种模式的优劣	YES
7	几种模式的对比	YES
8	引用	YES

1、KVC，即是指 NSKeyValueCoding，一个非正式的Protocol，提供一种机制来间接访问对象的属性。而不是通过调用Setter、Getter方法访问。KVO 就是基于 KVC 实现的关键技术之一。

Demo：

@interface myPerson : NSObject
{    
        NSString*_name;    
        int      _age;    
        int      _height;    
        int      _weight;

} 
@end

@interface testViewController :UIViewController 
@property (nonatomic, retain) myPerson*testPerson;  
@end

 

- (void)testKVC

{    

testPerson = [[myPerson alloc] init];        

 NSLog(@"testPerson‘s init height =%@", [testPerson valueForKey:@"height"]);    

[testPerson setValue:[NSNumber numberWithInt:168]forKey:@"height"];    NSLog(@"testPerson‘s height = %@", [testPerson valueForKey:@"height"]);

}

第一段代码是定义了一个myPerson的类，这个类有一个_height的属性，但是没有提供任何getter／setter的访问方法。同时在testViewController这个类里面有一个myPerson的对象指针。

当myPerson实例化后，常规来说是无法访问这个对象的_height属性的，不过通过KVC我们做到了，代码就是testKVC这个函数。

运行之后打印值就是：

2015-3-13 11:16:21.970 test[408:c07] testPerson‘s init height = 0

2015-3-13 11:16:21.971 test[408:c07] testPerson‘s height = 168

这就说明确实读写了_height属性。
KVC的常用方法：

- (id)valueForKey:(NSString *)key; 
- (void)setValue:(id)value forKey:(NSString *)key;

valueForKey的方法根据key的值读取对象的属性，setValue:forKey:是根据key的值来写对象的属性。

注意：

1. key的值必须正确，如果拼写错误，会出现异常

2. 当key的值是没有定义的，valueForUndefinedKey:这个方法会被调用，如果你自己写了这个方法，key的值出错就会调用到这里来

3. 因为类key反复嵌套，所以有个keyPath的概念，keyPath就是用.号来把一个一个key链接起来，这样就可以根据这个路径访问下去

4. NSArray/NSSet等都支持KVC

---

2、KVO的是KeyValue Observe的缩写，中文是键值观察。这是一个典型的观察者模式，观察者在键值改变时会得到通知。iOS中有个Notification的机制，也可以获得通知，但这个机制需要有个Center，相比之下KVO更加简洁而直接。

KVO的使用也很简单，就是简单的3步。

1. 注册需要观察的对象的属性addObserver:forKeyPath:options:context:
2. 实现observeValueForKeyPath:ofObject:change:context:方法，这个方法当观察的属性变化时会自动调用
3. 取消注册观察removeObserver:forKeyPath:context:

Demo：

@interface myPerson : NSObject  
{  
    NSString *_name;  
    int      _age;  
    int      _height;  
    int      _weight;  
}  
@end  
  
@interface testViewController : UIViewController  
@property (nonatomic, retain) myPerson *testPerson;  
  
- (IBAction)onBtnTest:(id)sender;  
@end  
  
- (void)testKVO  
{  
    testPerson = [[myPerson alloc] init];  
      
    [testPerson addObserver:self forKeyPath:@"height" options:NSKeyValueObservingOptionNew context:nil];  
}  
  
- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context  
{  
    if ([keyPath isEqualToString:@"height"]) {  
        NSLog(@"Height is changed! new=%@", [change valueForKey:NSKeyValueChangeNewKey]);  
    } else {  
        [super observeValueForKeyPath:keyPath ofObject:object change:change context:context];  
    }  
}  
  
- (IBAction)onBtnTest:(id)sender {  
    int h = [[testPerson valueForKey:@"height"] intValue];      
    [testPerson setValue:[NSNumber numberWithInt:h+1] forKey:@"height"];  
    NSLog(@"person height=%@", [testPerson valueForKey:@"height"]);  
}  
  
- (void)dealloc  
{  
    [testPerson removeObserver:self forKeyPath:@"height" context:nil];  
    [super dealloc];  
}  

第一段代码声明了myPerson类，里面有个_height的属性。在testViewController有一个testPerson的对象指针。

在testKVO这个方法里面，我们注册了testPerson这个对象height属性的观察，这样当testPerson的height属性变化时， 会得到通知。在这个方法中还通过NSKeyValueObservingOptionNew这个参数要求把新值在dictionary中传递过来。

重写了observeValueForKeyPath:ofObject:change:context:方法，这个方法里的change这个NSDictionary对象包含了相应的值。

需要强调的是KVO的回调要被调用，属性必须是通过KVC的方法来修改的，如果是调用类的其他方法来修改属性，这个观察者是不会得到通知的。

3、NSNotification的用法见

NSNotificationCenter提供了一种更加解耦的方式。最典型的应用就是任何对象都可以发送通知到中心，同时任何对象可以监听中心的通知。

发送通知的代码如下：
[[NSNotificationCenter defaultCenter] postNotificationName:@"myNotificationName" object:broadcasterObject];

注册接收通知的代码如下：
[[NSNotificationCenter defaultCenter] addObserver:listenerObject     selector:@selector(receivingMethodOnListener:)     name:@”myNotificationName”    object:nil];

注册通知的时候可以指定一个具体的广播者对象，但这不是必须的。你可能注意到了defaultCenter。实际上这是你在应用中会使用到的唯一的中心。通知会向整个应用开放，因此只有一个中心。

同时还有一个NSDistributedNotificationCenter。这是用来应用间通信的。在整个计算机上只有一个该类型的中心。

优点: 通知的发送者和接受者都不需要知道对方。可以指定接收通知的具体方法。通知名可以是任何字符串。

缺点: 较键值观察需要多点代码。在删掉前必须移除监听者。不能传大量数值，只能让谁去做什么事。

4.属性

1. 属性传值第一步需要用到什么类型就定义什么样的属性
2. 从上一个页面到一个页面的选中方法里面将要传的值传到来（上一个页面）备注：这种方法只适用于上一个页面推到下一个页面。

如：MainViewController与SecondViewController两个视图控制器，点击MainViewController中的按钮将跳转到SecondViewController视图，同时想要传递一个值过去。这时可以利用属性传值。
首先SecondViewController视图中需要有一个属性用来存储传递过来的值：

@property(nonatomic,retain) NSString *firstValue ;//属性传值
然后MainViewController视图需要引用SecondViewController视图的头文件，在视图中的按钮点击事件中，通过SecondViewController的对象将需要传递的值存在firstValue中:
(void)buttonAction:(UIButton *)button
{
SecondViewController *second =
[[SecondViewController alloc]init];//用下一个视图的属性接受想要传过去的值,属性传值
second.firstValue = _txtFiled.text;
[self.navigationControllerpushViewController:second animated:YES];
}

页面跳转之后，就能在SecondViewController视图中，通过存值的属性，取用刚才传递过来的值：

显示传过来的值[_txtFiledsetText:_firstValue];//firstValue保存传过来的值

5.协议和代理

协议（protocol），就是使用了这个协议后，必须按照协议规定的内容来处理事情，协议中要求的方法必须实现（@optional的方法除外）。
protocol是一种语法，它提供了一个很方便的、实现delegate模式的机会。
定义protocol如下：

@protocol ClassBDelegate<NSObject> 
- (void)methodOne; 
@optional 
 - (void)methodTwo:(NSString *)value; 
@end

//定义了一个ClassB的协议，这个协议中包含两个方法，其中methodTwo为可选的。
//在ClassA的头文件（ClassA.h）中定义这个协议，如下代码：
@interface ClassA<ClassBDelegate> 
@end
//在ClassA的实现文件（ClassA.m）中实现ClassBDelegate的两个方法，其中methodTwo可以不实现，如下：
- (void)methodOne{ 
      // 具体实现内容 
  } 
   
- (void)methodTwo:(NSString *)value{  
      // 具体实现内容   
  }

---

代理（delegate），顾名思义就是委托别人办事，当一件事情发生后，自己不处理，让别人来处理。

delegate和protocol没有关系。delegate本身是一种设计模式。是把一个类自己需要做的一部分事情，让另一个类（也可以就是自己本身）来完成。
在ClassB的头文件（ClassB.h）中定义一个代理如下：

@interface ClassB 
@property (nonatomic, unsafe_unretained) id<ClassBDelegate> delegate; 
@end 
这样，当我们在ClassB的实现文件（ClassB.m）中遇到想让别的类（如 ClassA）处理的问题时，就可以这样
  [self.delegate methodOne]; 
  [self.delegate methodTwo:@"需要传递的值"];

6.几个观察者模式的优劣

delegate 的 优势 ：

1. 非常严格的语法。所有将听到的事件必须是在delegate协议中有清晰的定义。
2. 如果delegate中的一个方法没有实现那么就会出现编译警告/错误
3. 协议必须在controller的作用域范围内定义
4. 在一个应用中的控制流程是可跟踪的并且是可识别的；
5. 在一个控制器中可以定义定义多个不同的协议，每个协议有不同的delegates
6. 没有第三方对象要求保持/监视通信过程。
7. 能够接收调用的协议方法的返回值。这意味着delegate能够提供反馈信息给controller

缺点 ：

1. 需要定义很多代码：
   1.协议定义；
   2.controller的delegate属性；
   3.在delegate本身中实现delegate方法定义

2. 在释放代理对象时，需要小心的将delegate改为nil。一旦设定失败，那么调用释放对象的方法将会出现内存crash

3. 在一个controller中有多个delegate对象，并且delegate是遵守同一个协议，但还是很难告诉多个对象同一个事件，不过有可能。

---

notification的 优势 ：

1. 不需要编写多少代码，实现比较简单；

2. 对于一个发出的通知，多个对象能够做出反应，即1对多的方式实现简单

3. controller能够传递context对象（dictionary），context对象携带了关于发送通知的自定义的信息

缺点 ：

1. 在编译期不会检查通知是否能够被观察者正确的处理；

2. 在释放注册的对象时，需要在通知中心取消注册；

3. 在调试的时候应用的工作以及控制过程难跟踪；

4. 需要第三方来管理controller与观察者对象之间的联系；

5. controller和观察者需要提前知道通知名称、UserInfodictionary keys。如果这些没有在工作区间定义，那么会出现不同步的情况；

6. 通知发出后，controller不能从观察者获得任何的反馈信息。

---

KVO的 优势 ：

1. 能够提供一种简单的方法实现两个对象间的同步。例如：model和view之间同步；

2. 能够对非我们创建的对象，即内部对象的状态改变作出响应，而且不需要改变内部对象（SKD对象）的实现；

3. 能够提供观察的属性的最新值以及先前值；

4. 用key paths来观察属性，因此也可以观察嵌套对象；

5. 完成了对观察对象的抽象，因为不需要额外的代码来允许观察值能够被观察

缺点 ：

1. 我们观察的属性必须使用strings来定义。编译器才不会出现警告以及检查；

2. 对属性重构将导致我们的观察代码不再可用；

3. 复杂的“IF”语句要求对象正在观察多个值。这是因为所有的观察代码通过一个方法来指向；

4 .当释放观察者时不需要移除观察者。

7.几种模式的对比

1. 效率肯定是delegate比NSNotification高。

delegate方法比notification更加直接，最典型的特征是，delegate方法往往需要关注返回值，也就是delegate方法的结果。
比如- windowShouldClose:，需要关心返回的是yes还是no。所以delegate方法往往包含 should这个很传神的词。也就是好比你做我的delegate，我会问你我想关闭窗口你愿意吗？你需要给我一个答案，我根据你的答案来决定如何做下一步。
相反的，notification最大的特色就是不关心接受者的态度，我只管把通告放出来，你接受不接受就是你的事情，同时我也不关心结果。所以notification往往用did这个词汇，比如NSWindowDidResizeNotification，那么NSWindow对象放出这个notification后就什么都不管了也不会等待接 受者的反应。

2、KVO和NSNotification的区别：

和delegate一样，KVO和NSNotification的作用也是类与类之间的通信，与delegate不同的是

1. 这两个都是负责发出通知，剩下的事情就不管了，所以没有返回值；
2. delegate只是一对一，而这两个可以一对多。这两者也有各自的特点。

8.引用

http://www.mamicode.com/info-detail-515516.html
http://blog.csdn.net/eduora_meimei/article/details/44198909