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

Objective-C类别（Category）与扩展（Extension）对比

2024-02-191.9k 阅读

一、Objective-C 类别（Category）

1.1 类别（Category）的基本概念

在 Objective-C 编程中，类别（Category）是一种为已存在的类添加新方法的方式，无需创建子类，也无需访问原始类的源代码。这在实际开发中极为实用，特别是当你无法直接修改某个类（例如系统框架中的类）的实现时，类别提供了一种强大的扩展机制。

从本质上讲，类别是一种将一组相关方法添加到现有类中的手段。通过类别，你可以把类的实现分散到多个文件中，提高代码的可维护性和组织性。例如，当一个类的功能逐渐增多，将其方法按功能模块划分到不同的类别中，能让代码结构更加清晰。

1.2 类别（Category）的语法结构

类别（Category）的定义语法如下：

@interface ExistingClassName (CategoryName)
// 在此声明新的方法
@end

@implementation ExistingClassName (CategoryName)
// 在此实现新的方法
@end
  • ExistingClassName 是你要扩展的现有类的名称。
  • CategoryName 是你为这个类别取的名字，通常用于描述该类别中方法的功能。

例如，假设我们有一个 NSString 类，我们想为它添加一个判断字符串是否为数字的方法，我们可以这样定义一个类别：

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

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

在上述代码中，我们为 NSString 类创建了一个名为 NumberCheck 的类别，并在其中声明和实现了 isNumber 方法。之后，我们就可以在任何 NSString 对象上调用这个方法：

NSString *str1 = @"123";
BOOL isNumber = [str1 isNumber];
if (isNumber) {
    NSLog(@"这是一个数字字符串");
} else {
    NSLog(@"这不是一个数字字符串");
}

1.3 类别（Category）的特点

1.3.1 方法添加 类别主要用于向现有类添加新的实例方法或类方法。但需要注意的是，类别不能添加实例变量。这是因为类别在运行时的实现机制决定了它无法为类增加新的实例变量存储。不过，你可以通过关联对象（Associated Objects）技术来模拟添加实例变量的效果，这在后面会详细介绍。

1.3.2 方法覆盖 如果类别中声明的方法与原始类中的方法同名，在运行时，类别中的方法会覆盖原始类中的方法。这一特性需要谨慎使用，因为它可能会导致一些难以调试的问题，尤其是在你不了解原始类的实现细节时。例如，假设 UIView 类有一个 drawRect: 方法，你在一个类别中也定义了一个 drawRect: 方法：

@interface UIView (MyDrawRect)
- (void)drawRect:(CGRect)rect;
@end

@implementation UIView (MyDrawRect)
- (void)drawRect:(CGRect)rect {
    // 自定义绘制逻辑
    NSLog(@"使用类别中的 drawRect 方法");
}
@end

这样，在任何 UIView 及其子类的实例调用 drawRect: 方法时，都会执行类别中定义的方法，而不是原始类中的方法。

1.3.3 访问控制 类别中的方法默认是 public 的，所有能够访问该类的代码都可以调用类别中的方法。这与原始类中方法的访问控制有所不同，原始类可以通过 @private、@protected、@public 等关键字来精确控制方法的访问权限。在类别中，由于其设计初衷是为了扩展类的功能，所以方法通常都是公开可访问的。

1.3.4 运行时加载 类别是在运行时加载的。这意味着，当程序运行到需要使用类别中的方法时，该类别才会被加载到内存中。这种延迟加载机制有助于提高程序的启动性能，尤其是在应用程序包含大量类和类别的情况下。

二、Objective-C 扩展（Extension）

2.1 扩展（Extension）的基本概念

扩展（Extension）也称为匿名类别（Anonymous Category），它是类别（Category）的一种特殊形式。与普通类别不同的是，扩展通常定义在类的实现文件（.m 文件）中，并且没有名称。扩展的主要作用是为类添加私有的方法和实例变量。

从本质上讲，扩展是类的实现的一部分，它允许你在类的实现文件中声明一些额外的方法和属性，这些方法和属性对于类的外部是不可见的，只有在类的实现文件内部才能访问。这有助于将类的实现细节封装起来，提高代码的安全性和可维护性。

