MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Objective-C中的类别(Category)与扩展(Extension)

2023-05-124.7k 阅读

一、Objective-C 类别（Category）

1.1 类别（Category）的基本概念

在 Objective-C 中，类别（Category）是一种为已存在的类添加新方法的方式，而无需创建子类或修改原有类的实现。它允许开发者将一个类的实现分散到多个不同的文件中，这在大型项目中非常有用，特别是当一个类的代码量变得庞大时，可以将不同功能的方法分别放在不同的类别中，提高代码的可维护性和组织性。

类别通常用于以下场景：

  • 将类的实现分散到多个文件：例如，一个复杂的视图控制器类，可将视图布局相关方法放在一个类别中，数据处理相关方法放在另一个类别中。
  • 为系统类添加自定义方法：对于一些系统提供的类，如 NSString，可以通过类别添加自定义的方法来扩展其功能。

1.2 类别（Category）的定义与语法

类别定义的语法如下：

@interface ClassName (CategoryName)
// 声明新方法
@end

@implementation ClassName (CategoryName)
// 实现新方法
@end

其中，ClassName 是要添加类别的类名，CategoryName 是类别名，这个名字可以根据功能自行命名，以体现该类别中方法的用途。

例如，为 NSString 类添加一个判断字符串是否为纯数字的方法：

@interface NSString (NumberCheck)
- (BOOL)isPureNumber;
@end

@implementation NSString (NumberCheck)
- (BOOL)isPureNumber {
    NSScanner *scanner = [NSScanner scannerWithString:self];
    NSNumber *number;
    return [scanner scanDouble:&number] && [scanner isAtEnd];
}
@end

在上述代码中，定义了一个名为 NumberCheck 的类别，为 NSString 类添加了一个 isPureNumber 方法，用于判断字符串是否为纯数字。使用时，可以像调用 NSString 类的其他方法一样调用这个新添加的方法：

NSString *str1 = @"123";
BOOL isNumber1 = [str1 isPureNumber];
NSString *str2 = @"abc";
BOOL isNumber2 = [str2 isPureNumber];

1.3 类别（Category）的局限性

  • 无法添加实例变量：类别主要是用于添加方法，不能直接在类别中声明实例变量。这是因为类别在运行时，并没有为实例变量分配额外的存储空间。如果确实需要添加实例变量，可以考虑使用继承或使用关联对象（Associated Objects）技术。
  • 方法名冲突：由于类别可以为类添加方法，当多个类别为同一个类添加了相同名称的方法时，可能会导致方法覆盖的问题。在编译时，编译器会发出警告，但最终链接时，后编译的类别中的方法会覆盖前面编译的类别中的同名方法。例如：
@interface NSString (Category1)
- (void)printMessage;
@end

@implementation NSString (Category1)
- (void)printMessage {
    NSLog(@"This is from Category1");
}
@end

@interface NSString (Category2)
- (void)printMessage;
@end

@implementation NSString (Category2)
- (void)printMessage {
    NSLog(@"This is from Category2");
}
@end

在上述代码中，Category1 和 Category2 都为 NSString 类添加了 printMessage 方法。如果在代码中调用 printMessage 方法，实际调用的将是 Category2 中的实现。

二、Objective-C 扩展（Extension）

2.1 扩展（Extension）的基本概念

扩展（Extension）是类别（Category）的一种特殊形式，也被称为匿名类别（Anonymous Category）。它主要用于在类的内部声明私有方法和属性，对类的接口进行扩展。与普通类别不同的是，扩展通常定义在实现文件（.m 文件）中，而不是头文件（.h 文件）中，这使得其中声明的方法和属性对于其他类来说是不可见的，从而实现了一定程度的封装。

2.2 扩展（Extension）的定义与语法

扩展的定义语法如下：

@interface ClassName ()
// 声明私有方法、属性等
@end

@implementation ClassName
// 实现类的方法，包括扩展中声明的方法
@end

