iOS 中KVC、KVO、NSNotification、delegate 总结及区别

转自：http://www.mamicode.com/info-detail-515516.html

iOS 中KVC、KVO、NSNotification、delegate 总结及区别

 

KVC/KVO原理详解及编程指南

时间 2013-08-04 18:28:55 CSDN博客

原文  http://blog.csdn.net/wzzvictory/article/details/9674431

主题 Objective-C

KVC/KVO原理详解及编程指南

作者： wangzz

原文地址： http://blog.csdn.net/wzzvictory/article/details/9674431

转载请注明出处

前言：

1、本文基本不讲KVC/KVO的用法，只结合网上的资料说说对这种技术的理解。

2、由于 KVO内容较少，而且是以 KVC为基础实现的，本文将着重介绍KVC部分。

一、简介

KVC/KVO是观察者模式的一种实现，在Cocoa中是以被万物之源NSObject类实现的NSKeyValueCoding/NSKeyValueObserving 非正式协议 的形式被定义为基础框架的一部分。 从协议的角度来说，KVC/KVO本质上是定义了一套让我们去遵守和实现的方法。

当然，KVC/KVO实现的根本是Objective-C的动态性和runtime，这在后文的原理部分会有详述。

另外，KVC/KVO机制离不开访问器方法的实现，这在后文中也有解释。

1、KVC简介

全称是Key-value coding，翻译成键值编码。顾名思义，在某种程度上跟map的关系匪浅。它提供了一种使用字符串而不是访问器方法去访问一个对象实例变量的机制。

2、KVO简介

全称是Key-value observing，翻译成键值观察。提供了一种当其它对象属性被修改的时候能通知当前对象的机制。再MVC大行其道的Cocoa中，KVO机制很适合实现model和controller类之间的通讯。

二、KVC相关技术

1、Key和Key Path

KVC定义了一种按名称访问对象属性的机制，支持这种访问的主要方法是：

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

前边两个方法用到的Key较容易理解，就是要访问的属性名称对应的字符串。

后面两个方法用到的KeyPath是一个被点操作符隔开的用于访问对象的指定属性的字符串序列。比如KeyPath address.street将会访问消息接收对象所包含的address属性中包含的一个street属性。其实KeyPath说白了就是我们平时使用点操作访问某个对象的属性时所写的那个字符串。

2、点语法和KVC

在实现了访问器方法的类中，使用点语法和KVC访问对象其实差别不大，二者可以任意混用。但是没有访问起方法的类中，点语法无法使用，这时KVC就有优势了。（ 原因见第三部分的第一节：KVC如何访问属性值。 ）

3、一对多关系（To-Many）中的集合访问器方法

我们平时大部分使用的属性都是一对一关系（To-One）,比如Person类中的name属性，每个人只有一个名字。但也有一对多的关系，比如Person中有一个friendsName属性，这是个集合（在Objective-C中可以是NSArray，NSSet等），保存的是一个人的所有朋友的名字。

当操作一对多的属性中的内容时，我们有两种选择：

①间接操作

先通过KVC方法取到集合属性，然后通过集合属性操作集合中的元素。

②直接操作

苹果为我们提供了一些方法模板，我们可以以规定的格式实现这些方法来达到访问集合属性中元素的目的。

有序集合对应方法如下：

-countOf<Key>
    //必须实现，对应于NSArray的基本方法count:
    -objectIn<Key>AtIndex:
    -<key>AtIndexes:
    //这两个必须实现一个，对应于 NSArray 的方法 objectAtIndex: 和 objectsAtIndexes:
    -get<Key>:range:
    //不是必须实现的，但实现后可以提高性能，其对应于 NSArray 方法 getObjects:range:
    
    -insertObject:in<Key>AtIndex:
    -insert<Key>:atIndexes:
    //两个必须实现一个，类似于 NSMutableArray 的方法 insertObject:atIndex: 和 insertObjects:atIndexes:
    -removeObjectFrom<Key>AtIndex:
    -remove<Key>AtIndexes:
    //两个必须实现一个，类似于 NSMutableArray 的方法 removeObjectAtIndex: 和 removeObjectsAtIndexes:
    -replaceObjectIn<Key>AtIndex:withObject:
    -replace<Key>AtIndexes:with<Key>:
    //可选的，如果在此类操作上有性能问题，就需要考虑实现之

