类别与扩展

前言

我们在开发项目时，可能会需要为已有的类扩展一些新的行为，关于这种扩展方式，最容易想起的就是继承，子类可以在父类的基础上添加新的方法，也可以重写父类已有的方法。但有时候，扩展并不是最好的选择，比如我们希望为NSNumber类新增一些方法，但由于NSNumber实际上只是一个类簇（cluster）的前端类，比如，通过[NSNumbernumberWithInt:5]方法所生成的NSNumber对象其实只是NSNumber子类的实例。那么即使我们为NSNumber派生子类也没有任何意义，派生的子类对NSNumber现有的子类并没有任何影响。此时就需要借助类别（category）来实现。

类别（category）

Objective-C的动态特征允许使用类别为现有的类添加新方法，并且不需要创建子类，不需要访问原有类的源代码。
通过使用类别，我们可以动态地为现有的类添加新方法，而且可以将类定义模块化地分布到多个相关文件中。
类别同样有接口和实现部分组成，接口部分的语法格式如下：

@interface 已有类(类别名)
//方法定义
···
@end

注意上面的语法格式，虽然这个语法格式看上去很像在定义类，但在类名后有一个圆括号，而且圆括号中带一个类别名。
定义类别的语法与定义类的语法存在如下差异：
1. 定义类时使用的类名必须是该项目中没有的类，而定义类别时使用的类名必须是已有的类。
2.定义类别是必须使用圆括号来包含类别名。
3.类别中通常只定义方法。

类别 实现部分的语法格式如下：

@implmentation 已有类 （类别名)
//方法实现
···
@end

增加类别的例子

//定义一个类别
@interface NSNumber (fk)
//定义四个方法
-(NSNumber*) add: (double) num2;
-(NSNumber*) substract: (double) num2;
-(NSNumber*) multiply: (double) num2;
-(NSNumber*) divide: (double) num2;
@end

#import "NSNumber+fk.h"
//为类别提供实现部分
@implementation NSNumber(fk)
-(NSNumber*) add: (double) num2
{
    return [NSNumber numberWithDouble: ([self doubleValue] + num2)];
    
}
-(NSNumber*) substract:(double)num2
{
    return [NSNumber numberWithDouble: ([self doubleValue] - num2)];
}
-(NSNumber*) multiply:(double)num2
{
    return [NSNumber numberWithDouble:([self doubleValue] * num2)];
}
-(NSNumber*) divide:(double)num2
{
    return [NSNumber numberWithDouble:([self doubleValue] / num2)];
}
@end

#import <Foundation/Foundation.h>
#import "NSNumber+fk.h"
int main(int argc , char * argv[])
{
    @autoreleasepool {
        NSNumber* myNum = [NSNumber numberWithInt:3];
        NSNumber* add = [myNum add:2.4];
        NSLog(@"%@" , add);
        NSNumber* substract = [myNum substract:2.4];
        NSLog(@"%@", substract);
        NSNumber* multiply = [myNum multiply:2.4];
        NSLog(@"%@", multiply);
        NSNumber* divide = [myNum divide:2.4];
        NSLog(@"%@",divide);
        
    }
}

上面为NSNumber定义了fk类别，该类别的实例具有add:、substract:、multiply:和divide:方法，这就实现了对原有NSNumber类的动态扩展。通过测试我们可以看到以下运行结果:

我们可以看到，定义的类别中的四个方法实现了。
虽然类别可以重写原有类中的方法，但通常并不推荐这样做，如果你需要重写原有类的方法，更好的建议是通过原有类派生子类，然后在子类中重写父类原有的方法。
关于类别，还有两点说明：
1.通过类别为指定类添加新方法之后，这个新方法不仅会影响NSNumber类，还会影响NSNumber类的所有子类，每个子类都会获取类别扩展的方法。
2.可根据需要为一个类定义多个类别，不同的类别都可对原有的类增加方法定义。
类别的3种用法：
1.利用类别对类进行模块化设计。
2.使用类别来调用私有方法。
3.使用类别来实现非正式协议。

利用类别对类进行模块化设计

当一个类非常大时，如果将该类的所有实现代码放在一个文件中，将会导致这个文件非常大，以至于维护起来非常困难。如果需要讲一个较大的类分模块设计，使用类别是一个不错的选择。
例如我们查看NSWindow类：

