我们在学iOS开发中,一直使用了OC语言做面向对象开发(就是找不到对象的时候new一个就好的那种).
也许你没有研究过,你写的代码编译后到底变成了什么东西.你可以进入iOS虚拟机的目录下,查看你的app目录,你会发现一个unix的可执行文件,没错,你写的代码都在这文件中,不管你创建了多少个.h和.m文件,最终只有它一个
你肯定很像打开它,然而没有一个程序可以打开它,因为他已经不是OC文件了.
它现在保存着一个app被加载到内存时候做的事情,包括对屏幕上的UI控件的触摸响应,它使用的语言叫做汇编,一个最接近计算机硬件的语言,也就是CPU唯一能认识的计算机语言.

Runtime藏匿与 C 与 OC 之间

在接下来的说明中，我必须要提起别的事情。

我们在学 iOS 开发中，一直使用了 OC 语言做面向对象开发(就是找不到对象的时候new一个就好的那种)。

也许你没有研究过，你写的代码编译后到底变成了什么东西。你可以进入 iOS 虚拟机的目录下，查看你的 app 目录。你会发现一个 Unix 的可执行文件。没错，你写的所有代码都在这文件中，不管你创建了多少个 .h 和 .m 文件，最终只有它一个。

你肯定很想打开它，然而没有一个程序可以打开它。因为它已经不再是 Objective-C 文件了。

它现在保存着一个 app 被加载到内存时候要做的事情，包括对屏幕上的 UI 控件的触摸响应。它使用的语言叫做汇编，一个最接触计算机硬件的语言，也就是 CPU 唯一能认识的计算机语言。

如果你真的很想知道他是什么,你可以去学习汇编语言,传说中用1和0就能就能变成,到时候你就和一反向编译任何app了.

既然你知道最终变成汇编,那你一定疑问为什么会这样?

因为CPU只认得数字,不认得字母,所以这个背景下任何一个可执行的语言最终编译后都会变成汇编

然而OC到汇编并不是一步的,其中还经历了C,甚至还有可能是C++.

但是C语言是最接近汇编语言的,因为C语言有直接的内存操作.而C语言又是用英语写的,人易看懂的语言.OC在变成汇编前,它先变成了C,然后才是汇编.

你一定会问:他们变来变去跟我有毛关系!

那你一定没有发现一个问题,OC是一个面向对象的语言,C语言是面向过程的,OC和C最大的区别是C没有”类”.那么,OC变成C语言后,面向对象特有的类变成了什么,类是怎么存在面向过程语言中的?

这个问题便引出了Runtime的表现形式.

Runtime用结构体做出了类在面向过程语言的实现

“你逗我?类有属性,有方法,有实例变量,结构体顶多存实例变量,方法又是什么鬼?”

并没有逗你,只是这个结构体的确可以保存这么多东西!

那么这个接头体到底长什么样,写不同而类,变成结构体都不一样吗?

#import <objc/rutime.h>

然后进入Rutime的头文件定义,你会发现如下结构体

