问题：OC有多继承吗？没有的话用什么代替？

背景

有三个类ClassA、ClassB、ClassC，A和B分别有两个方法run和walk,假设我们需要让C同时拥有run和walk方法，我们要如何做才能达到我们想要的结果呢？

我们都知道OC是不支持多继承的，这是因为消息机制名称查找发生在运行时而非编译时，很难解决多个基类可能导致的二义性问题，但我们可以通过下面几种方法来达到我们想要的效果。

• delegate(代理)
• 组合
• 消息转发（快速转发和标准转发）
• 类别（category）
• NSProxy

一、delegate(代理)

将C类需要继承的方法以及属性在ClassA和ClassB中各自声明一份协议，C类遵守这两份协议，同时在C类中实现协议中的方法以及属性

#ClassA的声明协议
@protocol ClassADelegate
- (void)run;
@property (nonatomic,copy) NSString *runDistance;
@end

#ClassB的声明协议
@protocol ClassBDelegate
- (void)walk;
@property (nonatomic,copy) NSString *walkDistance;
@end

#ClassC遵守ClassADelegate、ClassBDelegate两份协议
#同时在ClassC中实现ClassADelegate、ClassBDelegate两份协议中的方法以及属性
#import "ClassC.h"
#import "ClassA.h"
#import "ClassB.h"

@interface ClassC()<ClassADelegate,ClassBDelegate>
@end

@implementation ClassC
- (void)sport{
    [self run];
    [self walk];
}
- (void)run{
    self.runDistance = @"10000";
    NSLog(@"今天跑了%@步",self.runDistance);
}
- (void)walk{
    self.walkDistance = @"5000";
    NSLog(@"今天走了%@步",self.walkDistance);
}
@synthesize walkDistance;
@synthesize runDistance;
@end

二、组合

在ClassC的.h或者.m文件中,声明ClassA和ClassB的实例，这样我们就可以通过调用A类和B类实例来执行run和walk方法

#ClassC.h文件 声明ClassA和ClassB的实例
@class ClassA,ClassB;
@interface ClassC : NSObject
@property (nonatomic,strong) ClassA *a;
@property (nonatomic,strong) ClassB *b;
- (void)sport;
@end

#ClassC.m文件 调用A类和B类实例来执行run和walk方法
#import "ClassC.h"
#import "ClassA.h"
#import "ClassB.h"

@implementation ClassC
- (void)sport{
    [self.a run];
    [self.b walk];
}
@end

三、消息转发（快速转发和标准转发）

当向某个对象发送消息，但runtime system在当前类以及父类中都找不到对应方法的实现时，runtime system并不会立即报错使程序崩溃，而是依次执行下列步骤：

转发机制

• 1.动态方法解析：向当前类发送resolveInstanceMethod: 信号，检查是否动态向该类添加了方法
• 2.快速消息转发：检查该类是否实现了 forwardingTargetForSelector: 方法，若实现了则调用这个方法，若该方法返回nil或者非self，则向该返回对象重新发送消息。
  快速消息转发的实现方法很简单，只需要重写- (id)forwardingTargetForSelector:(SEL)aSelector方法就可以了，我们来用例子证明，还是拿上面的ClassA和ClassB，假设B有walk方法，而A没有。

#import "ClassA.h"
#import "ClassB.h"
#import "ClassA+MyCategory.h"

@implementation ClassA
- (void)run{
  NSLog(@"跑步");
}
- (id)forwardingTargetForSelector:(SEL)aSelector{
  // 当然这里可以通过判断方法名来决定转发的对象
  //NSString *seletorName = NSStringFromSelector(aSelector);
  //if([seletorName isEqualToString : @"xxx"])
  ClassB *b = [[ClassB alloc] init];
  if([b respondsToSelector:aSelector]){
      return b;
  }
  return nil;
}
@end

#调用
- (void)viewDidLoad {
   [super viewDidLoad];
   ClassA *a = [[ClassA alloc] init];
   [(ClassB *)a walk];
   //[a run];
}

• 3.标准消息转发：runtime发送methodSignatureForSelector:消息获取Selector对应的方法签名。返回值非空则通过forwardInvocation:转发消息，返回值为空则向当前对象发送doesNotRecognizeSelector:消息，程序崩溃退出。
  标准消息转发需要重写 methodSignatureForSelector: 和 forwardInvocation: 两个方法

#import "ClassA.h"
#import "ClassB.h"
#import "ClassA+MyCategory.h"

