OC学习笔记——类别与扩展

在开发项目的过程中，有时候需要在已有类上新增新的行为，利用继承可以重写父类方法，还能添加新方法，是一种好的扩展方式。
但有的时候，继承干不了我们想干的事：如我们希望为NSNumber类新增一些方法，使其子类都能共享这些方法，使用继承显然实现不了。这个时候，就要通过类别来实现。

类别

OC的动态特征允许使用类别为现有类添加新方法，不需要创建子类，也不需要访问原有类的源代码。
通过使用类别，我们可以动态地为现有类添加新方法，并且可以将类定义模块化地分布到多个相关文件中。
定义类别与定义类相似，也由接口部分和实现部分组成。

接口部分语法：

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

实现部分语法：

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

定义类别与定义类的差别在于类名后有一个圆括号，里面带有一个类别名。定义类的类名必须是该项目中没有的类，而定义类别的类名必须是已有的。

#import <Foundation/Foundation.h>

@interface NSNumber (my)

- (NSNumber *)add:(double)num2;

@end

@implementation NSNumber (my)

- (NSNumber *)add:(double)num2 {
    return [NSNumber numberWithDouble:([self doubleValue] + num2)];
}

@end

int main() {
    @autoreleasepool {
        NSNumber *num = [NSNumber numberWithInt:3];
        NSNumber *add = [num add:2.4];
        NSLog(@"%@", add);
    }
}

输出：

这样程序就有了add:方法，实现了对NSNumber类的动态扩展。

值得注意的是，通过类别为指定类添加新方法后，这个新方法不仅会影响NSNumber类，还会影响NSNumber类的所有子类，相当于每个子类都进行了扩展。而且对于某个类，我们可以定义多个类别，这些类别都可以对原有的类增加方法定义。

虽然类别可以重写原有类中的方法，但通常不建议这么做，因为派生子类是更加符合逻辑的方法。
那么类别在OC中的用途是什么？主要用途有3种：

• 进行模块化设计
• 调用私有方法
• 实现非正式协议

接下来我们来了解这3种用法。

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

一般在定义类时，我们使用 .h 文件来定义类接口部分，使用 .m 文件来定义类实现部分，但我们不能将一个类的类实现部分分布到多个 .m 文件中。当某个类非常大的时候，将所有实现部分放在一个文件中会使文件臃肿，维护的代价很大。这个时候，我们就可以使用类别，将一个类进行分模块设计。
举个例子，我们打开NSNumber的头文件，简单分析可以发现，头文件中包含NSNumber类的接口定义：

@interface NSValue : NSObject <NSCopying, NSSecureCoding>
@interface NSNumber : NSValue
...

属性定义：

@property (readonly) char charValue;
@property (readonly) unsigned char unsignedCharValue;
@property (readonly) short shortValue;
@property (readonly) unsigned short unsignedShortValue;
...
...

还有若干类别定义：

@interface NSValue (NSValueCreation)
@interface NSValue (NSValueExtensionMethods)
@interface NSNumber (NSNumberCreation)
@interface NSValue (NSDeprecated)
...

通过这种方式，NSNumber可以分别提供NSNumber.m、NSNumber+NSValueCreation.m、NSNumber+NSValueExtensionMethods.m、NSNumber+NSNumberCreation.m、NSNumber+NSDeprecated.m等实现文件，将类实现部分按不同模块分化到不同的 *.m 文件中，提高项目的后期可维护性。

使用类别调用私有方法

在类接口部分没有定义，仅在类实现部分的定义的方法相当于私有方法，原则上是不允许被调用的。但OC实际上并没有真正的私有方法，其实通过NSObject提供的performSelector:方法执行动态调用，我们可以调用那些私有方法。
但使用performSelector:方法完全绕过了编译器的语法检查，这样做有时会遇到一些棘手的问题。我们可以通过类别来定义前向引用，从而实现对私有方法的调用。

#import <Foundation/Foundation.h>

@interface Item : NSObject

@property(nonatomic, assign)double price;
- (void)info;

@end

@implementation Item

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

@end

@interface Item (discount)

- (double)calDiscount:(double)discount;

@end

int main() {
    @autoreleasepool {
        Item *item = [[Item alloc] init];
        item.price = 100;
        [item info];
        NSLog(@"物品的价格为：%g", [item calDiscount:0.75]);
    }
}

输出：

在main函数前定义了该类别后，Item类别中就增加了calDiscount:方法，这相当于告诉编译器Item类中可以包含calDiscount:方法，程序可以正常运行。

扩展

扩展与类别相似，相当于匿名类别。
定义扩展语法：

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

就用法来看，类别有单独的 .m 和 .h 文件，扩展则用于对某个类的接口进行临时补充，类实现部分同时实现类接口部分定义的方法和扩展中定义的方法。
定义类的扩展时，可以额外增加实例变量，也可以使用@property、@synthesize来定义属性，但定义类的列表时，不允许额外定义实例变量。

#import <Foundation/Foundation.h>

@interface Car : NSObject

@property(nonatomic, copy)NSString *brand;
@property(nonatomic, copy)NSString *model;
- (void)drive;

@end

@interface Car()

@property(nonatomic, copy)NSString *color;
- (void)drive:(NSString *)owner;

@end

@implementation Car

- (void)drive {
    NSLog(@"%@汽车正在路上行驶", self);
}
- (void)drive:(NSString *)owner {
    NSLog(@"%@正驾驶%@汽车在路上行驶", owner, self);
}
- (NSString *)description {
    return [NSString stringWithFormat:@"<[brand=%@,model=%@,color=%@]>", self.brand, self.model, self.color];
}

@end

int main() {
    @autoreleasepool {
        Car *car = [[Car alloc] init];
        car.brand = @"宝马";
        car.model = @"x5";
        car.color = @"黑色";
        [car drive];
        [car drive:@"顶梁柱"];
    }
}

输出：

这个程序中为Car类添加了color属性和drive:方法，扩展了Car类。

 
 
关于使用类别实现非正式协议的内容，将在协议与委托中进行学习。