struct objc_class{Class isa OBJC_ISA_AVAILABILITY;
#if !__OBJC2__Class super_class                       OBJC2_UNAVAILABLE;const char *name                                         OBJC2_UNAVAILABLE;long version                                             OBJC2_UNAVAILABLE;long info                                                OBJC2_UNAVAILABLE;long instance_size                                       OBJC2_UNAVAILABLE;struct objc_ivar_list *ivars                             OBJC2_UNAVAILABLE;struct objc_method_list **methodLists                    OBJC2_UNAVAILABLE;struct objc_cache *cache                                 OBJC2_UNAVAILABLE;struct objc_protocol_list *protocols                     OBJC2_UNAVAILABLE;
#endif} OBJC2_UNAVAILABLE;

这个结构体的名称叫做objc_class,我相信你在开发中绝对不会用到这个结构体,你有可能看过这篇文章的时候才第一次见到,但是有个东西你可能用过,他叫Class

在 main.m 文件中在导入一个文件:

#import <objc/objc.h>

也点进去看看,会有这么几行

typedef struct objc_class*Classstruct objc_object{Class isa OBJC_ISA_AVAILABILITY;
};typedef struct objc_object*id;

我删除了中间的注释,为的是让你看的更清楚一些.

如果你有C语言基础,你一定知道typedef的语法及含义.

苹果重新定义objc_class这个结构体,并取名为*Class,也就是说Class是一个objc_class的一个指针,同样id也是objc_object的一个指针.

非常的显然了,平时我们这样编写代码:

id obj=[[NSObject alloc]init];

obj是一个NSObject的一个对象,而本质上obj是一个id,而id又是一个objc_object结构体的一个指针,所以你其实得到的只是一个结构体指针而已

那么同样,类其实也是有对象的,因为你可以这样打:

Class c=[obj class];

这样c就是objc的类型了,然后你可以直接通过这个c来创建对象:

id other_obj=[[c alloc]init];

如果你细心的话,你会发现

Class保存的一个类对象,但本质是objc_class的指针

id保存一个对象,但本质是objc_object的指针

而我们所做的所有面向对象编程,对对象的操作,最终都会落实到结构体上,这些结构体保存着一个对象的所有信息

我们从结构体开始介绍(objc_object)

当我们获取到一个对象的时候,说白了就是一个对象的引用,也就是一个id.上面那个结构体被重定义为*id,那么id就是一个objc_object的指针.

这个结构体里有一个成员,是类型为Class的一个isa.我们可以这么理解,我们实例化出来的对象,他实际上只保存一个类的结构体的指针,也就是为了说明这个对象是由什么类型实例化出来的.

现在来看看累的结构体(objc_object).

对象被实例化出来后,也就保存了那个创造自己的了的信息,这个信息也就是一个objc_class结构体,那么我们来看看,这个结构体到底保存了哪些关于一个类的信息.

• Class isa
  *保存一个objc_class的一个指针,叫做isa
  *这个isa和objc_object中的重名,具体内容和区别之后分析
• Class super_class
  *保存一个objc_class的一个指针,叫做super_class
  *显而易见,这里就是一个指向父类的指针,为了保存自己是从那里继承来的
• char *name
  
  • 保存这个类名的字符串指针
  • 这个也不用多解释，NSObject类里这里的值就是”NSObject”
• long version
• long info
• long instance_size
  
  • 以上三个成员不多解释，用不到
• struct objc_ivar_list *ivars
  
  • 从定义可以看出，是一个结构体指针，保存着这个类的实例变量列表
• struct objc_method_list **methodLists
  
  • 从定义可以看出，是一个结构体指针，保存着这个类的方法列表
• struct objc_cache *cache
  
  • 从定义可以看出，是一个结构体指针，保存缓存
  • 什么东西可以保存到缓存，这个下文会解释
• struct objc_protocol_list *protocols
  