@interface ClassA(){
   ClassB *_b;
}
@end

@implementation ClassA

- (id)init
{
   self = [super init];
   if (self) {
       _b = [[ClassB alloc] init];
       
   }
   return self;
}
- (void)run{
   NSLog(@"跑步");
}

- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector{
   NSMethodSignature *signature = [super methodSignatureForSelector:aSelector];
   // 当然这里可以通过判断方法名来决定转发的对象
   //NSString *seletorName = NSStringFromSelector(aSelector);
   //if([seletorName isEqualToString : @"xxx"])
   //ClassB *b = [[ClassB alloc] init];
   if(signature == nil){
       signature = [_b methodSignatureForSelector:aSelector];
   }
   NSUInteger argCount = [signature numberOfArguments];
   for (NSInteger i=0; i<argCount; i++) {
         NSLog(@"%s" , [signature getArgumentTypeAtIndex:i]);
   }
   NSLog(@"returnType:%s ,returnLen:%ld" , [signature methodReturnType] , [signature methodReturnLength]);
   NSLog(@"signature:%@" , signature);
   return  signature;
}
- (void)forwardInvocation:(NSInvocation *)anInvocation{
   // 当然这里可以通过判断方法名来决定转发的对象
   //NSString *seletorName = NSStringFromSelector(aSelector);
   //if([seletorName isEqualToString : @"xxx"])
   SEL selector = [anInvocation selector];
   //ClassB *b = [[ClassB alloc] init];
   if([_b respondsToSelector:selector]){
       //这里如果没有响应，系统则会报错崩溃
       [anInvocation invokeWithTarget:_b];
   }
}
@end
运行结果
2020-01-04 10:32:34.288075+0800 MethodSwizzlingDemo[2006:407016] @
2020-01-04 10:32:34.288303+0800 MethodSwizzlingDemo[2006:407016] :
2020-01-04 10:32:34.288399+0800 MethodSwizzlingDemo[2006:407016] returnType:v ,returnLen:0
2020-01-04 10:32:34.288592+0800 MethodSwizzlingDemo[2006:407016] signature:<NSMethodSignature: 0x60000047a540>
2020-01-04 10:32:34.288887+0800 MethodSwizzlingDemo[2006:407016] 散步

四、类别（category）

类别也可以用来模拟多继承，比如

• 当前类添加方法。
• 利用runTime来添加属性。

#import "ClassA.h"
@interface ClassA (MyCategory)
- (void)walk;//添加方法
@property (nonatomic,copy)NSString *myselfStr;//利用runTime来添加属性
@end

@implementation ClassA (MyCategory)

static NSString *const myStr;

- (void)walk {
  NSLog(@"走路" );
}
- (void)setMyselfStr:(NSString *)myselfStr {
    objc_setAssociatedObject(self, &myStr, myselfStr, OBJC_ASSOCIATION_COPY);
}

- (NSString *)myselfStr {
    return objc_getAssociatedObject(self, &myStr);
}
@end

- (void)viewDidLoad {
   [super viewDidLoad];
   ClassA *a = [[ClassA alloc] init];
   [a walk];
}

五、NSProxy

我们都知道NSObject是Objective-C中大部分类的基类。但不是很多人知道除了NSObject之外的另一个基类——NSProxy,苹果官方文档是这样描述的

NSProxy is an abstract superclass defining an API for objects that act as stand-ins for other objects or for objects that don’t exist yet. Typically, a message to a proxy is forwarded to the real object or causes the proxy to load (or transform itself into) the real object. Subclasses of NSProxy can be used to implement transparent distributed messaging (for example, NSDistantObject) or for lazy instantiation of objects that are expensive to create.
NSProxy 是一个抽象基类，它是为一些作为对象的替身或者并不存在的对象定义的API。一般的，发送给代理的消息被转发给一个真实的对象或者代理本身引起加载(或者将本身转换成)一个真实的对象。NSProxy的基类可以被用来透明的转发消息或者耗费巨大的对象的lazy 初始化。

就是说，NSProxy是一个虚类，你可以通过继承它，并重写这两个方法以实现消息转发到另一个实例

- (void)forwardInvocation:(NSInvocation *)anInvocation;
- (NSMethodSignature *)methodSignatureForSelector:(SEL)sel;

现在NSProxy的真面目终于浮出水面：

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

还是以ClassA、ClassB、ClassC为例：