无序集合对应方法如下：

-countOf<Key>
    //必须实现，对应于NSArray的基本方法count:
    -objectIn<Key>AtIndex:
    -<key>AtIndexes:
    //这两个必须实现一个，对应于 NSArray 的方法 objectAtIndex: 和 objectsAtIndexes:
    -get<Key>:range:
    //不是必须实现的，但实现后可以提高性能，其对应于 NSArray 方法 getObjects:range:
    
    -insertObject:in<Key>AtIndex:
    -insert<Key>:atIndexes:
    //两个必须实现一个，类似于 NSMutableArray 的方法 insertObject:atIndex: 和 insertObjects:atIndexes:
    -removeObjectFrom<Key>AtIndex:
    -remove<Key>AtIndexes:
    //两个必须实现一个，类似于 NSMutableArray 的方法 removeObjectAtIndex: 和 removeObjectsAtIndexes:
    -replaceObjectIn<Key>AtIndex:withObject:
    -replace<Key>AtIndexes:with<Key>:
    //这两个都是可选的，如果在此类操作上有性能问题，就需要考虑实现之

不过这些方法除非是很有需求，否则个人认为没有实现的必要，间接法也不是很麻烦，基本能满足需求了。值得指出的是，苹果甚至都没有让这些方法以哪怕是非正式协议的形式出现，而只是在编程指南中提了一下。

4、键值验证（Key-Value Validation）

KVC提供了验证Key对应的Value是否可用的方法：

- (BOOL)validateValue:(inout id *)ioValue forKey:(NSString *)inKey error:(out NSError **)outError;

该方法默认的实现是调用一个如下格式的方法：

- (BOOL)validate<Key>:error:

比如属性name对应的方法为：

-(BOOL)validateName:(id *)ioValue error:(NSError * __autoreleasing *)outError {
    // Implementation specific code.
    return ...;
}

这样就给了我们一次纠错的机会。

需要指出的是， KVC是不会自动调用键值验证方法的 ，就是说我们需要手动验证。但是有些技术，比如CoreData会自动调用。

5、KVC对数值和结构体型属性的支持

一套机制如果不支持数值和结构体型的数据，那么它的实用性就会大大折扣。幸运的是KVC中苹果对这方面的支持做的很好。KVC可以自动的将数值或结构体型的数据打包或解包成NSNumber或NSValue对象，以达到适配的目的。

举个例子，Person类有个个NSInteger类型的age属性

①修改值

我们通过KVC技术使用如下方式设置age属性的值：

[person setValue:[NSNumber numberWithInteger:5] forKey:@"age"];

我们赋给age的是一个NSNumber对象， KVC会自动的将NSNumber对象转换成NSInteger对象 ，然后再 调用相应的访问器方法设置age的值。

②获取值

同样，以如下方式获取age属性值：

[person valueForKey:@"age"];

这时，会以NSNumber的形式返回age的值。

需要说明的是，什么时候返回的是NSNumber，什么时候返回的是NSValue？

③使用NSNumber封装

可以使用NSNumber的数据类型有：

+ (NSNumber *)numberWithChar:(char)value;
+ (NSNumber *)numberWithUnsignedChar:(unsigned char)value;
+ (NSNumber *)numberWithShort:(short)value;
+ (NSNumber *)numberWithUnsignedShort:(unsigned short)value;
+ (NSNumber *)numberWithInt:(int)value;
+ (NSNumber *)numberWithUnsignedInt:(unsigned int)value;
+ (NSNumber *)numberWithLong:(long)value;
+ (NSNumber *)numberWithUnsignedLong:(unsigned long)value;
+ (NSNumber *)numberWithLongLong:(long long)value;
+ (NSNumber *)numberWithUnsignedLongLong:(unsigned long long)value;
+ (NSNumber *)numberWithFloat:(float)value;
+ (NSNumber *)numberWithDouble:(double)value;
+ (NSNumber *)numberWithBool:(BOOL)value;
+ (NSNumber *)numberWithInteger:(NSInteger)value NS_AVAILABLE(10_5, 2_0);
+ (NSNumber *)numberWithUnsignedInteger:(NSUInteger)value NS_AVAILABLE(10_5, 2_0);