例如，有一个 Person 类，希望在类内部定义一些私有方法和属性，可以这样使用扩展：

#import <Foundation/Foundation.h>

@interface Person : NSObject
@property (nonatomic, strong) NSString *name;
- (void)publicMethod;
@end

@implementation Person
// 扩展定义在实现文件中
@interface Person ()
@property (nonatomic, assign) NSInteger age;
- (void)privateMethod;
@end

- (void)publicMethod {
    NSLog(@"Public method called. Name: %@", self.name);
    [self privateMethod];
}

- (void)privateMethod {
    NSLog(@"Private method called. Age: %ld", (long)self.age);
}
@end

在上述代码中，在 Person 类的实现文件中定义了一个扩展，声明了一个私有属性 age 和一个私有方法 privateMethod。publicMethod 方法可以调用 privateMethod，而外部其他类无法直接访问 privateMethod 和 age 属性。

2.3 扩展（Extension）与类别（Category）的区别

  • 声明位置：类别通常定义在头文件中，以便其他类可以使用其中添加的方法；而扩展通常定义在实现文件中，用于声明类的私有成员。
  • 是否可添加实例变量：类别不能直接添加实例变量，而扩展虽然不能像普通类那样声明实例变量，但通过属性声明，在运行时会自动为属性生成实例变量和相关的存取方法。例如在上述 Person 类的扩展中声明了 age 属性，实际上在运行时会有对应的实例变量。
  • 可见性：类别中声明的方法对所有导入该类别头文件的类都是可见的；而扩展中声明的方法和属性对于其他类是不可见的，只有类的实现文件内部可以访问。

三、关联对象（Associated Objects）在类别中的应用

3.1 关联对象的概念

由于类别不能直接添加实例变量，为了实现类似功能，可以使用关联对象（Associated Objects）技术。关联对象允许在运行时将一个对象与另一个对象关联起来，从而达到为对象动态添加属性的效果。

3.2 关联对象的使用方法

在 Objective-C 中，使用 objc_setAssociatedObject 函数来设置关联对象，使用 objc_getAssociatedObject 函数来获取关联对象，使用 objc_removeAssociatedObjects 函数来移除关联对象。这些函数定义在 <objc/runtime.h> 头文件中。

例如，为 UIButton 类通过类别添加一个自定义的属性 customData：

#import <UIKit/UIKit.h>
#import <objc/runtime.h>

@interface UIButton (CustomData)
@property (nonatomic, strong) id customData;
@end

@implementation UIButton (CustomData)

static const char *customDataKey = "customDataKey";

