OC 中一个类只有一个父类 但是我们可以用协议和 NSProxy 实现多继承

1. protocol

先说协议

比如我有两个协议, 分别是 Person,Student

#import <Foundation/Foundation.h>
@protocol Person <NSObject>
@required
@property (nonatomic,copy)NSString *name;
 
@optional
- (void)sleep;
@end

#import <Foundation/Foundation.h>
@protocol Man <NSObject>
@required
- (NSString *)nickname;
@optional
- (void)study;

那么, 我在新创建的一个 Student 类中, 只要遵守上面两个协议, 实现协议里的方法, 就可以在一个类中,实现多个协议中的方法了.

@interface Student : NSObject<Man,Person>
 
@end
@implementation Student
- (NSString *)nickname
{
    return @"花花";
}
- (void)sleep
{
    NSLog(@"困了");
}
- (void)study{
    NSLog(@"好好学习");
}
@end

调用的时候

Student *student = [[Student alloc]init];
student.name = @"小花";
[student study];
[student sleep];
NSLog(@"%@",student.nickname)；

2.NSProxy

首先什么是NSProxy：

• NSProxy是一个抽象的基类，是根类，与NSObject类似
• NSProxy和NSObject都实现了<NSObject>协议
• 提供了消息转发的通用接口

我们如何使用NSProxy实现消息转发呢？

例：

• 我先设置一个类 MyProxy, 继承自 NSProxy
• 为 MyProxy 设置一个 NSObject 属性
• 自定义一个方法,给 NSObject 属性赋值
• 然后通过这个NSObject属性获得调用方法的方法签名,也就是：methodSignatureForSelector:
• 设置调用目标：调用forwardInvocation:这个方法

3.使用NSProxy实现多继承

#import <Foundation/Foundation.h>
 
@interface MyProxy : NSProxy
 
- (id) changeToAnyObject:(NSObject *)object;
 
@end
 
#import "MyProxy.h"
 
@interface MyProxy ()
 
@property (nonatomic,strong)NSObject *object;
 
@end

@implementation MyProxy
- (id) changeToAnyObject:(NSObject *)object
{
    self.object = object;
    return self.object;
}
 
- (NSMethodSignature *)methodSignatureForSelector:(SEL)sel
{
    NSMethodSignature *methodSignature;
    
    if (self.object) {
        methodSignature = [self.object methodSignatureForSelector:sel];
    }else{
        methodSignature = [super methodSignatureForSelector:sel];
    }
    return methodSignature;
}
 
- (void)forwardInvocation:(NSInvocation *)invocation
{
    if (self.object) {
        [invocation setTarget:self.object];
        [invocation invoke];
    }
}
@end

创建一个Person类

#import "Person.h"
 
@interface Person ()
 
@property (nonatomic,copy)NSString *name;
 
@end
 
@implementation Person
 
- (void)eat
{
    NSLog(@"%@正在吃饭",self.name);
}

创建一个Student类

#import "Student.h"
 
@interface Student ()
 
@end
 
@implementation Student
 
- (void)study
{
    NSLog(@"好好学习");
}

调用

Person *person = [[Person alloc]init];
Student *student = [[Student alloc]init];
MyProxy *proxy = [MyProxy alloc];

//类似成为Person的子类
[proxy changeToAnyObject:person];

//这样就可以调用 Person 类的方法了
[proxy performSelector:@selector(setName:) withObject:@"小花花"];
[proxy performSelector:@selector(eat)];

//类似成为学生的子类
[proxy changeToAnyObject:student];

//这样又可以调 Student类的方法了
[proxy performSelector:@selector(study)];

3.1使用NSPRoxy

一些开源项目中使用NSProxy来避免循环引用 比如YYLabel
NSTimer是一个需要添加到Runloop里的类，对于一个不会自动停止的Timer，你需要调用invalidate方法来手动断开这个Timer。否则，引用Timer的Controller或者其他类，就会出现循环引用而无法释放掉。
举个例子,在Controller中，添加Timer很常见，比如:

#import "SecondViewController.h"
@interface SecondViewController ()
 
@property (strong,nonatomic)NSTimer * timer;
 
@end
@implementation SecondViewController
 
- (void)viewDidLoad{
    [super viewDidLoad];
    self.timer = [NSTimer timerWithTimeInterval:1
                                         target:self
                                       selector:@selector(timerInvoked:)
                                       userInfo:nil
                                        repeats:YES];
    [[NSRunLoop mainRunLoop] addTimer:self.timer forMode:NSRunLoopCommonModes];
}
- (void)timerInvoked:(NSTimer *)timer{
    NSLog(@"1");
}
- (void)dealloc{
    NSLog(@"Dealloc");
}
@end

假如我Push这样一个SecondViewController,然后pop。
你会发现Controller没有被释放，timer也没有被取消。

我们可以在dealloc中，调用Timer取消吗？比如

- (void)dealloc
{
    [self.timer invalidate];
    NSLog(@"Dealloc");
}

当然不行，因为Controller根本没有被释放，dealloc方法根本不会调用。
当然，破坏这种循环引用的方式有很多种。本文主要讲解如何用 NSProxy 来破坏。
我们写一个WeakProxy来实现弱引用
1.为外界暴露一个变身方法:

@interface WeakProxy : NSProxy
+ (instancetype)proxyWithTarget:(id)target;
- (instancetype)initWithTarget:(id)target;
@end

2.设置一个 NSObject 属性

#import "WeakProxy.h"
@interface WeakProxy ()
@property (weak,nonatomic,readonly)id target;
 
@end

3.实现变身方法

- (instancetype)initWithTarget:(id)target{
    _target = target;
    return self;
}
+ (instancetype)proxyWithTarget:(id)target{
    return [[self alloc] initWithTarget:target];
}

4.重写- (NSMethodSignature *)methodSignatureForSelector:(SEL)see方法获得方法签名

- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector{
    return [self.target methodSignatureForSelector:aSelector];
}

5.重写- (void)forwardInvocation:(NSInvocation *)invocation方法改变调用对象,也就是说,让消息实际上发给真正的实现这个方法的类

- (void)forwardInvocation:(NSInvocation *)invocation{
    SEL sel = [invocation selector];
    if ([self.target respondsToSelector:sel]) {
        [invocation invokeWithTarget:self.target];
    }
}
- (BOOL)respondsToSelector:(SEL)aSelector{
    return [self.target respondsToSelector:aSelector];

}

调用

self.timer = [NSTimer timerWithTimeInterval:1 target:[WeakProxy proxyWithTarget:self] selector:@selector(timerInvoked:) userInfo:nil repeats:YES];

[原文链接]：(https://blog.csdn.net/shubinniu/article/details/80895450)
NSProxy还有更多强大的地方，后续更新。。。。