总之就是一些常见的数值型数据。

④使用NSValue封装

NSValue主要用于处理结构体型的数据，它本身提供了如下集中结构的支持：

+ (NSValue *)valueWithCGPoint:(CGPoint)point;
+ (NSValue *)valueWithCGSize:(CGSize)size;
+ (NSValue *)valueWithCGRect:(CGRect)rect;
+ (NSValue *)valueWithCGAffineTransform:(CGAffineTransform)transform;
+ (NSValue *)valueWithUIEdgeInsets:(UIEdgeInsets)insets;
+ (NSValue *)valueWithUIOffset:(UIOffset)insets NS_AVAILABLE_IOS(5_0);

只有有限的6种而已！那对于其它自定义的结构体怎么办？别担心，任何结构体都是可以转化成NSValue对象的，具体实现方法参见我之前的一篇文章：

http://blog.csdn.net/wzzvictory/article/details/8614433

6、集合运算符（Collection Operators）

集合运算符是一个特殊的Key Path，可以作为参数传递给valueForKeyPath：方法， 注意只能是这个方法 ，如果传给了valueForKey:方法保证你程序崩溃。

运算符是一个以@开头的特殊字符串，格式如下图所示：

①简单集合运算符

简单集合运算符共有@avg，@count，@max，@min，@sum5种，都表示啥不用我说了吧， 目前还不支持自定义 。

有一个集合类的对象：transactions，它存储了一个个的Transaction类的实例，该类有三个属性：payee，amount，date。下面以此为例说明如何使用这些运算符：

要获取amount的平均值可以这样：

NSNumber *transactionAverage = [transactions valueForKeyPath:@"@avg.amount"];

要获取transactions集合中元素数目可以这样：

NSNumber *numberOfTransactions = [transactions valueForKeyPath:@"@count"];

需要之处的是，@count是这些集合运算符中比较特殊的一个，因为它没有右路经，原因很容易理解。

②对象运算符

比集合运算符稍微复杂，能以数组的方式返回指定的内容，一共有两种：

@distinctUnionOfObjects
@unionOfObjects

它们的返回值都是NSArray，区别是前者返回的元素都是唯一的，是去重以后的结果；后者返回的元素是全集。

用法如下：

NSArray *payees = [transactions valueForKeyPath:@"@distinctUnionOfObjects.payee"];
NSArray *payees = [transactions valueForKeyPath:@"@unionOfObjects.payee"];

前者会将收款人的姓名去除重复的以后返回，后者直接返回所有收款人的姓名。

③Array和Set操作符

这种情况更复杂了，说的是集合中包含集合的情况，我们执行了如下的一段代码：

// Create the array that contains additional arrays.
self.arrayOfTransactionsArray = [NSMutableArray array];
 
// Add the array of objects used in the above examples.
[arrayOfTransactionsArray addObject:transactions];
 
// Add a second array of objects; this array contains alternate values.
[arrayOfTransactionsArrays addObject:moreTransactions];

得到了一个包含集合的集合：arrayOfTransactionsArray

这时如果我们想操作 arrayOfTransactionsArray中包含的集合中的元素时，可以使用如下三个运算符：

@distinctUnionOfArrays
@unionOfArrays
@distinctUnionOfSets

前两个针对的集合是Arrays，后一个针对的集合是Sets。 因为Sets中的元素本身就是唯一的，所以没有对应的@unionOfSets运算符。

它们的用法举例如下：

NSArray *payees = [arrayOfTransactionsArrays valueForKeyPath:@"@unionOfArrays.payee"];

三、实现原理

1、KVC如何访问属性值

KVC再某种程度上提供了访问器的替代方案。不过访问器方法是一个很好的东西，以至于只要是有可能，KVC也尽量再访问器方法的帮助下工作。为了设置或者返回对象属性，KVC按顺序使用如下技术：