2.2 扩展（Extension）的语法结构

扩展（Extension）的定义语法如下：

@interface ExistingClassName ()
// 在此声明新的方法和属性
@end

@implementation ExistingClassName
// 在此实现扩展中声明的方法
@end
  • ExistingClassName 同样是你要扩展的现有类的名称。
  • 与类别不同的是，这里没有类别名称，括号内为空。

例如，假设我们有一个 Person 类，我们想在其实现文件中添加一些私有方法和属性，我们可以这样定义一个扩展：

#import "Person.h"

@interface Person ()
@property (nonatomic, strong) NSString *privateName;
- (void)privateMethod;
@end

@implementation Person

- (void)privateMethod {
    NSLog(@"这是一个私有方法");
}

- (void)publicMethod {
    self.privateName = @"张三";
    [self privateMethod];
    NSLog(@"公有方法中使用私有属性和方法，私有属性值为：%@", self.privateName);
}

@end

在上述代码中，我们在 Person 类的实现文件中定义了一个扩展，在扩展中声明了一个私有属性 privateName 和一个私有方法 privateMethod。然后在类的实现中实现了这些方法，并在公有方法 publicMethod 中使用了私有属性和方法。

2.3 扩展（Extension）的特点

2.3.1 私有方法和属性 扩展最显著的特点就是可以声明私有方法和属性。这些方法和属性对于类的外部是不可见的，只有在类的实现文件内部可以访问。这有助于隐藏类的实现细节，只向外部暴露必要的接口。例如，在一个复杂的视图控制器类中，可能有一些方法只用于内部的逻辑处理，不需要外部调用，这时就可以将这些方法声明在扩展中。

2.3.2 编译时处理 与类别在运行时加载不同，扩展是在编译时处理的。这意味着扩展中声明的方法和属性在编译阶段就会被编译器所知，编译器会对其进行类型检查等操作。这使得扩展中的方法调用更像是类本身的方法调用，而不像类别中的方法调用那样在运行时才确定。

2.3.3 与类的紧密结合 扩展是类实现的一部分，它与类的关系更加紧密。因为扩展定义在类的实现文件中，所以它可以访问类的所有成员，包括私有成员。这与类别不同，类别虽然可以访问类的公共成员，但无法直接访问类的私有成员。例如，在扩展中可以直接访问类的 @private 实例变量，而在类别中则不行。

2.3.4 继承性 扩展中声明的方法和属性会被类的子类继承。这意味着子类可以使用父类扩展中定义的方法和属性，就如同这些方法和属性是在父类的接口中声明的一样。不过，由于扩展的私有性质，子类在外部仍然无法直接访问这些方法和属性，除非子类自己也在其实现文件中定义相同的扩展或者通过继承的公有方法间接访问。

三、类别（Category）与扩展（Extension）的对比

3.1 定义位置与可见性

  • 类别（Category）：类别通常定义在头文件（.h 文件）中，其方法对所有能够导入该头文件的代码都是可见的。这使得类别成为一种向类的外部公开新功能的有效方式。例如，你为 NSString 创建的类别，只要其他代码导入了包含该类别定义的头文件，就可以在任何地方调用类别中的方法。
  • 扩展（Extension）：扩展定义在类的实现文件（.m 文件）中，其声明的方法和属性对于类的外部是不可见的，只有在类的实现文件内部可以访问。这使得扩展成为封装类的私有实现细节的理想选择。例如，在一个视图控制器类的实现文件中定义的扩展，其中的私有方法和属性不会被其他类看到，只有该视图控制器类自己的代码可以使用。

3.2 能否添加实例变量

  • 类别（Category）：类别不能直接添加实例变量。这是由于类别在运行时的实现机制决定的，类别主要是为现有类添加新的方法，而不是改变类的实例变量布局。不过，如前文所述，可以通过关联对象（Associated Objects）技术来模拟添加实例变量的效果。例如，为 UIView 类创建一个类别，想为其添加一个自定义的标识变量，可以使用关联对象实现：