@interface NSWindow : NSResponder<NSAnimatablePropertyContainer,NSUserInterfaceValidations, NSUserInterfaceItemIdentification>

还可以看到以下类别:

@interface NSWindow(NSKeyboardUI)
@interface NSWindow(NSToolbarSupport)
@interface NSWindow(NSDrag)
@interface NSWindow(NSCarbonExtensions)

我们可以看到，NSWindow可以分别提供NSWindow.m、NSWindow+NSKeyboardUI.m、NSWindow+NSToolbarSupport.m、NSWindow+NSDrag.m和NSWindow+NSCarbonExtensions实现文件，通过这种方式就可以对类实现按模块分布到不同的*.m文件中，从而提高项目后期的可维护性。

使用类别来调用私有方法

前面在介绍定义类时提到，没有在接口部分定义而是在类实现部分定义的方法相当于私有方法，通常不允许被调用。但后面也说过，OC没有真正私有的方法，如果NSObject的performSelector：方法来执行动态调用，完全可以调用那些私有方法。
但如果使用performSelector:来执行调用，则完全避开了编译器的语法检查，有时候未必是一种好的做法。除了使用performSelector：方法来动态调用那些私有方法之外，还可以通过类别来定义前向引用，从而实现对私有方法的调用。

事例

先定义一个FKCar的接口代码：

#import <Foundation/Foundation.h>
@interface FKItem : NSObject
@property(nonatomic , assign)double price;
-(void) info;
@end

接下来定义一个实现部分：

#import "FKItem.h"

@implementation FKItem
@synthesize price;
-(void) info
{
    NSLog(@"这是一个普通的方法");
}
-(double) calDiscount: (double) discount
{
    return self.price * discount;
}
@end

接下来我们来写main（）函数：

#import <Foundation/Foundation.h>
#import "FKItem.h"
@interface FKItem (fk)
-(double) calDiscount: (double)discount;
@end
int main(int argc , char * argv[])
{
    @autoreleasepool {
        FKItem* item = [[FKItem alloc] init];
        item.price = 109;
        [item info];
        NSLog(@"物品打折的价格为: %g",[item calDiscount: .75]);
    }
}

我们可以看到在main()函数之前我们先定义了一个类别，这个类别也让FKItem类中增加并实现了calDiscount：方法，所以我们在main()函数里就可以直接调用了。

运行结果如图所示：

扩展（extension）

扩展与类别相似，扩展相当于匿名类别，定义扩展的语法格式如下：

@interface 已有类 ()
{
	实例变量
}
//方法定义
···
@end

从上面语法中可以看出来，扩展相当于定义一个匿名的类别。但就用法来看，类别通常有单独的*.h和*.m文件，扩展则用于临时对某个类的接口进行扩展，类实现部分同时实现类接口部分定义的方法和扩展中定义的方法。
定义类的扩展时，可以额外增加实例变量，也可以使用@property、@synthesize来合成setter、getter方法，但定义类的列表时，则不允许额外定义实例变量。

事例

我们先定义Car的接口部分：

#import <Foundation/Foundation.h>
@interface Car : NSObject
@property (nonatomic , copy)NSString* brand;
@property (nonatomic , copy)NSString* model;
-(void) drive;
@end

然后我们拓展一下这个类：

#import <Foundation/Foundation.h>
#import "Car.h"
@interface Car()
@property (nonatomic , copy)NSString* color;
-(void) drive: (NSString*)owner;
@end

需要注意的是我们需要重新创建一个*.h文件，名为：“Car+drive.h”，然后接下来我们在*.m的文件中实现：

#import"Car+drive.h"
@implementation Car
@synthesize brand;
@synthesize model;
@synthesize color;
-(void) drive;
{
    NSLog(@"%@汽车正在路上奔驰", self);
}
-(void) drive:(NSString *)owner
{
    NSLog(@"%@正驾驶%@汽车在路上奔驰",owner, self);

}
-(NSString*) description
{
    return [NSString stringWithFormat:@"<FK[brand = %@, model = %@, color = %@]>",self.brand,self.model,self.color];
}
@end

最后我们在main()函数中测试：

#import <Foundation/Foundation.h>
#import "Car+drive.h"
int main(int argc , char * argv[])
{
    @autoreleasepool {
        Car* car = [[Car alloc] init];
        car.brand = @"宝马";
        car.model = @"X5";
        car.color = @"红色";
        [car drive];
        [car drive:@"马思唯"];
    }
}