【iOS】继承链

文章目录

前言
什么是继承链
OC中的根类
- 关于NSProxy
关键作用
- 1.方法查找与动态绑定
- [2. 消息转发](#2. 消息转发)
- [3. **类型判断与多态**](#3. 类型判断与多态)
继承链的底层实现
- 元类的继承链
总结

前言

在objective-c中，继承链是类与类之间通过父类（Superclass）关系形成的一层层继承结构，在我们之前的学习中，我们发现无论是方法的动态查找、消息的传递还是代码的复用，都需要用到继承链，今天我们就来系统地了解一下继承链。

什么是继承链

每个OC类（除根类外）都有一个直接父类，通过这种层级关系形成一条从子类到根类的单向链。当向一个对象发送消息（调用方法）时，OC运行时会沿着这条链自底向上查找对应的方法实现：

若当前类实现了该方法，直接调用；
若未实现，则跳转到父类继续查找；
直到根类仍无实现时，触发「消息转发」机制（否则程序崩溃）。

OC中的根类

OC 中几乎所有类的最终父类都是 NSObject（少数特殊类如 NSProxy可能作为独立根类）。NSObject定义了OC对象的基础行为（如内存管理、反射、消息传递等）。

eg：

objective-c 复制代码

// 自定义类继承链示例
@interface MyBaseClass : NSObject
@end

@interface MySubClass : MyBaseClass
@end

// MySubClass 的继承链：MySubClass → MyBaseClass → NSObject → nil（根类无父类）

关于NSProxy

在 Objective-C（OC）中，NSProxy是一个特殊的抽象基类，与 NSObject并列作为 OC 类体系的两大根类（但 NSObject是绝大多数类的最终父类，而 NSProxy更专注于消息转发场景）。它的核心设计目标是==轻量级消息转发，常用于实现代理模式（Proxy Pattern）、动态消息拦截或替代复杂的继承结构。

NSProxy的底层源码如下：

objective-c 复制代码

/*	NSProxy.h
	Copyright (c) 1994-2019, Apple Inc. All rights reserved.
*/

#import <Foundation/NSObject.h>

@class NSMethodSignature, NSInvocation;

NS_HEADER_AUDIT_BEGIN(nullability, sendability)

NS_ROOT_CLASS
@interface NSProxy <NSObject> {
    __ptrauth_objc_isa_pointer Class	isa;
}

+ (id)alloc;
+ (id)allocWithZone:(nullable NSZone *)zone NS_AUTOMATED_REFCOUNT_UNAVAILABLE;
+ (Class)class;

- (void)forwardInvocation:(NSInvocation *)invocation;
- (nullable NSMethodSignature *)methodSignatureForSelector:(SEL)sel NS_SWIFT_UNAVAILABLE("NSInvocation and related APIs not available");
- (void)dealloc;
- (void)finalize;
@property (readonly, copy) NSString *description;
@property (readonly, copy) NSString *debugDescription;
+ (BOOL)respondsToSelector:(SEL)aSelector;

- (BOOL)allowsWeakReference API_UNAVAILABLE(macos, ios, watchos, tvos);
- (BOOL)retainWeakReference API_UNAVAILABLE(macos, ios, watchos, tvos);

// - (id)forwardingTargetForSelector:(SEL)aSelector;

@end

NS_HEADER_AUDIT_END(nullability, sendability)

通过上述代码，我们可以发现NSProxy是一个实现了NSObject协议的根类。

由此我们知道：

NSProxy 是一个抽象类,跟 NSObject 一样的基类，都遵守NSObject协议
NSProxy是一个抽象类，必须继承实例化其子类才能使用。
NSProxy从类名来看是代理类专门负责代理对象转发消息的。相比NSObject类来说NSProxy更轻量级，OC是单继承的语言，但通过NSProxy可以帮助Objective-C间接的实现多重继承的功能（"伪多继承"）。

在NSProxy源码中，运用消息转发机制的核心方法有两个：

通过methodSignatureForSelector:方法获取一个NSMethodSignature类型的对象，调用forwardInvocation:方法。该方法传入一个封装了NSMethodSignature的NSInvocation对象。然后该对象通过invakeWithTarget:方法将消息转发给其它对象。

顺便回顾一下消息转发：

OC的消息转发流程：当向一个对象发送消息，而该对象没有实现对应的方法时，运行时会触发消息转发机制。这个过程分为几个步骤：动态方法解析、备用接收者转发，最后是完整消息转发。这两个方法主要参与最后一步，即完整消息转发阶段。

methodSignatureForSelector:的作用是为指定的选择器生成方法签名。方法签名包含了方法的参数类型、返回类型等信息，是构造NSInvocation对象所必需的。如果这个方法返回nil，运行时会认为该消息无法处理，进而触发doesNotRecognizeSelector:导致崩溃。

然后是forwardInvocation:，它的作用是处理那些无法被当前对象或其继承链中其他类处理的方法调用。在这个方法里，我们可以自定义如何处理这些未被识别的消息，比如将消息转发给其他对象，或者执行一些额外的逻辑。

当消息转发到NSProxy或自定义类时，首先会调用methodSignatureForSelector:来获取方法签名，如果返回有效的签名，才会调用forwardInvocation:来处理消息。如果methodSignatureForSelector:返回nil，则不会调用forwardInvocation:，直接崩溃。

关键作用

1.方法查找与动态绑定

OC 是动态语言，方法的调用（消息发送）发生在运行时。继承链的存在使得对象可以「继承」父类的方法，无需重复实现。例如：

objective-c 复制代码

MySubClass *obj = [[MySubClass alloc] init];
NSString *desc = [obj description]; // 实际调用 NSObject 的 description 方法

即使 MySubClass未重写 description，运行时仍会沿继承链找到 NSObject的实现。

2. 消息转发

若继承链中所有类都未实现目标方法，OC 会尝试通过消息转发机制处理，避免直接崩溃。典型流程如下：

动态方法解析 ：调用 +resolveInstanceMethod:（实例方法）或 +resolveClassMethod:（类方法）尝试动态添加方法实现；
备用接收者转发 ：调用 -forwardingTargetForSelector:将消息转发给其他对象；
完整消息转发 ：调用 -methodSignatureForSelector:生成方法签名，再通过 -forwardInvocation:转发（可自定义处理逻辑）。

3. 类型判断与多态

通过继承链可以实现多态（Polymorphism）。例如，isKindOfClass:和 isMemberOfClass:方法通过检查对象继承链判断类型：

objective-c 复制代码

id obj = [[MySubClass alloc] init];
BOOL isMyBase = [obj isKindOfClass:[MyBaseClass class]]; // YES（继承链包含 MyBaseClass）
BOOL isNSObject = [obj isKindOfClass:[NSObject class]];   // YES（继承链最终到 NSObject）

继承链的底层实现

OC 类的底层通过 objc_class结构体表示，其中 superclass字段指向父类。通过运行时函数可手动操作继承链：

class_getSuperclass(Class cls)：获取类的直接父类；
class_getClass(Class cls)：获取类对应的元类（Meta Class）；
object_getClass(id obj)：获取对象的类（等价于 [obj class]）。

元类的继承链

OC 中类（Class）本身也是对象，其类型为元类（Meta Class）。元类的继承链与普通类不同：

普通类的 isa指针指向其元类；
元类的 isa指针指向根元类 （通常是 NSObject元类的父类）；
根元类的 isa指针指向自身（形成闭环）。

例如，NSObject类的元类继承链为：NSObject_Meta → Root_Meta（自身）。

总结

在编程设计时，我们要避免继承链过长，过深的继承链会增加方法查找时间，降低性能。推荐优先使用组合（Composition）而非继承。
在继承中，根类（如 NSObject）需自行实现部分基础方法（如 alloc、init），否则其子类无法正常使用。
类方法存储在元类中，其继承链为「元类 → 父元类 → ... → 根元类」；实例方法的继承链为「类 → 父类 → ... → 根类」。

在面向对象编程（OOP）中，组合（Composition） 是一种通过「持有其他对象实例」来实现功能复用的设计模式，与「继承（Inheritance）」共同构成代码复用的两大核心手段。它的核心思想是「整体-部分」（Whole-Part）关系，即一个对象（整体）由多个其他对象（部分）组成，通过调用这些「部分」对象的方法来实现自身功能。

在面向对象编程（OOP）中，组合（Composition） 是一种通过「持有其他对象实例」来实现功能复用的设计模式，与「继承（Inheritance）」共同构成代码复用的两大核心手段。它的核心思想是「整体-部分」（Whole-Part）关系，即一个对象（整体）由多个其他对象（部分）组成，通过调用这些「部分」对象的方法来实现自身功能。
组合的本质是「has-a 」关系（拥有关系），而非继承的「is-a」关系（是一种关系）。例如：

一辆 Car（整体）「拥有」一个 Engine（部分），因此 Car通过持有 Engine实例来调用 start、stop等方法；

一个 Computer（整体）「拥有」一个 CPU和一个 Memory（部分），通过调用它们的计算和存储方法完成功能。

与继承相比，组合不要求整体类与部分类存在继承层级，而是通过动态的消息传递（调用部分对象的方法）实现功能复用。

维度	组合（Composition）	继承（Inheritance）
关系类型	「has-a」（整体拥有部分）	「is-a」（子类是一种父类）
耦合度	低：整体与部分通过接口（协议）交互，解耦性强	高：子类依赖父类的实现细节（如私有方法、属性）
灵活性	高：运行时可动态替换部分对象（如依赖注入）	低：继承关系编译时确定，无法动态修改
复用粒度	细粒度：仅复用需要的部分功能	粗粒度：必须继承整个父类的功能（包括不需要的）
设计复杂度	需定义清晰的接口（协议），规范部分对象的行为	需维护继承链，可能导致「脆弱基类」问题

组合的具体使用：

在 Objective-C 中，组合通过「属性持有其他对象实例」实现。

1.定义部分对象（Component）

首先定义需要被组合的功能模块（部分），通常通过协议（Protocol）规范其行为，以降低耦合。

objective-c 复制代码

// 定义 Engine 协议（部分对象的行为规范）
@protocol Engine <NSObject>
- (void)start;
- (void)stop;
- (NSString *)engineInfo;
@end

// 具体实现：GasEngine（汽油发动机）
@interface GasEngine : NSObject <Engine>
@end

@implementation GasEngine
- (void)start { NSLog(@"汽油发动机启动..."); }
- (void)stop { NSLog(@"汽油发动机停止..."); }
- (NSString *)engineInfo { return @"Gas Engine v1.0"; }
@end

2. 定义整体对象（Composite）

整体对象通过属性持有部分对象的实例，并在需要时调用其方法。

objective-c 复制代码

// 整体对象：Car（汽车）
@interface Car : NSObject
@property (nonatomic, strong) id<Engine> engine; // 持有符合 Engine 协议的对象
- (instancetype)initWithEngine:(id<Engine>)engine;
- (void)startCar;
- (void)stopCar;
@end

@implementation Car
- (instancetype)initWithEngine:(id<Engine>)engine {
    if (self = [super init]) {
        _engine = engine; // 注入部分对象（依赖注入）
    }
    return self;
}

// 调用部分对象的方法实现自身功能
- (void)startCar {
    [self.engine start];
    NSLog(@"汽车启动，使用发动机：%@", [self.engine engineInfo]);
}

- (void)stopCar {
    [self.engine stop];
    NSLog(@"汽车停止");
}
@end

3. 使用组合

通过创建部分对象的实例，并注入到整体对象中，即可完成功能复用。

objective-c 复制代码

// 创建部分对象（GasEngine）
id<Engine> engine = [[GasEngine alloc] init];

// 创建整体对象（Car）并注入部分对象
Car *car = [[Car alloc] initWithEngine:engine];

// 调用整体对象的方法（内部调用部分对象的方法）
[car startCar]; 
// 输出：
// 汽油发动机启动...
// 汽车启动，使用发动机：Gas Engine v1.0