- (void)setCustomData:(id)customData {
    objc_setAssociatedObject(self, customDataKey, customData, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}

- (id)customData {
    return objc_getAssociatedObject(self, customDataKey);
}
@end

在上述代码中，定义了一个静态常量 customDataKey 作为关联对象的键。setCustomData: 方法使用 objc_setAssociatedObject 函数将传入的 customData 对象与当前 UIButton 对象关联起来，customData 方法使用 objc_getAssociatedObject 函数获取关联的对象。

3.3 关联对象的内存管理

关联对象的内存管理由关联策略（Association Policy）决定。在 objc_setAssociatedObject 函数中，第四个参数就是关联策略，常见的关联策略有：

  • OBJC_ASSOCIATION_ASSIGN：弱引用，类似 assign 属性，不保留对象，对象释放时不会自动设置为 nil。
  • OBJC_ASSOCIATION_RETAIN_NONATOMIC：非原子性的强引用，类似 strong 属性，但不是线程安全的。
  • OBJC_ASSOCIATION_COPY_NONATOMIC：非原子性的拷贝，类似 copy 属性，但不是线程安全的。
  • OBJC_ASSOCIATION_RETAIN：原子性的强引用，类似 strong 属性，线程安全。
  • OBJC_ASSOCIATION_COPY：原子性的拷贝，类似 copy 属性，线程安全。

选择合适的关联策略对于内存管理和程序的正确性非常重要。例如，如果关联的对象是一个可变对象，并且不希望在传递过程中被修改，可能需要使用 OBJC_ASSOCIATION_COPY 或 OBJC_ASSOCIATION_COPY_NONATOMIC 策略。

四、类别和扩展在实际项目中的应用场景

4.1 类别在实际项目中的应用

  • 代码模块化：在一个大型的 iOS 应用开发项目中，假设存在一个 User 类，该类负责处理用户相关的各种操作。随着项目的推进，User 类的代码量不断增加，变得难以维护。此时，可以通过类别将不同功能的方法进行分离。比如，将用户登录、注册相关的方法放在一个名为 User+Authentication 的类别中，将用户信息更新相关的方法放在 User+ProfileUpdate 的类别中。这样，不同的开发人员可以分别关注不同类别的代码，提高开发效率和代码的可维护性。
@interface User (Authentication)
- (BOOL)loginWithUsername:(NSString *)username password:(NSString *)password;
- (BOOL)registerWithUsername:(NSString *)username password:(NSString *)password;
@end

@implementation User (Authentication)
- (BOOL)loginWithUsername:(NSString *)username password:(NSString *)password {
    // 登录逻辑实现
    return YES;
}

- (BOOL)registerWithUsername:(NSString *)username password:(NSString *)password {
    // 注册逻辑实现
    return YES;
}
@end

@interface User (ProfileUpdate)
- (BOOL)updateProfileWithName:(NSString *)name age:(NSInteger)age;
@end

@implementation User (ProfileUpdate)
- (BOOL)updateProfileWithName:(NSString *)name age:(NSInteger)age {
    // 更新用户信息逻辑实现
    return YES;
}
@end
  • 扩展系统类功能：在开发中经常会用到 UIImage 类来处理图片。有时需要对图片进行一些特殊的处理，比如添加水印。可以通过类别为 UIImage 类添加一个添加水印的方法。
@interface UIImage (Watermark)
- (UIImage *)imageWithWatermark:(NSString *)watermark;
@end

@implementation UIImage (Watermark)
- (UIImage *)imageWithWatermark:(NSString *)watermark {
    UIGraphicsBeginImageContextWithOptions(self.size, NO, self.scale);
    [self drawInRect:CGRectMake(0, 0, self.size.width, self.size.height)];
    NSDictionary *attributes = @{NSFontAttributeName: [UIFont systemFontOfSize:12]};
    CGSize size = [watermark sizeWithAttributes:attributes];
    [watermark drawAtPoint:CGPointMake(self.size.width - size.width - 10, self.size.height - size.height - 10) withAttributes:attributes];
    UIImage *newImage = UIGraphicsGetImageFromCurrentImageContext();
    UIGraphicsEndImageContext();
    return newImage;
}
@end

这样，在项目中使用 UIImage 类时，就可以方便地为图片添加水印：

UIImage *originalImage = [UIImage imageNamed:@"example.jpg"];
UIImage *watermarkedImage = [originalImage imageWithWatermark:@"Copyright"];

4.2 扩展在实际项目中的应用

  • 实现类的私有方法和属性：以一个 ViewController 类为例，在开发过程中，可能有一些方法和属性只希望在该视图控制器内部使用，不希望被外部类访问。这时可以使用扩展来实现。
#import "ViewController.h"

@interface ViewController ()
@property (nonatomic, strong) NSMutableArray *privateDataArray;
- (void)privateMethodToProcessData;
@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    self.privateDataArray = [NSMutableArray array];
    [self privateMethodToProcessData];
}

- (void)privateMethodToProcessData {
    // 处理私有数据数组的逻辑
    [self.privateDataArray addObject:@"Some data"];
}
@end