#import <objc/runtime.h>

@interface UIView (CustomIdentifier)
@property (nonatomic, strong) NSString *customIdentifier;
@end

@implementation UIView (CustomIdentifier)

- (void)setCustomIdentifier:(NSString *)customIdentifier {
    objc_setAssociatedObject(self, @selector(customIdentifier), customIdentifier, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}

- (NSString *)customIdentifier {
    return objc_getAssociatedObject(self, @selector(customIdentifier));
}

@end
  • 扩展（Extension）：扩展可以声明实例变量（通过属性声明的方式）。因为扩展是类实现的一部分，在编译时就会被处理，所以可以像在类的接口中声明实例变量一样在扩展中声明实例变量。例如，在 Person 类的扩展中声明 privateName 属性，这个属性就如同在类的接口中声明一样，会为类的实例分配相应的存储空间。

3.3 方法覆盖与继承

  • 类别（Category）：如果类别中声明的方法与原始类中的方法同名，类别中的方法会覆盖原始类中的方法。并且类别中的方法会被子类继承，如果子类没有重写该方法，子类会使用类别中覆盖后的方法。例如，为 UIView 类创建一个类别覆盖了 drawRect: 方法，UIView 的子类在调用 drawRect: 方法时，默认会执行类别中覆盖后的方法，除非子类自己重写了 drawRect: 方法。
  • 扩展（Extension）：扩展中声明的方法如果与类本身的方法同名，在编译时会报错，因为扩展是类实现的一部分，编译器不允许这种冲突。扩展中声明的方法会被类的子类继承，但由于其私有性质，子类在外部无法直接访问，只能通过继承的公有方法间接访问或者在子类的实现文件中通过相同的扩展定义来访问。

3.4 运行时与编译时特性

  • 类别（Category）：类别是在运行时加载的。这意味着只有当程序运行到需要使用类别中的方法时，该类别才会被加载到内存中。这种延迟加载机制有助于提高程序的启动性能，尤其在应用程序包含大量类和类别的情况下。例如，一个应用程序可能有多个针对不同功能场景的类别，只有在实际使用到这些功能时，相应的类别才会被加载。
  • 扩展（Extension）：扩展是在编译时处理的。编译器在编译类的实现文件时，会将扩展中声明的方法和属性视为类实现的一部分进行处理，包括类型检查等。这使得扩展中的方法调用更像是类本身的方法调用，在编译时就可以发现潜在的错误，而不像类别中的方法调用那样在运行时才确定。

3.5 应用场景

  • 类别（Category）：
    • 功能扩展：当你无法修改某个类（如系统框架中的类）的源代码，但又需要为其添加新功能时，类别是首选。例如，为 NSArray 添加一个方便的方法来获取数组中的随机元素。
    • 代码组织：将类的方法按功能模块划分到不同的类别中，提高代码的可维护性和组织性。比如，将一个复杂视图控制器类的与网络请求相关的方法放在一个类别中，与界面布局相关的方法放在另一个类别中。
  • 扩展（Extension）：
    • 封装私有实现：用于在类的实现文件中添加私有的方法和属性，隐藏类的实现细节，只向外部暴露必要的接口。例如，在一个数据模型类的实现文件中，通过扩展声明一些私有方法来处理数据的内部转换逻辑。
    • 临时添加方法：在类的实现过程中，有时可能需要临时添加一些方法来辅助实现某个功能，这些方法不需要暴露给外部，使用扩展可以方便地实现这一需求。例如，在一个视图控制器类中，在实现某个复杂功能时，通过扩展添加一些私有方法来处理中间逻辑，功能完成后这些方法也不会影响类的外部接口。

通过以上对 Objective-C 类别（Category）与扩展（Extension）的详细对比，开发者可以根据具体的需求和场景，合理选择使用类别或扩展来优化代码结构，提高代码的可维护性和安全性。无论是为现有类添加公开功能，还是封装类的私有实现细节，类别和扩展都提供了强大而灵活的手段。在实际开发中，深入理解它们的特性和区别，能够让我们更加高效地编写高质量的 Objective-C 代码。