  • 从定义可以看出，是一个结构体指针，保存协议列表

我们写的类,实际上也就是这些东西,一个实例变量,一些方法,实现一些协议,海哥类取了个名字,拥有弗雷德所有特性.

现在我们终于知道我们写的类最终会变成了一个什么样的结构体.

你一定会问,这些结构体和我们runtime 有什么关系,它仅仅是编译时候的产物,和开发有什么关系.

机构体的作用

结构体,就是一块内存,用于统一保存大小不同且不变的集合.

在C语言中,允许我们去创建与修改结构体

对,你们有听错,就是修改.我们可以动态的修改这些结构体内的内容,甚至你再一个对象创建后,你可以真真切切地修改他的类型和父类,你甚至可以为一个类动态的增加方法,而不是在.m文件中去写方法.同样,你甚至可与修改苹果写的类.

这样很多问题变得很简单.

比如有两个人开发,你的小伙伴是主要开发者,而你就是帮他写工具类.后来我们发现,UIAlertController在低版本的iOS系统可能会出现闪退,但是你们的项目已经子阿哥各地方都用到了,你们觉得一个一个找到他们在做版本适配是一个大工程.

此时,你就可以利用Runtime去写版本适配代码,把相关方法,都做一下修改(这写方法都是苹果写好的,你要修改就只能集成,但是Runtime不需要你继承就可以直接修改),然后导入到工程中,所有的代码均作了适配.

在你使用Runtime的时候,你必须知道Runtime是出于什么位置.

Runtime的一遍是面向过程的C语言,另一边是面向对象的OC.你通过C语言去做面向对象开发.也就是说你绕过了OC,去做了面向对象开发

OC是一个成熟的面向对象语言,他拥有一个面向对象语言应有的机制和保护,保证你写的代码在面向对象层是正确的(这里是☞你写的方法绝对不会变成另一个类的方法,而不是你写的bug).

一旦你绕过了OC,利用Runtime做面向对象开发,那么你写的代买就不受一个成熟的面向对象的语言所保护很可能出现面向对象层的运行错误.

乱用Runtime很有可能破坏面向对象机制

好吧,Runtime就是这么强大,Runtime就是这么可怕.

最终类,的结构体是可以进行数据的读写的,也就是说允许你在程序运行的时候动态的改变一个类的信息.

当程序运行到某一个时间点,我们可以给一个类添加一个方法
比如这个点事8:00,添加的方法名叫做newMethod在,8:00前调用newMethod会程序崩溃,蛋8:00后调用newMethod就不会崩溃.

比如你把一个累的实例方法换到了另一个类上,然后去调用它.编译时并不会报错.但运行时就会出现错误.

你再改造OC,OC是一个成熟的语言,甚至比你还要老,你去改造他?

如果你技术成熟,改造可以让OC更能配合你的开发.

如果你技术不成熟,改造后后果无法预测.

OC的消息机制是指,在外部需要执行某个对象的方法时,使用的方式是”发送消息”而不是”调用”.

在学Runtime之前你学对不理解为什么是发送消息而不是调用.

其实很简单,最终结果都是执行一段代码.但是OC要执行那段代码是不会确定的,而”调用”是确定的.

不确定的原因

Runtime 允许我们去修改一个方法的实现,也就是说,外部告诉一个对象,执行”xxx”方法,但是那个对象是否执行和执行什么内容是不能确定的.

比如我写了一个方法

in Class MyClass:
-(void)aMethodCreatedByMyself{NSLog(@"%s","aMethodCreatedByMyself");
}

然后我在外部调用

MyClass *myObj=[MyClass alloc]init];
[myObj aMethodCreatedByMyself];

它输出了aMethodCreatedByMyself

看似确定的代码,其实是不确定的.因为你没有写任何的Runtime代码,所以这个方法没有做过任何”运行时修改”.所以你觉得它很确定.但是如果我再别的地方,对这个方法做修改,修改他的实现内容,那么输出救国就会大不一样.

如果你现在不裂解,之后学到方法修改的时候,你就会恍然大悟了.

现在来上手操作一下

新建一个Mac OC X命令行工程
然后你得到了一个main.m文件
在main.m文件中写一句最简单的实例化对象的代码

id obj=[NSObject alloc]init];
//或许你喜欢上面这种写法,但是这里我希望你用下面的写法
//这样我们会更好的看出编译后到底长什么样.
id obj=[NSObject alloc];
obj=[obj init];

保存一下后,用终端cd到这个文件的目录

cd~/Desktop/Runtime/Runtime

然后执行便已命令,编译成C++

clang -rewrite-objc main.m

然后你就可以得到一个main.cpp文件,这就是C++文件了.

打开这个文件,到文件的最后,你可以找到你写的main函数,看看它有什么秘密

id obj=((NSObject *(*)(id,SEL))(void *)objc_msgSend)((id)objc_getClass("NSObject"),sel_registerName("allpc"));
obj=((id(*)(id,SEL))(void*)objc_msgSend)((id)obj,sel_registerName("init"));

看不懂 但是可以缩略一下.

首先我们写的第一句话

id obj=[NSObject alloc];
//翻译成C++后
Class classForAlloc=objc_getClass("NSObject");//get class
SEL selForAlloc=sel_registerName("alloc");//get selector
id obj=objc_msgSend(classForAlloc,selForAlloc);//do selector and get obj

1.通过一个字符串创建一个类的结构体指针
2.通过一个字符串创建一个类方法的结构体指针
3.向类结构体发送一个消息,得到一个结果.

之后我们写了另一句话

obj=[obj init];
//翻译后
SEL selForInit=sel_registerName("init");
obj=objc_msgSend(obj,selForInit);

这就是一个简单的消息机制,把面向对象变为面向过程.

我们知道了所有类都是结构体指针,所有的对象也是结构体指针.我们还知道了OC的消息机制.现在我们试图去使用objc/runtime.h文件来进行编程.