在上述代码中，通过扩展声明了一个私有属性 privateDataArray 和一个私有方法 privateMethodToProcessData，只有 ViewController 类的实现文件内部可以访问这些成员，有效地实现了封装。

  • 增强类的内部功能：对于一些复杂的类，可能需要在内部进行一些额外的功能扩展，但又不想暴露这些功能给外部类。比如一个 DataManager 类负责数据的读取、存储等操作，在类内部可能需要一些辅助方法来处理数据格式转换等工作，这些方法可以通过扩展来声明和实现。
#import <Foundation/Foundation.h>

@interface DataManager : NSObject
- (void)saveData:(id)data;
- (id)loadData;
@end

@implementation DataManager

@interface DataManager ()
- (NSString *)formatDataToString:(id)data;
- (id)parseStringToData:(NSString *)string;
@end

- (void)saveData:(id)data {
    NSString *formattedString = [self formatDataToString:data];
    // 实际的保存逻辑，比如写入文件等
}

- (id)loadData {
    // 实际的读取逻辑，比如从文件读取字符串
    NSString *loadedString = @"Some loaded data";
    return [self parseStringToData:loadedString];
}

- (NSString *)formatDataToString:(id)data {
    // 数据格式转换逻辑
    return [NSString stringWithFormat:@"Formatted: %@", data];
}

- (id)parseStringToData:(NSString *)string {
    // 反向数据格式转换逻辑
    return [string substringFromIndex:10];
}
@end

通过扩展，DataManager 类可以在内部实现一些辅助功能，而不影响其对外的接口。

五、使用类别和扩展时的注意事项

5.1 类别方法命名冲突问题

正如前面提到的，当多个类别为同一个类添加相同名称的方法时，会出现方法覆盖的问题。为了避免这种情况，在命名类别方法时，应尽量使用具有唯一性和描述性的名称。可以采用命名前缀的方式，例如，如果项目中有一个模块叫 UserModule，为 NSString 类添加的类别方法可以命名为 userModule_stringFormatForUserInfo，这样可以大大降低方法名冲突的概率。另外，在开发过程中，团队应制定统一的命名规范，对类别方法的命名进行约束。

5.2 扩展的可见性管理

虽然扩展的目的是实现类的私有成员，但在实际开发中，如果不小心将扩展的声明放在了头文件中，就会导致原本私有的方法和属性暴露给其他类。因此，要严格遵守扩展定义在实现文件中的原则。同时，在团队开发中，要对新加入的开发人员进行相关培训，强调扩展的正确使用方式，避免因误操作导致代码的封装性被破坏。

5.3 关联对象的性能和内存管理

在使用关联对象为类别添加属性时，虽然提供了一种灵活的方式，但也需要注意性能和内存管理问题。关联对象的设置和获取操作会带来一定的性能开销，尤其是在频繁操作时。此外，选择不合适的关联策略可能会导致内存泄漏或对象过早释放的问题。例如，如果关联的对象是一个大的图片对象，使用 OBJC_ASSOCIATION_RETAIN 策略可能会导致内存占用过高，而使用 OBJC_ASSOCIATION_ASSIGN 策略如果不注意对象的生命周期，可能会导致野指针问题。因此，在使用关联对象时，要根据实际情况仔细选择关联策略，并对性能进行测试和优化。

5.4 类别和扩展对类结构的影响

虽然类别和扩展为代码的组织和功能扩展提供了很大的便利，但过度使用可能会对类的结构造成一定的混乱。比如，在一个类上添加了过多的类别，可能会使类的功能变得分散，难以理解和维护。因此，在使用类别和扩展时，要遵循适度原则，确保类的结构清晰，功能明确。同时，在团队开发中，要定期对代码进行审查，对不合理的类别和扩展使用进行调整。

通过深入理解和正确使用 Objective-C 中的类别和扩展，开发人员可以更好地组织代码，提高代码的可维护性和扩展性，从而开发出更加健壮和高效的应用程序。无论是在小型项目还是大型项目中，合理运用类别和扩展都是提升代码质量的重要手段。在实际开发过程中，要根据具体的需求和场景，灵活选择使用类别或扩展，并注意相关的注意事项，以充分发挥它们的优势。