分类(category)、协议(protocol)

～～～～我的生活，我的点点滴滴！！

1、Category

Objective-C提供了一种与众不同的方式——Category，可以动态的为已经存在的类添加新的行为。这样可以保证类

的原始设计规模较小，功能增加时再逐步扩展。使用Category对类进行扩展时，不需要访问其源代码，也不需要创

建子类。Category使用简单的方式，实现了类的相关方法的模块化，把不同的类方法分配到不同的分类文件中。
 
实现起来很简单，我们举例说明。

SomeClass.h
@interface SomeClass : NSObject{
}
-(void) print;
@end 

这是类SomeClass的声明文件，其中包含一个实例方法print。如果我们想在不修改原始类、不增加子类的情况下，为

该类增加一个hello的方法，只需要简单的定义两个文件SomeClass+Hello.h和SomeClass+Hello.m，在声明文件和实现

文件中用“()”把Category的名称括起来即可。声明文件代码如下：

#import "SomeClass.h"
 
@interface SomeClass (Hello)
-(void)hello;
@end

实现文件代码如下:

#import "SomeClass+Hello.h"
@implementationSomeClass (Hello)
-(void)hello{
    NSLog (@"name：%@ ", @"Jacky");
}
@end 

其中Hello是Category的名称，如果你用XCode创建Category，那么需要填写的内容包括名称和要扩展的类的名称。这里还

有一个约定成俗的习惯，将声明文件和实现文件名称统一采用“原类名+Category”的方式命名。

调用也非常简单，毫无压力，如下：

首先引入Category的声明文件，然后正常调用即可。

#import "SomeClass+Hello.h"
 
SomeClass * sc =[[SomeClass alloc] init];
[sc hello] 

执行结果是：

name：Jacky

Category的使用场景：

1、当你在定义类的时候，在某些情况下（例如需求变更），你可能想要为其中的某个或几个类中添加方法。

2、一个类中包含了许多不同的方法需要实现，而这些方法需要不同团队的成员实现

3、当你在使用基础类库中的类时，你可能希望这些类实现一些你需要的方法。
 
遇到以上这些需求，Category可以帮助你解决问题。当然，使用Category也有些问题需要注意，

1、Category可以访问原始类的实例变量，但不能添加变量，如果想添加变量，可以考虑通过继承创建子类。

2、Category可以重载原始类的方法，但不推荐这么做，这么做的后果是你再也不能访问原来的方法。如果确实要重载，正确

的选择是创建子类。

3、和普通接口有所区别的是，在分类的实现文件中可以不必实现所有声明的方法，只要你不去调用它。
 
用好Category可以充分利用Objective-C的动态特性，编写出灵活简洁的代码。

2、Protocol

在ObjC中使用@protocol定义一组方法规范，实现此协议的类必须实现对应的方法。熟悉面向对象的童鞋都知道接口本身是对象行

为描述的协议规范。也就是说在ObjC中@protocol和其他语言的接口定义是类似的，只是在ObjC中interface关键字已经用于定义类了，

因此它不会再像C#、Java中使用interface定义接口了。

假设我们定义了一个动物的协议AnimalDelegate，人员Person这个类需要实现这个协议，请看下面的代码：

AnimalDelegate.h

//定义一个协议
@protocol AnimalDelegate <NSObject>


@required //必须实现的方法
-(void)eat;


@optional //可选实现的方法
-(void)run;
-(void)say;
-(void)sleep;


@end

Person.h

#import <Foundation/Foundation.h>
#import "AnimalDelegate.h"


@interface Person : NSObject<AnimalDelegate>


-(void)eat;


@end

Person.m

#import "Person.h"


@implementation Person


-(void)eat{
    NSLog(@"eating...");
}


@end

这里需要说明几点：


1、一个协议可以扩展自另一个协议，例如上面AnimalDelegate就扩展自NSObject，如果需要扩展多个协议中间使用逗号分隔；

2、和其他高级语言中接口不同的是协议中定义的方法不一定是必须实现的，我们可以通过关键字进行@required和@optional

进行设置，如果不设置则默认是@required（注意ObjC是弱语法，即使不实现必选方法编译运行也不会报错）；

3、协议通过<>进行实现，一个类可以同时实现多个协议，中间通过逗号分隔；

4、协议的实现只能在类的声明上,不能放到类的实现上（也就是说必须写成@interface Person:NSObject<AnimalDelegate>

而不能写成@implementation Person<AnimalDelegate>）；

5、协议中不能定义属性、成员变量等,只能定义方法；


