OC中的类扩展和协议

关于OC的Category、Extension和Protocol

1、Category：具名类扩展

• 有如下分数（Fraction）类：

@interface Fraction : NSObject

@property int numerator, denominator;   //分子、分母

-(void) setTo: (int) n over: (int) d;   //设置分子n，分母d
-(void) reduce;                         //没有功能
-(double) convertToNum;                 //转换分数为实数
-(void)print;                           //打印该分数

@end

使用Category以模块化风格来添加类接口中的方法。

比如对于框架类，你需要对某个类增加一个特殊方法，这时有两种选择

第一种是从零开始实现一个该类的子类，然后写新方法

第二种是使用更简单的方法：使用Category。

Category：在原有类中增加新方法，并以模块化风格编写代码（并不需要拥有原有类的源码），不需要新建子类。

假设想在Fraction中添加一些数学方法，可以使用Category添加，Category的声明如下所示：

//为fraction类增加数学方法：
//Category的头文件命名规则是：原类名 “+” Category名，如这个就是Fraction+MathOps。
//Category的声明其实可以在类的头文件中进行，但是为了模块化，更好的办法是分开一个头文件出来。
//Category名为MathOps，是类Fraction的Category。

@interface Fraction (MathOps)

-(Fraction *) add: (Fraction *) f;
-(Fraction *) sub: (Fraction *) f;
-(Fraction *) mul: (Fraction *) f;
-(Fraction *) div: (Fraction *) f;

-(void)displayAdd: (Fraction *) f;
-(void)displaySub: (Fraction *) f;
-(void)displayMul: (Fraction *) f;
-(void)displayDiv: (Fraction *) f;

@end

实现这些方法后，在Fraction类对象中就可以直接使用这些方法了。

1.1关于Category的注意事项：

• (1) 最好不要在Category中覆盖原类中的方法。因为覆盖后，原方法就无法访问了。若确实需要覆盖原类方法，最好是新建子类进行覆盖，因为原类方法可以用super访问。

• (2) 一个类可以有若干的Category。但是若有一个方法在两个以上的Category中定义，OC并不会指定哪个方法会被使用。

• (3) 一个类Category中的方法会被子类继承。对NSObject根类使用Category的话，这样可能会有潜在风险。因为每个它的子类都会继承这个方法，不管你想不想继承。

• (4) 最好是不要用Category来将Square类改造为Circle（即不要使用Category将一个类改造成另外一种类），这是一种不好的编程方法。

• (5) Category与类名的组合，也必须是唯一的。如：Fraction+MathOps，在工程中必须是唯一的。NSString中的Utilities Category只能存在于特定OC命名空间。这在编写屏幕保护程序、控制面板程序和其他插件时很重要，因为代码会被插入到这些程序以外的其他应用或框架中。

2、Class Extension：匿名类扩展

Class Extension:在原类中增加新方法（需要类的源码），不需要新建子类，也称为匿名Category，因为其声明方式就是不指定Category名称.

如Fraction的Class Extension：

@interface Fraction()
//some methods... 
@end

正是因为这个Class Extension的匿名，所以方法的实现就是在原来的类中添加的，这也是为什么需要拥有类的源码。

附上Fraction类的实现和类扩展MathOps的实现：

• Fraction类的实现代码：

#import "Fraction.h"

@implementation Fraction



-(void)setTo:(int)n over:(int)d
{
    [self setNumerator:n];
    [self setDenominator:d];
}

-(void)reduce
{
    NSLog(@"No such function.");
}

-(void)print
{
    NSLog(@"%i / %i",self.numerator,self.denominator);
}

-(double)convertToNum
{
    return self.numerator / self.denominator;
}


@end

• Fraction类的具名类扩展MathOps实现代码：

#import "Fraction+MathOps.h"

@implementation Fraction (MathOps)

-(Fraction *) add:(Fraction *)f
{
    Fraction* result = [[Fraction alloc]init];
    result.numerator = (self.numerator * f.denominator) + (self.denominator * f.numerator);
    result.denominator = self.denominator * f.denominator;
    return result;
}

-(Fraction *) sub:(Fraction *)f
{
    Fraction* result = [[Fraction alloc]init];
    result.numerator = (self.numerator * f.denominator) - (self.denominator * f.numerator);
    result.denominator = self.denominator * f.denominator;
    return result;

}

-(Fraction *) mul:(Fraction *)f
{
    Fraction* result = [[Fraction alloc]init];
    result.numerator = self.numerator * f.numerator;
    result.denominator = self.denominator * f.denominator;
    return result;

}

-(Fraction *) div: (Fraction *) f
{
    Fraction* result = [[Fraction alloc]init];
    result.numerator = self.numerator * f.denominator;
    result.denominator = self.denominator * f.numerator;
    return result;
}