创建一个Mac OS X 命令行(为了编译运行快速)工程,在main.m文件中引入runtime的头文件

#import<objc/runtime.h>

现在你就可以使用runtime里面的方法了.

我们要研究的是类和对象,自然需要一个类和一个对象了.

首先需要一个类,我们自己定义一个类;

@interface ZQPerson@property(copy)NSString *name;
@end

这里我们需要一个obj,就取一个NSArray类型的对象

#import "ZQPerson"ZQPerson *person=[[ZQFperson alloc]init];

现在你可以进入objc/runtime.h里面看看有什么公开的函数.

对于那些一看就能看懂用途的函数我就不介绍了,接下来介绍比较常用的功能.

*枚举属性
*关联对象
*方法交换

枚举属性

在操作之前，我们必须要为这个类添加一些属性，以供我们枚举

@interface TRPerson : NSObject@property (nonatomic, copy, readonly) NSString *name;@property (nonatomic, strong) NSObject *obj;@property (nonatomic, weak, setter=resignIdentifier:) id identifier;@property (nonatomic, assign, getter=isRight) BOOL boolValue;@property (nonatomic, assign) CGFloat cgFloat;@property (atomic, assign) CGRect cgRect;@end

回到main.m文件,现在开始使用runtime.h来枚举这些东西

unsigned int outCount = 0;
objc_property_t *propertyList = class_copuPropertyList([ZQPerson class],&outCount);
for (int i = 0; <outCount; i++){const char *name = property_getName(propertyList[i]);const char *attribute = property_getAttributes(propertyList[i]);NSLog(@"\n name = %s\n attribute = %s",name,attribute);
}

首先看里面的函数函数,

objc_property_t *class_copuPropertyList(Class cls, unsigned int *outCount);

这个函数的作用是枚举出一个类的所有属性

参数一:Class cls 类

参数二:unsigned int *outCount

返回值:objc_property_t的数组

所以我们给的第一个参数是[ZQPerson class]

第二个参数是为了得到这个数组的长度,所以我们在前面声明了一个变量,并把这个变量的地址传到第二个参数中,函数会自动给他赋值属性个数.

获取到了数组和数组长度,我们就可以通过for循环遍历这个数组了.

在循环中,我们使用了两个方法 第一个是

const char *property_getName(objc_property_t *property);

这个函数可以返回这个属性的名称

另一个函数是

const char *attribute = property_getAttributes(propertyList[i]);

这个函数可以返回这个属性的属性,就是我么你在.h文件中写在”()”中的内容

看看输出结果

2015-11-23 22:09:30.483 temp[900:74089] 
name = name
attribute = T@"NSString",R,C,N,V_name2015-11-23 22:09:30.483 temp[900:74089] 
name = obj
attribute = T@"NSObject",&,N,V_obj2015-11-23 22:09:30.483 temp[900:74089] 
name = identifier
attribute = T@,W,N,SresignIdentifier:,V_identifier2015-11-23 22:09:30.484 temp[900:74089] 
name = boolValue
attribute = Tc,N,GisRight,V_boolValue2015-11-23 22:09:30.484 temp[900:74089] 
name = cgFloat
attribute = Td,N,V_cgFloat2015-11-23 22:09:30.484 temp[900:74089] 
name = cgRect
attribute = T{CGRect={CGPoint=dd}{CGSize=dd}},V_cgRect

现在我们整理一下代码和输出

@property (nonatomic, copy, readonly) NSString *name;
name = name
attribute = T@"NSString",R,C,N,V_name@property (nonatomic, strong) NSObject *obj;
name = obj
attribute = T@"NSObject",&,N,V_obj@property (nonatomic, weak, setter=resignIdentifier:) id identifier;
name = identifier
attribute = T@,W,N,SresignIdentifier:,V_identifier@property (nonatomic, assign, getter=isRight) BOOL boolValue;
name = boolValue
attribute = Tc,N,GisRight,V_boolValue@property (nonatomic, assign) CGFloat cgFloat;
name = cgFloat
attribute = Td,N,V_cgFloat@property (atomic, assign) CGRect cgRect;
name = cgRect
attribute = T{CGRect={CGPoint=dd}{CGSize=dd}},V_cgRect

好的,这样就很明显了,name是一个很好理解的字符串,

所以介绍一下attribute这个字符串

attribute

以T开头