①检查是否存在-<key>、-is<key>（只针对布尔值有效）或者-get<key>的访问器方法，如果有可能，就是用这些方法返回值；

检查是否存在名为-set<key>:的方法，并使用它做设置值。对于 -get<key>和 -set<key>:方法，将大写Key字符串的第一个字母，并与Cocoa的方法命名保持一致；

②如果上述方法不可用，则检查名为-_<key>、-_is<key>（只针对布尔值有效）、-_get<key>和-_set<key>:方法；

③如果没有找到访问器方法，可以尝试直接访问实例变量。实例变量可以是名为：<key>或_<key>;

④如果仍为找到，则调用valueForUndefinedKey:和setValue:forUndefinedKey:方法。这些方法的默认实现都是抛出异常，我们可以根据需要重写它们。

2、KVC/KVO实现原理

键值编码和键值观察是根据isa-swizzling技术来实现的，主要依据runtime的强大动态能力。下面的这段话是引自网上的一篇文章：

http://blog.csdn.net/kesalin/article/details/8194240

当某个类的对象第一次被观察时， 系统就会在运行期动态地创建该类的一个派生类，在这个派生类中重写基类中任何被观察属性的 setter 方法。
派生类在被重写的 setter 方法实现真正的通知机制 ，就如前面手动实现键值观察那样。这么做是基于设置属性会调用 setter 方法，而通过重写就获得了 KVO 需要的通知机制。当然前提是要通过遵循 KVO 的属性设置方式来变更属性值，如果仅是直接修改属性对应的成员变量，是无法实现 KVO 的。
同时派生类还重写了 class 方法以“欺骗”外部调用者它就是起初的那个类。然后系统将这个对象的 isa 指针指向这个新诞生的派生类，因此这个对象就成为该派生类的对象了，因而在该对象上对 setter 的调用就会调用重写的 setter，从而激活键值通知机制。此外，派生类还重写了 dealloc 方法来释放资源。

原文写的很好，还举了解释性的例子，大家可以去看看。

在我之前的一篇介绍Objective-C类和元类的文章：

http://blog.csdn.net/wzzvictory/article/details/8592492

中介绍过，isa指针指向的其实是类的元类，如果之前的类名为：Person，那么被runtime更改以后的类名会变成：NSKVONotifying_Person。

新的 NSKVONotifying_Person类会重写以下方法：

增加了监听的属性对应的set方法，class，dealloc，_isKVOA。

①class

重写class方法是为了我们调用它的时候返回跟重写继承类之前同样的内容。

打印如下内容：

NSLog(@"self->isa:%@",self->isa);
NSLog(@"self class:%@",[self class]);

在建立KVO监听前，打印结果为：

self->isa:Person
self class:Person

在建立KVO监听之后，打印结果为：

self->isa:NSKVONotifying_Person
self class:Person

这也是isa指针和class方法的一个区别 ，大家使用的时候注意。

②重写set方法

新类会重写对应的set方法，是为了在set方法中增加另外两个方法的调用：

- (void)willChangeValueForKey:(NSString *)key
- (void)didChangeValueForKey:(NSString *)key

其中，didChangeValueForKey:方法负责调用：

- (void)observeValueForKeyPath:(NSString *)keyPath
                      ofObject:(id)object
                        change:(NSDictionary *)change
                       context:(void *)context

方法， 这就是KVO实现的原理了！

如果没有任何的访问器方法，-setValue:forKey方法会直接调用：

- (void)willChangeValueForKey:(NSString *)key
- (void)didChangeValueForKey:(NSString *)key

如果在没有使用键值编码且没有使用适当命名的访问起方法的时候，我们只需要显示调用上述两个方法，同样可以使用KVO！

总结一下，想使用KVO有三种方法：

1)使用了KVC

使用了KVC，如果有访问器方法，则运行时会在访问器方法中调用 will/didChangeValueForKey:方法；

没用访问器方法，运行时会在setValue:forKey方法中调用 will/didChangeValueForKey:方法。

2)有访问器方法

运行时会重写访问器方法调用 will/didChangeValueForKey:方法。

因此，直接调用访问器方法改变属性值时，KVO也能监听到。

3)显示调用will/didChangeValueForKey:方法。

