重拾iOS-多继承

image

关键词：多继承,Protocol,Category,Runtime

面试题：

1）OC中可以多继承吗？

2）多继承的实现方案有哪些？

一、概述

面向对象编程之所以成为主流的编程思想和他的继承和多态是分不开的，只要是面向对象语言都支持继承和多态，当然不同的OOP语言之间都有其特点。OC中和Java类似，不支持多重继承，但OOP语言C++就支持多继承。

为什么Objective-C不支持多继承？

Objective-C不支持多继承，由于消息机制名字查找发生在运行时而非编译时，很难解决多个基类可能导致的二义性问题。

二、OC的多继承实现方案

虽然OC不支持多继承，但是可以通过其他方式间接地达到多继承的效果。

  • 通过组合实现多继承；
  • 通过协议实现多继承；
  • 通过类别实现多继承；
  • 通过Runtime消息转发实现多继承；
  • 通过NSProxy实现多继承；

代码演示如下：

1、通过组合实现多继承

ClassA:

// .h
@interface ClassA : NSObject
- (void)funcA;
@end

// .m
#import "ClassA.h"

@implementation ClassA
- (void)funcA{
    NSLog(@"%s",__func__);
}
@end

ClassB:

// .h
@interface ClassB : NSObject
- (void)funcB;
@end

// .m
#import "ClassB.h"

@implementation ClassB
- (void)funcB{
    NSLog(@"%s",__func__);
}
@end

ClassC:（通过组合多个类来间接实现多继承）

// .h
@interface ClassC : NSObject
- (void)funcA;
- (void)funcB;
@end

// .m
#import "ClassC.h"
#import "ClassA.h"
#import "ClassB.h"

@interface ClassC ()
@property (nonatomic, strong) ClassA *clsA;
@property (nonatomic, strong) ClassB *clsB;
@end

@implementation ClassC
- (instancetype)init{
    if (self = [super init]) {
        self.clsA = [[ClassA alloc]init];
        self.clsB = [[ClassB alloc]init];
    }
    return self;
}
- (void)funcA {
    [self.clsA funcA];
}
- (void)funcB{
    [self.clsB funcB];
}

@end

2、通过协议实现多继承

ClassA:

// .h
@protocol ClassAProtocol <NSObject>
- (void)funcA;
@end

@interface ClassA : NSObject<ClassAProtocol>

@end

// .m
#import "ClassA.h"

@implementation ClassA
- (void)funcA{
    NSLog(@"%s",__func__);
}
@end

ClassB:

// .h
@protocol ClassBProtocol <NSObject>
- (void)funcB;
@end

@interface ClassB : NSObject<ClassBProtocol>

@end

// .m
#import "ClassB.h"

@implementation ClassB
- (void)funcB{
    NSLog(@"%s",__func__);
}
@end

ClassC:（通过遵循多个协议来间接实现多继承）

// .h
@interface ClassC : NSObject
- (void)funcA;
- (void)funcB;
@end

// .m
#import "ClassC.h"
#import "ClassA.h"
#import "ClassB.h"

@interface ClassC ()<ClassAProtocol, ClassBProtocol>
@property (nonatomic, strong) ClassA *clsA;
@property (nonatomic, strong) ClassB *clsB;
@end

@implementation ClassC
- (instancetype)init{
    if (self = [super init]) {
        self.clsA = [[ClassA alloc]init];
        self.clsB = [[ClassB alloc]init];
    }
    return self;
}
- (void)funcA {
    [self.clsA funcA];
}
- (void)funcB{
    [self.clsB funcB];
}

@end

3、通过类别实现多继承

ClassA:

// .h
@interface ClassA : NSObject
- (void)funcA;
@end

// .m
#import "ClassA.h"

@implementation ClassA
- (void)funcA{
    NSLog(@"%s",__func__);
}
@end

ClassB:

// .h
@interface ClassB : NSObject
- (void)funcB;
@end

// .m
#import "ClassB.h"

@implementation ClassB
- (void)funcB{
    NSLog(@"%s",__func__);
}
@end

ClassC:（通过添加多个类别来间接实现多继承）

// .h
@interface ClassC : NSObject
- (void)funcA;
- (void)funcB;
@end

// .m
#import "ClassC.h"
#import "ClassA.h"
#import "ClassB.h"
#import "ClassC+A.h"
#import "ClassC+B.h"

@interface ClassC ()
@end

@implementation ClassC
- (instancetype)init{
    if (self = [super init]) {
        self.clsA = [[ClassA alloc]init];
        self.clsB = [[ClassB alloc]init];
    }
    return self;
}
- (void)funcA {
    [self.clsA funcA];
}
- (void)funcB{
    [self.clsB funcB];
}

@end

ClassC+A:

// .h
#import "ClassC.h"
@class ClassA;

