OC类别与扩展

Posted 2021-06-11 Billy Miracle

通过继承，子类可以在父类的基础上添加新的方法，甚至重写父类已有的方法。
有些时候，使用继承并不是最好的选择，例如通过[NSNumber numberWithInt: 5]方法所生成的NSNumber对象其实只是NSNumber子类的实例。这样即使为NSNumber派生子类也没有任何意义，派生的子类对NSNumber现有的子类并没有任何影响，此时就需要借助类别来实现。

类别

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

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

虽然这个语法格式很像在定义类，但在类名后有一个圆括号，而且圆括号中带一个类别名。
定义类别的语法与定义类的语法存在如下差异：

• 定义类时使用的类名必须是该项目中没有的类，而定义类别时使用的类名必须是已有的类。
• 定义类别时必须使用圆括号来包括类名。
• 类别中通常只定义方法

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

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

示例：

//  NSNumber+fk.h

#import <Foundation/Foundation.h>

@interface NSNumber (fk)

-(NSNumber*) add: (double) num2;
-(NSNumber*) substract: (double) num2;
-(NSNumber*) multiply: (double) num2;
-(NSNumber*) divide: (double) num2;

@end

//  NSNumber+fk.m

#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

上面为NSNumber定义了fk类，接下来只要在程序中导入NSNumber+fk.h头文件，并在主函数使用NSNumber类，该类的实例就会具有add: 、subtract: 、multiply: 和 divide: 方法。这就实现了对原有NSNumber类的动态扩展。

//  main.m

#import "NSNumber+fk.h"

int main(int argc, const 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);
    }
    return 0;
}

运行程序，可以看到如下结果：

5.4
0.6000000000000001
7.199999999999999
1.25

虽然类别可以重写原有类中的方法，但通常不建议这么做，如果需要重写原有类方法，最好的建议是通过原有类派生子类，然后在子类中重写父类原有的方法。
注意：

• 通过类别为指定类添加新方法后，这个新方法不仅会影响当前类，还会影响它的全部子类，每个子类都会获取类别扩展方法。
• 可以根据需要为一个类定义多个类别，不同的类别都可对原有的类增加方法定义。

类别通常有如下3种用法：

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

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

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

@interface NSValue : NSObject <NSCopying, NSSecureCoding>

此外，还有许多类别：

@interface NSValue (NSValueCreation)
@interface NSValue (NSValueExtensionMethods)
@interface NSValue (NSDeprecated)

通过这种方式就可以对类实现按模块分布到不同的.m文件中，从而提高项目后期的可维护性。

使用类别来调用私有方法

除了使用performSelector: 方法来动态调用那些私有方法之外，还可以通过类别来定义前向引用，从而实现对私有方法的调用。
示例：

//  FKItem.h

#import <Foundation/Foundation.h>

@interface FKItem : NSObject
@property (nonatomic , assign) double price;
-(void) info;
@end

//  FKItem.m

#import "FKItem.h"

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

//  main.m

#import "FKItem.h"

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        FKItem* item = [[FKItem alloc] init];
        item.price = 109;
        [item info];
        NSLog(@"物品打折的价格为：%g",[item calDiscount: .75]);
    }
    return 0;
}

直接编译会看到如下错误提示：

No visible @interface for 'FKItem' declares the selector 'calDiscount:'

为了可以正常调用calDiscount: 方法，可以在main函数前增加类别：

@interface FKItem (fk)
-(double) calDiscount: (double) discount;
@end

也可以新建一个文件，再在主函数导入即可：

//  FKItem+fk.h

#import "FKItem.h"

@interface FKItem (fk)
-(double) calDiscount: (double) discount;
@end

注意：类别的方法并不强制程序去实现它，实际上，FKItem类的实现部分已经实现了calDiscount: 方法。

扩展

扩展与类别类似，扩展相当于一个未命名的分类。但就用法来看，类别通常有单独的.h和.m文件，扩展则用于临时对某个类的接口进行扩展。类实现部分同时实现类接口部分定义的方法和扩展中定义的方法。
在定义类的扩展时，可以额外增加实例变量，也可以通过@property来合成属性，但在定义类的类别时，则不允许额外定义实例变量，也不能用@property来合成属性。
示例：
FKCar类的接口部分：

//  Car.h

#import <Foundation/Foundation.h>

@interface Car : NSObject
@property (nonatomic, copy) NSString* brand;
@property (nonatomic, copy) NSString* model;
-(void) drive;
@end

扩展：
新定义了一个color属性，新增了drive方法

//  Car+drive.h

#import "Car.h"

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

@end

实现部分：
不仅需要实现接口部分定义的所有方法，还需要实现扩展中定义的方法。

#import "Car+drive.h"

@implementation Car
-(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.m

#import "Car+drive.h"

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        Car* car = [[Car alloc] init];
        car.brand = @"BMW";
        car.model = @"M3";
        car.color = @"White";
        [car drive];
        [car drive:@"Peter"];
    }
    return 0;
}

在上面程序中，可以使用点语法来访问color属性，这个color属性是在扩展部分定义的，除此之外，也可以调用drive: 方法，这个方法也是在扩展部分定义的。

注意事项

使用类别与扩展可以覆写该类中的另一个方法，但是，覆写一个方法后，再也不能访问原来的方法。如果确实需要覆写方法，正确的选择可能会是创建子类，子类中覆写了方法，依然可以通过super关键字来引用父类的方法。
如果一个方法定义在多个分类中，该语句不会指定使用哪个分类。
扩展不仅会影响这个类，同时也会影响它的所有子类，也就是为一个类扩展新方法后，所有子类都会继承这个方法。