总之，想使用KVO，只要有 will/didChangeValueForKey:方法就可以了。

③ _isKVOA

这个私有方法估计是用来标示该类是一个 KVO 机制声称的类。

四、优点和缺点

1、优点

①可以再很大程度上简化代码

例子网上很多，这就不举了

②能跟脚本语言很好的配合

才疏学浅，没学过AppleScript等脚本语言，所以没能深刻体会到该优点。

2、缺点

KVC的缺点不明显，主要是KVO的，详情可以参考这篇文章：

http://www.mikeash.com/pyblog/key-value-observing-done-right.html

核心思想是说KVO的回调机制，不能传一个selector或者block作为回调，而必须重写-addObserver:forKeyPath:options:context:方法所引发的一系列问题。问了解决这个问题，作者还亲自实现了一个MAKVONotificationCenter类，代码见github:

https://github.com/mikeash/MAKVONotificationCenter

不过个人认为这只是苹果做的KVO不够完美，不能算是缺陷。

KVC, KVO实现原理剖析

字数1263 阅读287 评论0 喜欢0

iPhone程序开发 KVO/KVC实现机理分析是本文要介绍的内容，不多说，直接进入话题。我们来看详细内容。

Objective-C里面的Key-Value Observing (KVO)机制，非常不错，可以很好的减少浇水代码。关于KVO的学习，可以参考文章：《Key-Value Observing快速入门》：http://www.cocoadev.cn/Objective-C/Key-Value-Observing-Quick-Start-cn.asp

Key-Value Coding（KVC）实现分析

KVC运用了一个isa-swizzling技术。isa-swizzling就是类型混合指针机制。KVC主要通过isa-swizzling，来实现其内部查找定位的。isa指针，如其名称所指，（就是is a kind of的意思），指向维护分发表的对象的类。该分发表实际上包含了指向实现类中的方法的指针，和其它数据。

比如说如下的一行KVC的代码：

[site setValue:@"sitename" forKey:@"name"];

就会被编译器处理成：

SEL sel = sel_get_uid ("setValue:forKey:");

IMP method = objc_msg_lookup (site->isa,sel);

method(site, sel, @"sitename", @"name");

Selectors

Selectors are the run-time system's identifier for a method. TheSELdata type is used for selectors.

Thesel_get_uid()function can be used to get a method's selector from it's name:

objc_msg_lookup

If we want to get anIMPusing the Objective-C runtime functions, then useobjc_msg_lookup(id,SEL)on the GNU runtime.

What is an IMP? How do I get one?

IMPis a C type referring to theimplementationof a method, also known as animplementation pointer. It's a pointer to a function returningid, and withselfand amethod selector(available inside method definitions as the variable_cmd) as the first arguments:

id (*IMP)(id, SEL, ...);

With NSObject, you can obtain theIMPfor a given method by doing:

IMP imp=[obj methodForSelector:@selector(message)];

For Object, do:

IMP imp=[obj methodFor:@selector(message)];

How do I send a message given an IMP?

Dereference it, as with a C function pointer:

id anObject, theResult;

IMP someImp;

SEL aSelector;

// ...

theResult=someImp(anObject,aSelector);

=================

When an observer is registered for an attribute of an object the isa pointer of the observed object is modified, pointing to an intermediate class rather than at the true class. As a result the value of the isa pointer does not necessarily reflect the actual class of the instance.

Instead of relying on the isa pointer your application should use the class method to determine the class of an object instance.

首先介绍两个基本概念：

（1）SEL数据类型：它是编译器运行Objective-C里的方法的环境参数。

（2）IMP数据类型：他其实就是一个 编译器内部实现时候的函数指针。当Objective-C编译器去处理实现一个方法的时候，就会指向一个IMP对象，这个对象是C语言表述的类型（事实上，在Objective-C的编译器处理的时候，基本上都是C语言的）。

关于如何找到实现函数的指针，可参考文章：《Objective-C如何避免动态绑定，而获得方法地址》：http://www.cocoadev.cn/Objective-C/Get-method-address.asp