每一个attribute都是以T开头,可以理解为规定

可能包含有@符号

属性类型

@之后就是类型,如果是id就为空,如果不是就是双引号加类名

如果没有@就是基础数据类型,

这理解是一下CGFloat和CGRect

CGFloat是double数据类型,所以是d

而CGRect,有两个成员,一个是CGPoint一个是CGSize

CGPoint 有两个成员，都是 CGFloat，所以有 CGPoint={dd}

同理，CGSize 也有两个 CGFloat，所以有 CGSize={dd}

以此类推，CGRect={CGPoint=dd}{CGSize=dd}

属性属性

通过不同属性的attribute值得比较和OC代码的参考之后的字母可以总结为

字母	OC	含义
有R	readonly	只读
无R	readwrite	读写
有N	nonatomic	线程不安全
无N	atomic	线程安全
C	copy	复制
&	strong/retain	强引用
W	weak	弱引用
Sxxx:	setter	set方法
Gxxx	getter	get方法
Vxxx	var	实例变量

关联对象

关联对象目前比较常用的地方就是给已有的类添加属性和对应的成员变量.

利用Category 给现有的类添加属性

比如我们要给一个NSArray添加一个属性叫做ZQPerson *person.

在之前的工程中,我们新建一个**OC文件.

File:`Person`File Type:`Category`Class:`NSArray`

然后我们在NSArray+Person.h里写

#import "TRPerson.h"@interface NSArray (Person)@property (nonatomic, strong) TRPerson *person;@end

于是我们就给NSArray这个类添加了一个ZQPerson类型的person

进入main.m文件试验一下:

NSArray *array = @[@"Magic", @"Unique"];
TRPerson *person = [TRPerson new];
array.person = person;
NSLog(@"%@", array.person);

我们新建了一个NSArray和一个ZQPerson,并把person复制给了array的属性中.

然后输出看看这个属性是否成功赋值.

于是你很开心的按下了command+r,发现这家伙崩溃了,崩溃原因:

[__NSArrayI setPerson:]unrecognized selector sent to instance 0x100400d90

NSArray并没有这个setPerson:这个方法,仔细一看Xcode还给我们连个警告.

于是我们进入NSArray+Person.m文件写上get方法和set方法;

#import "NSArray+Person.h"@implementation NSArray (Person)- (void)setPerson:(TRPerson *)person {
_person = person;
}- (TRPerson *)person {
return _person;
}@end

很好,两个错误,因为没有实例变量,或许你觉得可以添加一个扩展,于是你写了一个扩展并且给他添加了一个实例变量ZQPerson *_person,然后这次连编译都不通过

Category只能给已有的类添加方法,不能添加实例变量

利用Runtime 和Category 给现有的类添加属性

关联对象

关联对象是只将一个对象a利用一个key绑定一个对象b,之后a就可以利用这个key获取到这个对象b

同时a可以二次绑定同一个key,并且会替换之前被绑定的对象,之后再通过key获取对象,就是一个新绑定的值了

是不是感觉和普通的属性很像?可以赋值可以取值,可以重复赋值然后覆盖.

的确,只是调用一个函数而已

函数

Runtime 给了我们两个函数来实现关联对象,只需要 #import

//set function
void objc_setAssociatedObject(id object, const void *key, id value, objc_AssociationPolicy policy);//get function
id objc_getAssociatedObject(id object, const void *key);

负值函数

来看看set函数里的东西

• object 要持有“别的对象”的对象，这里也就是指a
• key 关联关键字，是一个字符串常亮，是一个地址(这里注意，地址必须是不变的，地址不同但是内容相同的也不算同一个key)
• value 也就是值，你可以猜的出应该是值b了
• policy 这是一个枚举，你可以点进去看看这个枚举是什么：
  
  • OBJC_ASSOCIATION_ASSIGN
  • OBJC_ASSOCIATION_RETAIN_NONATOMIC
  • OBJC_ASSOCIATION_COPY_NONATOMIC
  • OBJC_ASSOCIATION_RETAIN
  • OBJC_ASSOCIATION_COPY

如果你了解 Objective-C，那你一定知道上面这些枚举的作用了。

所以，我们就可以在前面的NSArray的分类里这么写