-------------------------------------------------
//  ClassA.h
#import <Foundation/Foundation.h>

#ClassA的声明协议
@protocol ClassADelegate
- (void)run;
@end

@interface ClassA : NSObject
@end
-------------------------------------------------
//  ClassA.m
#import "ClassA.h"

@interface ClassA () < ClassADelegate >
@end

@implementation ClassA
- (void)run {
    NSLog(@"跑步");
}
@end
-------------------------------------------------

-------------------------------------------------
//  ClassB.h
#import <Foundation/Foundation.h>

#ClassB的声明协议
@protocol ClassBDelegate
- (void)walk;
@end

@interface ClassB : NSObject
@end
-------------------------------------------------
//  ClassB.m
#import "ClassB.h"

@interface ClassB () < ClassBDelegate >
@end

@implementation ClassB
- (void)walk {
    NSLog(@"走路");
}
@end
-------------------------------------------------

一定要通过protocol来声明接口，而不是直接在类的@interfere中定义。因为通过protocol来声明接口，然后让proxy类遵循此协议，可以骗过编译器防止编译器提示proxy类未声明接口的错误。这个问题下面可以看到。

-------------------------------------------------
//  ClassC.h
#ClassC这个子类必须要遵循之前定义的两个协议ClassADelegate与ClassBDelegate
#目的是骗过编译器，让编译器认为这个类实现了上面两个协议

#import <Foundation/Foundation.h>
#import "ClassA.h"
#import "ClassB.h"

@interface ClassC : NSProxy < ClassADelegate, ClassBDelegate >
+ (instancetype )dealerProxy;
@end
-------------------------------------------------
//  ClassC.m

#import "ClassC.h"
#import <objc/runtime.h>

@interface ClassC () {
    ClassA          *_classA;
    ClassC       *_classB;
    NSMutableDictionary     *_methodsMap;
}
@end

@implementation ClassC

#pragma mark - class method
+ (instancetype)dealerProxy{
    return [[ClassC alloc] init];
}

#pragma mark - init
- (instancetype)init{
    _methodsMap = [NSMutableDictionary dictionary];
    _ classA = [[ClassA alloc] init];
    _classB = [[ClassB alloc] init];

    //映射target及其对应方法名
    [self _registerMethodsWithTarget: classA];
    [self _registerMethodsWithTarget: _classB];

    return self;
}

#pragma mark - private method
- (void)_registerMethodsWithTarget:(id )target{
    
    unsigned int numberOfMethods = 0;
    
    //获取target方法列表
    Method *method_list = class_copyMethodList([target class], &numberOfMethods);
    
    for (int i = 0; i < numberOfMethods; i ++) {
        //获取方法名并存入字典
        Method temp_method = method_list[i];
        SEL temp_sel = method_getName(temp_method);
        const char *temp_method_name = sel_getName(temp_sel);
        [_methodsMap setObject:target forKey:[NSString stringWithUTF8String:temp_method_name]];
    }
    
    free(method_list);
}
#pragma mark - NSProxy override methods
- (void)forwardInvocation:(NSInvocation *)invocation{
    //获取当前选择子
    SEL sel = invocation.selector;
    
    //获取选择子方法名
    NSString *methodName = NSStringFromSelector(sel);
    
    //在字典中查找对应的target
    id target = _methodsMap[methodName];
    
    //检查target
    if (target && [target respondsToSelector:sel]) {
        [invocation invokeWithTarget:target];
    } else {
        [super forwardInvocation:invocation];
    }
}

- (NSMethodSignature *)methodSignatureForSelector:(SEL)sel{
    //获取选择子方法名
    NSString *methodName = NSStringFromSelector(sel);
    
    //在字典中查找对应的target
    id target = _methodsMap[methodName];

    //检查target
    if (target && [target respondsToSelector:sel]) {
        return [target methodSignatureForSelector:sel];
    } else {
        return [super methodSignatureForSelector:sel];
    }
}

@end
-------------------------------------------------

#调用
- (void)viewDidLoad {
   [super viewDidLoad];
  ClassC *classC = [ClassC dealerProxy];
    [classC run];
    [classC walk];
}
运行结果
2020-05-04 10:32:34.288075+0800 ProxyDemo[2006:407016] 跑步
2020-05-04 10:32:34.288303+0800 ProxyDemo[2006:407016] 走路

感觉NSProxy实现多继承就像，代理+组合+消息转发的结合体。