这下KVC内部的实现就很清楚的清楚了：一个对象在调用setValue的时候，（1）首先根据方法名找到运行方法的时候所需要的环境参数。（2）他会从自己isa指针结合环境参数，找到具体的方法实现的接口。（3）再直接查找得来的具体的方法实现。

Key-Value Observing（KVO）实现

在上面所介绍的KVC机制上加上KVO的自动观察消息通知机制就水到渠成了。

当观察者为一个对象的属性进行了注册，被观察对象的isa指针被修改的时候，isa指针就会指向一个中间类，而不是真实的类。所以isa指针其实不需要指向实例对象真实的类。所以我们的程序最好不要依赖于isa指针。在调用类的方法的时候，最好要明确对象实例的类名。

熟悉KVO的朋友都知道，只有当我们调用KVC去访问key值的时候KVO才会起作用。所以肯定确定的是，KVO是基于KVC实现的。其实看了上面我们的分析以后，关系KVO的架构的构思也就水到渠成了。

因为KVC的实现机制，可以很容易看到某个KVC操作的Key，而后也很容易的跟观察者注册表中的Key进行匹对。假如访问的Key是被观察的Key，那么我们在内部就可以很容易的到观察者注册表中去找到观察者对象，而后给他发送消息。

总结一下，想使用KVO有三种方法：

1)使用了KVC

使用了KVC，如果有访问器方法，则运行时会在访问器方法中调用will/didChangeValueForKey:方法；

没用访问器方法，运行时会在setValue:forKey方法中调用will/didChangeValueForKey:方法。

2)有访问器方法

运行时会重写访问器方法调用will/didChangeValueForKey:方法。

因此，直接调用访问器方法改变属性值时，KVO也能监听到。

3)显示调用will/didChangeValueForKey:方法。

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

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：

1. @interface myPerson : NSObject  
2. {  
3.     NSString *_name;  
4.     int      _age;  
5.     int      _height;  
6.     int      _weight;  
7. }  
8. @end  
9.   
10. @interface testViewController : UIViewController  
11. @property (nonatomic, retain) myPerson *testPerson;  
12.   
13. - (IBAction)onBtnTest:(id)sender;  
14. @end  
15.   
16. - (void)testKVO  
17. {  
18.     testPerson = [[myPerson alloc] init];  
19.       
20.     [testPerson addObserver:self forKeyPath:@"height" options:NSKeyValueObservingOptionNew context:nil];  
21. }  
22.   
23. - (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context  
24. {  
25.     if ([keyPath isEqualToString:@"height"]) {  
26.         NSLog(@"Height is changed! new=%@", [change valueForKey:NSKeyValueChangeNewKey]);  
27.     } else {  
28.         [super observeValueForKeyPath:keyPath ofObject:object change:change context:context];  
29.     }  
30. }  
31.   
32. - (IBAction)onBtnTest:(id)sender {  
33.     int h = [[testPerson valueForKey:@"height"] intValue];      
34.     [testPerson setValue:[NSNumber numberWithInt:h+1] forKey:@"height"];  
35.     NSLog(@"person height=%@", [testPerson valueForKey:@"height"]);  
36. }  
37.   
38. - (void)dealloc  
39. {  
40.     [testPerson removeObserver:self forKeyPath:@"height" context:nil];  
41.     [super dealloc];  
42. }  

第一段代码声明了myPerson类，里面有个_height的属性。在testViewController有一个testPerson的对象指针。
      在testKVO这个方法里面，我们注册了testPerson这个对象height属性的观察，这样当testPerson的height属性变化时， 会得到通知。在这个方法中还通过NSKeyValueObservingOptionNew这个参数要求把新值在dictionary中传递过来。
      重写了observeValueForKeyPath:ofObject:change:context:方法，这个方法里的change这个NSDictionary对象包含了相应的值。
      需要强调的是KVO的回调要被调用，属性必须是通过KVC的方法来修改的，如果是调用类的其他方法来修改属性，这个观察者是不会得到通知的。

3、NSNotification的用法见http://blog.csdn.net/eduora_meimei/article/details/44198909

 

区别：

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.当释放观察者时不需要移除观察者。

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只是一对一，而这两个可以一对多。这两者也有各自的特点。