- (void)setPerson:(ZQPerson *)person {
objc_setAssociatedObject(self, "person", person, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}

取值函数

现在来看看 get 函数里的东西

• object 持有“别的对象”的对象，这里指a
• key 关联关键字

看完 set 函数之后，get 函数就显而易见了！这里不用多解释，立马就可以写代码

- (TRPerson *)person {
return objc_getAssociatedObject(self, "person");
}

验证结果

运行demo，成功输出如下内容：

2015-11-25 23:18:11.625 temp[745:79654] <TRPerson: 0x100305b60>

说明我们给 array 赋值的结果成功保留下来，下一次去取值可以成功取到上一次保存的值了。

我们会想一下可以发现,OC的对象是有一个结构体指针过程的,结构体指针如下

struct objc_class {
Class isa  OBJC_ISA_AVAILABILITY;
#if !__OBJC2__
Class super_class                                        OBJC2_UNAVAILABLE;
const char *name                                         OBJC2_UNAVAILABLE;
long version                                             OBJC2_UNAVAILABLE;
long info                                                OBJC2_UNAVAILABLE;
long instance_size                                       OBJC2_UNAVAILABLE;
struct objc_ivar_list *ivars                             OBJC2_UNAVAILABLE;
struct objc_method_list **methodLists                    OBJC2_UNAVAILABLE;
struct objc_cache *cache                                 OBJC2_UNAVAILABLE;
struct objc_protocol_list *protocols                     OBJC2_UNAVAILABLE;#endif} OBJC2_UNAVAILABLE;

在这里我们可以找到
实例变量struct objc_ivar_list *ivars
方法列表struct objc_method_list **methodLists
缓存方法列表struct objc_cache *cache

当我们向对象发消息的时候,OC会到缓存方法中开始找方法的指针,如果缓存列表中找不到,就会到方法列表中找,如果本类的方法列表中找不到,就会到父类里面找,知道找到方法的指针或者最终的父类NSObject也找不到方法的指针为止.当找不到方法指针的时候,编译器会发出[xxx 方法]unrecognized selector sent to instance的警告
当找到方法指针的时候,OC会将在内存中找到方法指针所指向的那个代码块并运行它.

我们知道,程序之所以能运行,是一位方法和变量都存在程序的内存中,所以如果我们改变了方法指针指针所指向的内存地址的内容或者直接改变了方法指针指向的地址,我们就可以改变了方法的实现.

Runtime中的方法交换

Runtime给了我们一个函数来实现方法交换,你只需要导入objc/Runtime.h文件即可使用这个函数

这个函数是

/** 
* Exchanges the implementations of two methods.
* 交换两个方法的实现
* 
* @param m1 Method to exchange with second method.
* @param m2 Method to exchange with first method.
* 
* @note This is an atomic version of the following:
* 这个函数的实现如下:
*  \code 
*  IMP imp1 = method_getImplementation(m1);
*  IMP imp2 = method_getImplementation(m2);
*  method_setImplementation(m1, imp2);
*  method_setImplementation(m2, imp1);
*  \endcode
*/
void method_exchangeImplementations(Method m1, Method m2);

这个方法的注释官方已经给出,我们只要关注他的参数以及返回值(由于返回值为void,所以为此没有多余的解释,主要解释两个参数).

Method是OC语言中的一个结构体,子啊runtime.h头文件中有定义.在这个函数中,Method顾名思义就是要交换的方法.我们可以通过下面这个函数来获取一个类的Method.

Method class_getInstanceMethod(Class cls, SEL name);

现在这两个参数是我们平时看的见的参数,综上所述,我们只要将两组要交换的方法SEL和该方法所在的Class传入进去即可实现方法交换.

由此最终代码会变成

Method m1 = class_getInstanceMethod([M1 class], @selector(method1name));
Method m2 = class_getInstanceMethod([M2 class], @selector(method2name));
method_exchangeImplementations(m1, m2);

如果你不知道方法交换的最终效果,现在我们用一个简单的例子来说明这个问题.
这是两个类的文件,每个类都有自己的方法以及对应的实现部分
(这里的实现部分比较单纯,只是输出一个方法名用作标记).

@interface classOne : NSObject
@end@implementation classOne()
- (void)methodOne {
NSLog(@"one");
}
@end

@interface classTwo : NSObject
@end@implementation classTwo()
- (void)methodTwo {
NSLog(@"two");
}
@end

按常理来说,如果我们调用[[classOne new]methodOne]则会输出one.

同理如果调用[[classTwo new]nethodTwo]则会输出two.

但是如果我们在某一时刻执行了一次下面的代码

Method method1 = class_getInstanceMethod([classTwo class], @selector(methodTwo));
Method method2 = class_getInstanceMethod([classOne class], @selector(methodOne));
method_exchangeImplementations(method1, method2);

在此之后(知道程序结束前),我们运行[[classOne new] methodOne]的时候,打印的是two.

这个是runtime的黑科技，慎用。例如千万别在一个控制器里写8个通知和写goto。

这个是runtime的黑科技，慎用。例如千万别在一个控制器里写8个通知和写goto。

这个是runtime的黑科技，慎用。例如千万别在一个控制器里写8个通知和写goto。

CocoaTouch 框架是苹果公司仿造Cocoa框架专门为iOS设计的一套SDK
这套SDK没有对外公布源代码,卡法这无法获取到这些SDK的内部实现原理,也无法直接修改这套SDK.
在仅有的面向对象基础上,开发者想修改这些系统提供的类,唯一的方式就是继承

如果开发前期将一些常用的类都做了继承处理,则在开发后期如果出现大范围修改代码就会节省很多事情

比如你要将整个APP的UINavigationBar做一个统一处理(这里并非指样式统一化,而是一些新逻辑统一化),那你就要将整个APP用到的UINavigationController都做统一处理,这是一件很费劲的事情.

如果能直接修改系统自带的类就不需要统一继承了

修改系统类要做的最基本的事情就是修改这些类的方法

OC层修改闭源CocoaTouch

你可以尝试使用扩展来做,比如

我们首先使用一个简易的类来模拟苹果提供的类,假装这个类不是我们写的

@interface AppleClass : NSObject@property (nonatomic,copy)NSString *name;@end

然后我们在外面调用这个类的name的get方法和set方法

AppleClass *appleClass = [AppleClass new];appleClass.name = "我是ZQ";NSLog(@"%@",appleClass.name);

现在我们尝试着修改这个AppleClass的setName方法.由于这个类”不是我们写的”,所以我们不能再.m文件里直接修改这个累的方法.

我们可以使用扩展的方法实现

@implementation AppleClass (Modify)
-(void)setName:(NSString *)name{
NSLog(@"这是新的setName:方法");
}

所以我们可以得出一个结论

扩展可以直接修改类中的方法

但是问题来了,我们修改了方法,但是原有的方法功能被我们直接覆盖了.那我们如何保证原有类的方法依旧还在并且还是可以调用呢?

在继承中,重写一个类的方法的时候我们可以使用super关键字来调用父类的原方法,在这里可以尝试一下.

- (void)setName:(NSString *)name {NSLog(@"这是新的 setName: 方法");[super setName:name];//Xcode在这里报错了
}

这里的super是NSObject,他没有setName方法
显而易见,实现这个方法是AppleClass而不是NSObject,所以在AppleClass中调用他自己的方法应该使用self而不是super但是当写成self就变成了死循环

所以我们无法保留原有类的方法实现,因为我们直接覆盖了

最终结论:
1.扩展可以直接修改原有类的方法,其修改方式是直接覆盖同名方法的实现.
2.分类覆盖方法后无法保留原有方法的实现.
3.如果想让方法原有的功能依旧存在,就不能使用分类来修改类.

如果既要保留原有方法的功能,又想在原有方法里添加我自己的方法怎么办?
在这种情形下,我们可以尝试使用上面的方法交换来达到目的.

(????上面的东西不是可以用继承来做吗? 答:因为我们要做的是拿过来就能给别人用的东西 继承需要开始就写好)

Runtime层修改闭源CocoaTouch

归纳情况

在继承中,如果我们重写父类的方法,一般会使用super来调用一次父类的方法.最常见的是重写UIViewController:

@interface MyViewController : UIViewController
@end

@implement MyViewController
-(void)viewDidLoad{[super viewDidLoad];NSLog(@"viewDidLoad 调用完毕");
}

一般这种情况我们灰白调用super的方法写在整个方法的开头,就如上面一样,但是我们也可以像下面这样,先调用自己的方法,再调用父类的方法.