事实上在ObjC中协议的更多作用是用于约束一个类必须实现某些方法，而从面向对象的角度而言这个类跟接口并不一定存在某种

自然关系，可能是两个完全不同意义上的事物,这种模式我们称之为代理模式（Delegation）。在Cocoa框架中大量采用这种模式

实现数据和UI的分离，而且基本上所有的协议都是以Delegate结尾。



现在假设需要设计一个按钮，我们知道按钮都是需要点击的，在其他语言中通常会引入事件机制，只要使用者订阅了点击事件，

那么点击的时候就会触发执行这个事件（这是对象之间解耦的一种方式：代码注入）。但是在ObjC中没有事件的定义，而是使用

代理来处理这个问题。首先在按钮中定义按钮的代理，同时使用协议约束这个代理（事件的触发者）必须实现协议中的某些方法，

当按钮处理过程中查看代理是否实现了这个方法，如果实现了则调用这个方法。


KCButton.h

#import <Foundation/Foundation.h>
@class KCButton;


//一个协议可以扩展另一个协议，例如KCButtonDelegate扩展了NSObject协议
@protocol KCButtonDelegate <NSObject>


@required //@required修饰的方法必须实现
-(void)onClick:(KCButton *)button;


@optional //@optional修饰的方法是可选实现的
-(void)onMouseover:(KCButton *)button;
-(void)onMouseout:(KCButton *)button;


@end

@interface KCButton : NSObject


#pragma mark - 属性
#pragma mark 代理属性，同时约定作为代理的对象必须实现KCButtonDelegate协议
@property (nonatomic,retain) id<KCButtonDelegate> delegate;


#pragma mark - 公共方法
#pragma mark 点击方法
-(void)click;


@end

KCButton.m

#import "KCButton.h"


@implementation KCButton


-(void)click{
    NSLog(@"Invoke KCButton's click method.");
    //判断_delegate实例是否实现了onClick:方法（注意方法名是"onClick:",后面有个:）
    //避免未实现ButtonDelegate的类也作为KCButton的监听
    if([_delegate respondsToSelector:@selector(onClick:)]){
        [_delegate onClick:self];
    }
}


@end

MyListener.h

#import <Foundation/Foundation.h>
@class KCButton;
@protocol KCButtonDelegate;


@interface MyListener : NSObject<KCButtonDelegate>
-(void)onClick:(KCButton *)button;
@end

MyListener.m

#import "MyListener.h"
#import "KCButton.h"


@implementation MyListener
-(void)onClick:(KCButton *)button{
    NSLog(@"Invoke MyListener's onClick method.The button is:%@.",button);
}
@end

main.m

#import <Foundation/Foundation.h>
#import "KCButton.h"
#import "MyListener.h"


int main(int argc, const char * argv[]) {
    @autoreleasepool {
        
        KCButton *button=[[KCButton alloc]init];
        MyListener *listener=[[MyListener alloc]init];
        button.delegate=listener;
        [button click];
        /* 结果：
         Invoke KCButton's click method.
         Invoke MyListener's onClick method.The button is:<KCButton: 0x1001034c0>.
         */
    }
    return 0;
}

我们通过例子模拟了一个按钮的点击过程，有点类似于Java中事件的实现机制。通过这个例子我们需要注意以下几点内容：


1、id可以表示任何一个ObjC对象类型，类型后面的”<协议名>“用于约束作为这个属性的对象必须实现该协议(注意：使用id定义的

对象类型不需要加“*”)；


2、MyListener作为事件触发者，它实现了KCButtonDelegate代理（在ObjC中没有命名空间和包的概念，通常通过前缀进行类的划分，

“KC”是我们自定义的前缀）


3、在.h文件中如果使用了另一个文件的类或协议我们可以通过@class或者@protocol进行声明，而不必导入这个文件，这样可以提高编

译效率（注意有些情况必须使用@class或@protocol，例如上面KCButton.h中上面声明的KCButtonDelegate协议中用到了KCButton类，而

此文件下方的KCButton类声明中又使用了KCButtonDelegate，从而形成在一个文件中互相引用关系，此时必须使用@class或者@protocol

声明，否则编译阶段会报错），但是在.m文件中则必须导入对应的类声明文件或协议文件（如果不导入虽然语法检查可以通过但是编译链

接会报错）；


4、使用respondsToSelector方法可以判断一个对象是否实现了某个方法（需要注意方法名不是”onClick”而是“onClick:”，冒号也是

方法名的一部分）；