@interface ClassC (A)
@property (nonatomic, strong) ClassA *clsA;
- (void)funcA;
@end

// .m
#import "ClassC+A.h"
#import "ClassA.h"
#import <objc/runtime.h>

@implementation ClassC (A)
- (void)setClsA:(ClassA *)clsA{
    objc_setAssociatedObject(self, @selector(clsA), clsA, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}
- (ClassA *)clsA{
    return objc_getAssociatedObject(self, @selector(clsA));
}
- (void)funcA{
    [self.clsA funcA];
}
@end

ClassC+B:

// .h
#import "ClassC.h"
@class ClassB;

@interface ClassC (B)
@property (nonatomic, strong) ClassB *clsB;
- (void)funcB;
@end

// .m
#import "ClassC+B.h"
#import "ClassB.h"
#import <objc/runtime.h>

@implementation ClassC (B)
- (void)setClsB:(ClassB *)clsB{
    objc_setAssociatedObject(self, @selector(clsB), clsB, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}
- (ClassB *)clsB{
    return objc_getAssociatedObject(self, @selector(clsB));
}
- (void)funcB{
    [self.clsB funcB];
}
@end

4、通过Runtime消息转发实现多继承

Runtime在经历「消息传递」阶段仍未找到方法的实现时，会进入「消息转发」阶段。大致的流程如下：

image

想了解更多Runtime相关知识，可以看看这篇：「重拾iOS-Runtime」

「消息转发」

消息转发会经历三个过程：

1）首先是「动态方法解析」，Objective-C运行时会调用 resolveInstanceMethod:，让你有机会提供一个函数实现。如果你添加了函数并返回YES， 那运行时系统就会重新启动一次消息发送的过程。

2）然后是「备用接收者」，如果目标对象实现了forwardingTargetForSelector:，RunTime 这时就会调用这个方法，给你把这个消息转发给其他对象的机会。

3）最后是「完整的消息转发」，首先它会发送methodSignatureForSelector:消息获得函数的参数和返回值类型。如果methodSignatureForSelector:返回nil ，Runtime则会发出 doesNotRecognizeSelector:消息，程序这时也就挂掉了。如果返回了一个函数签名，Runtime就会创建一个NSInvocation 对象并发送 forwardInvocation:消息给目标对象。

所以说我们有三次机会，去间接的实现多继承。但是可想而知，越到后面的阶段，代价也就越大。

ClassA和ClassB不变

ClassA:

// .h
@interface ClassA : NSObject
- (void)funcA;
@end

// .m
#import "ClassA.h"

@implementation ClassA
- (void)funcA{
    NSLog(@"%s",__func__);
}
@end

ClassB:

// .h
@interface ClassB : NSObject
- (void)funcB;
@end

// .m
#import "ClassB.h"

@implementation ClassB
- (void)funcB{
    NSLog(@"%s",__func__);
}
@end
1）通过「动态方法解析」来实现多继承

ClassC:

// .h
@interface ClassC : NSObject

@end

// .m
#import "ClassC.h"
#import "ClassA.h"
#import "ClassB.h"
#import "objc/runtime.h"

@interface ClassC ()
@property (nonatomic, strong) ClassA *clsA;
@property (nonatomic, strong) ClassB *clsB;
@end

@implementation ClassC
- (instancetype)init{
    if (self = [super init]) {
        self.clsA = [[ClassA alloc]init];
        self.clsB = [[ClassB alloc]init];
    }
    return self;
}
// MARK: 动态方法解析
// 对象方法
+ (BOOL)resolveInstanceMethod:(SEL)sel {
    if (sel == @selector(funcA)) {
        Method method = class_getInstanceMethod(self, @selector(resolvedFuncA));
        class_addMethod(self, sel, method_getImplementation(method), method_getTypeEncoding(method));
        return YES;
    }
    if (sel == @selector(funcB)) {
        Method method = class_getInstanceMethod(self, @selector(resolvedFuncB));
        class_addMethod(self, sel, method_getImplementation(method), method_getTypeEncoding(method));
        return YES;
    }
    return [super resolveInstanceMethod:sel];
}
// 类方法
+ (BOOL)resolveClassMethod:(SEL)sel {
    return [super resolveClassMethod:sel];
}

- (void)resolvedFuncA {
    [self.clsA funcA];
}
- (void)resolvedFuncB {
    [self.clsB funcB];
}

@end

调用方法

// 使用performSelector调用方法
ClassC *clsC = [[ClassC alloc]init];
[clsC performSelector:NSSelectorFromString(@"funcA") withObject:nil];
[clsC performSelector:NSSelectorFromString(@"funcB") withObject:nil];
2）通过「备用接收者」来实现多继承

ClassC:

// .h
@interface ClassC : NSObject

@end

// .m
#import "ClassC.h"
#import "ClassA.h"
#import "ClassB.h"
#import "objc/runtime.h"

@interface ClassC ()
@property (nonatomic, strong) ClassA *clsA;
@property (nonatomic, strong) ClassB *clsB;
@end

@implementation ClassC
- (instancetype)init{
    if (self = [super init]) {
        self.clsA = [[ClassA alloc]init];
        self.clsB = [[ClassB alloc]init];
    }
    return self;
}
// MARK: 备用接受者
- (id)forwardingTargetForSelector:(SEL)aSelector {
    if (aSelector == @selector(funcA) && [self.clsA respondsToSelector:aSelector]) {
        return self.clsA;
    }
    if (aSelector == @selector(funcB) && [self.clsB respondsToSelector:aSelector]) {
        return self.clsB;
    }
    return [super forwardingTargetForSelector:aSelector];
}

@end
3）通过「完整的消息转发」来实现多继承

ClassC:

// .h
@interface ClassC : NSObject

@end

// .m
#import "ClassC.h"
#import "ClassA.h"
#import "ClassB.h"
#import "objc/runtime.h"

@interface ClassC ()
@property (nonatomic, strong) ClassA *clsA;
@property (nonatomic, strong) ClassB *clsB;
@end

@implementation ClassC
- (instancetype)init{
    if (self = [super init]) {
        self.clsA = [[ClassA alloc]init];
        self.clsB = [[ClassB alloc]init];
    }
    return self;
}
// MARK: 完整的消息转发
- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector{
    if (aSelector == @selector(funcA) && [self.clsA respondsToSelector:aSelector]) {
        return [self.clsA methodSignatureForSelector:aSelector];
    }
    if (aSelector == @selector(funcB) && [self.clsB respondsToSelector:aSelector]) {
        return [self.clsB methodSignatureForSelector:aSelector];
    }
    return [super methodSignatureForSelector:aSelector];
}
- (void)forwardInvocation:(NSInvocation *)anInvocation{
    SEL aSelector = [anInvocation selector];
    if (aSelector == @selector(funcA) && [self.clsA respondsToSelector:aSelector]) {
        [anInvocation invokeWithTarget:self.clsA];
    }
    else if (aSelector == @selector(funcB) && [self.clsB respondsToSelector:aSelector]) {
        [anInvocation invokeWithTarget:self.clsB];
    }
    else {
        [super forwardInvocation:anInvocation];
    }
}

@end

5、通过NSProxy实现多继承

SFProxy：

// .h
@interface SFProxy : NSProxy
-(void)transformToObject:(NSObject *)obj;
@end

// .m
#import "SFProxy.h"

@interface SFProxy ()
@property (nonatomic, strong) NSObject *obj;
@end

@implementation SFProxy
-(void)transformToObject:(NSObject *)obj {
    self.obj = obj;
}
- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector{
    if (self.obj && [self.obj respondsToSelector:aSelector]) {
        return [self.obj methodSignatureForSelector:aSelector];
    }
    return [super methodSignatureForSelector:aSelector];
}
- (void)forwardInvocation:(NSInvocation *)anInvocation{
    SEL aSelector = [anInvocation selector];
    if (self.obj && [self.obj respondsToSelector:aSelector]) {
        [anInvocation invokeWithTarget:self.obj];
    }
    else {
        [super forwardInvocation:anInvocation];
    }
}

@end

方法调用：

ClassA *clsA = [[ClassA alloc]init];
ClassB *clsB = [[ClassB alloc]init];
SFProxy *proxy = [SFProxy alloc];
// 变身为clsA的代理
[proxy transformToObject:clsA];
[proxy performSelector:@selector(funcA) withObject:nil];
// 变身为clsB的代理
[proxy transformToObject:clsB];
[proxy performSelector:@selector(funcB) withObject:nil];

打印：

2020-07-04 12:44:49.893660+0800 OCTestDemo[71379:1458448] -[ClassA funcA]
2020-07-04 12:44:49.893836+0800 OCTestDemo[71379:1458448] -[ClassB funcB]

好了，以上就是间接实现多继承的方案。综合来讲，个人觉得还是「通过协议来实现多继承」较为直观。

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 216,240评论 6赞 498
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 92,328评论 3赞 392
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 162,182评论 0赞 353
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 58,121评论 1赞 292
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 67,135评论 6赞 388
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 51,093评论 1赞 295
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 40,013评论 3赞 417
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 38,854评论 0赞 273
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 45,295评论 1赞 310
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 37,513评论 2赞 332
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 39,678评论 1赞 348
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 35,398评论 5赞 343
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 40,989评论 3赞 325
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 31,636评论 0赞 22
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,801评论 1赞 268
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 47,657评论 2赞 368
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 44,558评论 2赞 352