你用分类都做了哪些事 -作用？
1.声明私有方法 - 把分类的头文件放到对应数组类的.m中,就满足了私有方法的一个声明和使用,又对外不暴露。
2.分解体积庞大的类文件。
3.把Framework的私有方法公开。
分类的特点：（更好的回答分类和扩展的区别在哪里）
1.在运行时决议
- 在编写完分类文件之后,并没有把分类中添加的内容附加到宿主类中。
- 也就说宿主中还没有分类中的方法，而是在运行时通过runtime把分类内容真实的添加到对应的宿主类上。
2.可以为系统类添加分类（关于UIView的一些获取坐标的分类方法，实际上是我们在工程中植入了对应UI系统文件的一个分类，而不能给系统类添加扩展）。
分类中都可以添加哪些内容？
1.实例方法
2.类方法
3.协议
4.实例属性(实例属性只声明了对应的get和set方法,但没有在分类中添加上相应的实例变量)。
5.想要添加实例变量，可以通过关联对象来为分类添加实例变量。
分类结构体
加载调用栈
备注：
- _objc_init：runtime初始化方法。
- images：指的是镜像。
源码分析
这里以添加实例方法举例：
从remethodizeClass开始入手分析：
1.我们只分析分类当中实例方法添加的逻辑，因此在这里我们假设 isMeta = NO。
2.生成一个新的二维数组，用来存放分类中的方法。
3.遍历分类数组，采用倒叙遍历。
4.获取宿主类当中的rw数据，其中包含宿主类的方法列表信息。
5.将分类方法拼接到rw的methods上--->。
6.具体如何拼接 rw->methods.attachLists(mlists, mcount)-->attachLists方法详解。
static void remethodizeClass(Class cls)
{
category_list *cats;
bool isMeta;
runtimeLock.assertWriting();
/*
分类可以添加实例方法、类方法、属性、协议等等
我们只分析分类当中实例方法添加的逻辑，
因此在这里我们假设添加的是实例方法， isMeta = NO
*/
/*
<--------------1.isMeta = NO---------------->
*/
isMeta = cls->isMetaClass();//判断当前类是否为元类对象，这取决于我们添加的方法是实例方法还是类方法
//从对应的类（cls）当中获取还没有拼接整合的所有分类 cats是获取分类的列表
if ((cats = unattachedCategoriesForClass(cls, false))) {
if (PrintConnecting) {
_objc_inform("CLASS: attaching categories to class '%s' %s",
cls->nameForLogging(), isMeta ? "(meta)" : "");
}
//将分类cats拼接到cls上面
attachCategories(cls, cats, true );
free(cats);
}
}
2.3.4.5.6 将分类cats拼接到cls上面-->attachCategories方法详解：
通过rw->methods.attachLists(mlists, mcount)这句话，分类的方法才真正添加到了宿主类上面。所以，分类是在运行时决议。
static void attachCategories(Class cls, category_list *cats, bool flush_caches)
{
if (!cats) return; //分类的判空操作
if (PrintReplacedMethods) printReplacements(cls, cats);//打印的内容或者debug调试的东西，可以忽略
/*
分类可以添加实例方法、类方法、属性、协议等等
我们只分析分类当中实例方法添加的逻辑，
因此在这里我们假设添加的是实例方法， isMeta = NO
*/
bool isMeta = cls->isMetaClass();//又进行了一次当前分类当中，添加的方法是实例方法还是类方法。或者说是为类添加分类，还是为元类添加分类。
//声明了三个局部变量，对应的都是二维数组， 我们主要分析关于方法添加的一个逻辑
/*二维数组
[[method_t,method_t,...],[method_t],[method_t,method_t,method_t]...]
*/
/*
<--------------2.生成一个新的二维数组，用来存放分类中的方法---------------->
*/
method_list_t **mlists = (method_list_t **)
malloc(cats->count * sizeof(*mlists));//方法列表
property_list_t **proplists = (property_list_t **)
malloc(cats->count * sizeof(*proplists));//属性列表
protocol_list_t **protolists = (protocol_list_t **)
malloc(cats->count * sizeof(*protolists));//协议列表
int mcount = 0; //方法参数
int propcount = 0;//属性参数
int protocount = 0;//协议参数
int i = cats->count;//宿主类分类的总数，不是方法的总数
bool fromBundle = NO;
while (i--) {
/*
<--------------3.遍历分类数组，采用倒叙遍历---------------->
*/
//这里是倒序遍历，最先访问最后编译的分类，也就是说attachCategories函数中传递过来的分类列表的参数，category_list *cats里面最后一个元素，是最后参加编译的。 最后编译的同名方法会生效，前面的会被覆盖掉。
//获取一个分类
auto& entry = cats->list[i];
//获取该分类的方法列表
method_list_t *mlist = entry.cat->methodsForMeta(isMeta);
if (mlist) {
//最后编译的分类最先添加到分类数组中
mlists[mcount++] = mlist;
fromBundle |= entry.hi->isBundle();
}
//属性列表添加规则 同方法添加规则
property_list_t *proplist = entry.cat->propertiesForMeta(isMeta);
if (proplist) {
proplists[propcount++] = proplist;
}
//协议列表添加规则 同方法添加规则
protocol_list_t *protolist = entry.cat->protocols;
if (protolist) {
protolists[protocount++] = protolist;
}
}
/*
<--------------4.获取宿主类当中的rw数据，其中包含宿主类的方法列表信息---------------->
*/
//根据当前类，获取它的读写信息
auto rw = cls->data();
//主要是针对 分类中实现了一些内存管理相关方法情况下的 一些特殊处理（覆盖掉系统的一些内存管理方法）
prepareMethodLists(cls, mlists, mcount, NO, fromBundle);
/*
<--------------5.将分类方法拼接到rw的methods上---------------->
*/
/*
rw代表类
methods代表类的方法列表
attachLists 方法的含义是 将含有mcount个元素的mlists拼接到rw的methods上面
分类添加的关键位置：就是将我们刚才处理过的一个二维数组的分类数据mlists，拼接到对应的宿主类的方法列表上面。
rw类的结构当中有一个方法列表的成员methods，然后通过调用methods的attachLists函数，来把含有mcount个元素的二维数组mlists拼接到宿主类rw的对应方法methods上面。
通过rw->methods.attachLists(mlists, mcount)这句话，分类的方法才真正添加到了宿主类上面。所以，分类是在运行时决议
*/
rw->methods.attachLists(mlists, mcount);
free(mlists);
if (flush_caches && mcount > 0) flushCaches(cls);
rw->properties.attachLists(proplists, propcount);
free(proplists);
rw->protocols.attachLists(protolists, protocount);
free(protolists);
}
6.1 rw->methods.attachLists(mlists, mcount);方法解析:
[ A ---> [addedLists中的第一个元素],B ---> [addedLists中的第二个元素], C ---> [addedLists中的第三个元素],[原有的第一个元素], [原有的第二个元素] ]
经过调用memmove-->把原有列表中的元素移动到数组后面的位置，把前面留出来addedCount个新添加的位置，
memcpy（内容拷贝）： 这也是分类方法会“覆盖”宿主类的方法的原因，如果分类的方法有和宿主类方法同名的现象，分类的方法会被优先实现。
/*
addedLists 传递过来的二维数组 （准备拼接的分类列表）
[[method_t,method_t,...],[method_t],[method_t,method_t,method_t]...]
------------------------ -------- ------------------------------
分类A中的方法列表（A） B C
addedCount = 3 二维数组列表的个数
*/
void attachLists(List* const * addedLists, uint32_t addedCount) {
if (addedCount == 0) return;//判空操作
if (hasArray()) { //有数组的情况下
// many lists -> many lists
//列表中原有元素总数 oldCount = 2
uint32_t oldCount = array()->count;
//拼接之后的元素总数
uint32_t newCount = oldCount + addedCount;
//根据新总数重新分配内存
setArray((array_t *)realloc(array(), array_t::byteSize(newCount)));
//重新设置元素总数
array()->count = newCount;
/*
内存移动
调用memmove-->把原有列表中的元素移动到数组后面的位置，把前面留出来addedCount个新添加的位置
[[],[],[],[原有的第一个元素]，[原有的第二个元素]]
*/
memmove(array()->lists + addedCount, array()->lists,
oldCount * sizeof(array()->lists[0]));
/*
内存拷贝
[
A ---> [addedLists中的第一个元素],
B ---> [addedLists中的第二个元素],
C ---> [addedLists中的第三个元素],
[原有的第一个元素],
[原有的第二个元素]
这也是分类方法会“覆盖”宿主类的方法的原因，如果分类的方法有和宿主类方法同名的现象，分类的方法会被优先实现。
]
*/
memcpy(array()->lists, addedLists,
addedCount * sizeof(array()->lists[0]));
}
else if (!list && addedCount == 1) {
// 0 lists -> 1 list
list = addedLists[0];
}
else {
// 1 list -> many lists
List* oldList = list;
uint32_t oldCount = oldList ? 1 : 0;
uint32_t newCount = oldCount + addedCount;
setArray((array_t *)malloc(array_t::byteSize(newCount)));
array()->count = newCount;
if (oldList) array()->lists[addedCount] = oldList;
memcpy(array()->lists, addedLists,
addedCount * sizeof(array()->lists[0]));
}
}
下面我们图示经过memmove和memcpy方法过后的内存变化。
经过memmove方法之后，内存变化为
// array()->lists 原来方法、属性、协议列表数组
// addedCount 分类数组长度
// oldCount * sizeof(array()->lists[0]) 原来数组占据的空间
memmove(array()->lists + addedCount, array()->lists,
oldCount * sizeof(array()->lists[0]));
经过memmove方法之后，我们发现，虽然本类的方法，属性，协议列表会分别后移，但是本类的对应数组的指针依然指向原始位置。
memcpy方法之后，内存变化
// array()->lists 原来方法、属性、协议列表数组
// addedLists 分类方法、属性、协议列表数组
// addedCount * sizeof(array()->lists[0]) 原来数组占据的空间
memcpy(array()->lists, addedLists,
addedCount * sizeof(array()->lists[0]));
我们发现原来指针并没有改变，至始至终指向开头的位置。并且经过memmove和memcpy方法之后，分类的方法，属性，协议列表被放在了类对象中原本存储的方法，属性，协议列表前面。
那么为什么要将分类方法的列表追加到本来的对象方法前面呢，这样做的目的是为了保证分类方法优先调用，我们知道当分类重写本类的方法时，会覆盖本类的方法。
其实经过上面的分析我们知道本质上并不是覆盖，而是优先调用。本类的方法依然在内存中的。
重要总结
1.分类实现原理由运行时决议,不同分类中含有同名分类方法,谁最终生效,取决于谁最后参与编译。
2.假如分类中添加的方法恰好是宿主类中的同名方法,分类方法会"覆盖"同名的宿主类方法。
(消息传递过程中会优先查找数组靠前的元素,若找到了就会调用,但宿主类的同名方法仍然存在)。
- 分类添加的同名方法可以"覆盖"原宿主类方法。
- 效果上是覆盖的，实际上呢宿主类的同名方法仍然存在，只是memmove移动到了后面。
- 在我们消息发送过程中,是根据选择器名称来查找的,一旦查找到对应的实现就会返回
- 由于分类方法位于数组靠前的位置,若分类和宿主类方法重名,会先查找到分类的方法
-
最后编译的分类同名方法才会最终生效,其他分类都会被覆盖掉。
- 若我们添加两个分类,两个分类中都有同名方法,哪个会生效,取决于分类的编译顺序
- 因为是倒序编译,最后编译的分类同名方法才会最终生效,其他都会被覆盖掉
-
名字相同的分类会引起编译报错。
- 因为在生成具体分类的时候,经过runtime在编译过程中，会把我们添加的分类名字以下划线方式拼接到宿主类上。
- 或者更复杂的命名规则，总之名字相同,就会类似于我们定义了两个同名变量,会引起编译报错。
+load方法
+load方法会在runtime加载类、分类时调用，每个类、分类的+load，在程序运行过程中只调用一次。
调用顺序
1、先调用类的+load：按照编译先后顺序调用（先编译，先调用），调用子类的+load之前会先调用父类的+load。
2、再调用分类的+load：按照编译先后顺序调用（先编译，先调用）
+initialize方法
+initialize方法会在类第一次接收到消息时调用。
调用顺序
先调用父类的+initialize，再调用子类的+initialize，先初始化父类，再初始化子类，每个类只会初始化1次。
+initialize和+load的很大区别是：+load方法是根据方法地址直接调用，并不是经过objc_msgSend函数调用，而+initialize是通过objc_msgSend进行调用的，所以有以下特点：
1、如果子类没有实现+initialize，会调用父类的+initialize（所以父类的+initialize可能会被调用多次）。
2、如果分类实现了+initialize，就覆盖类本身的+initialize调用。
如何实现给分类添加成员变量
默认情况下，因为分类底层结构的限制，不能添加成员变量到分类中。但可以通过关联对象来间接实现(重写成员变量的set和get方法)。
Objc_AssociationPolicy关联对象提供了以下API：
添加关联对象
void objc_setAssociatedObject(id object, const void * key,id value, objc_AssociationPolicy policy)
获得关联对象
id objc_getAssociatedObject(id object, const void * key)
移除所有的关联对象
void objc_removeAssociatedObjects(id object)