-(void)displayAdd:(Fraction *)f
{
    Fraction* result = [[Fraction alloc]init];
    result = [self add:f];
    NSLog(@"%i / %i + %i / %i = %i / %i",self.numerator,self.denominator,f.numerator,f.denominator,result.numerator,result.denominator);
}

-(void)displaySub:(Fraction *)f
{
    Fraction* result = [[Fraction alloc]init];
    result = [self sub:f];
    NSLog(@"%i / %i - %i / %i = %i / %i",self.numerator,self.denominator,f.numerator,f.denominator,result.numerator,result.denominator);
}

-(void)displayMul:(Fraction *)f
{
    Fraction* result = [[Fraction alloc]init];
    result = [self mul:f];
    NSLog(@"%i / %i × %i / %i = %i / %i",self.numerator,self.denominator,f.numerator,f.denominator,result.numerator,result.denominator);
}

-(void)displayDiv:(Fraction *)f
{
    Fraction* result = [[Fraction alloc]init];
    result = [self div:f];
    NSLog(@"%i / %i ➗ %i / %i = %i / %i",self.numerator,self.denominator,f.numerator,f.denominator,result.numerator,result.denominator);
}

@end

3、Protocol：协议

PIOW内说的相当明确：A protocol is a list of methods that is shared among classes.The methods listed in the protocol do not have corresponding implementations.

协议是一个共享方法的列表，定义协议的人并不需要实现协议内的方法。

相对地，这些方法的实现是由其他人（他们的类遵循或接受这个协议）完成的。

协议是一系列方法的集合，它有协议名称，通过这个协议，其他人能够知道里面的方法具体实现何种功能，并在他们自己的类（遵循或接受这个协议）中实现这些方法。

协议内定义的是一个通用的标准，接受这个协议的类都必须遵从的标准。

协议中的方法有required和optional之分。

3.1 协议的定义和接受格式：

比如框架中的NSCopying协议：

@protocol NSCopying
-(id)copyWithZone: (NSZone *)zone;
@end

相应地，你的类如果要接受这个协议，声明的格式如下：

@interface AddressBook : NSObject <NSCopying>

如果一个类接受多个协议，则协议名用逗号分隔，如下所示：

@interface AddressBook : NSObject <NSCopying，NSCoding>

假如需要在屏幕显示的对象就需要Drawing功能，可以让这些类统一接受一个Drawing协议：

@protocol Drawing
//默认是required
-(void)print;
-(void)erase;
@optional
-(void)outline;
@end

如果你声明了遵从某个协议，但没有实现协议方法，编译器只会提出警告，而不会报错。

可以使用conformsToProtocol：方法来查看某个对象是否接受某个协议：

id currentObject;
...
if([currentObject conformsToProtocol:@protocol(Drawing)] == YES)
{
    ...
}

向编译器明确表示某个对象遵从一个协议：

Fraction <Drawing> *f3 = [[Fraciton alloc]init];

上面的代码说明f3对象是遵从Drawing协议的。

如果向编译器表示一个对象遵守多个方法，加逗号即可。。。

（在变量名前面加星号是更加可靠的编程写法）

3.2 关于协议的继承：

协议的继承问题分两类：一类是接受协议的类的子类继承协议的问题，另外一类是协议本身继承另外的协议。

先看第一个：

• 当一个类接受某协议，并实现了协议内的方法，那它的子类也自动地接受这个协议。并且由于子类继承了父类方法，当没有重新实现这些协议方法（即使父类中的方法在子类中有可能不适用）时，也不会报错。

第二个：

• 说一个协议继承另外一个协议，也可以理解为一个协议同时遵从另外一个协议，语法如下：

@protocol Drawing3D <Drawing>

如果一个类遵从Drawing3D，意思是说：这个类遵从Drawing3D协议，同时遵从Drawing协议，即这个类同时实现了这两个协议中的方法。

3.3类扩展也可以接受协议

比如类扩展Stuff，同时接受NSCopying和NSCoding协议:

@interface Fraction (Stuff) <NSCopying,NSCoding>

这里是Fraction类的Stuff扩展，它接受NSCopying和NSCoding协议。

如果你不想让别人从类的接口文件中看到这个类接受的一些特殊协议，可以将协议指定在类扩展中，如下所示：

@interface ProfilePreviewController () <NavigationBarAdjustments>
...
@end

和类名一样，协议名也必须唯一。

总地来说，一个类的可用方法有这些：

1.从父类继承来的方法；

2.声明在自身接口中的方法；

3.声明在类扩展中的（具名或匿名，对应Category和Class Extension）方法；

4.接受的协议中的方法。

4、Delegation：委托

可以将两个类之间的公共接口也看做是一个协议。