Objective-C语言
- 分类(什么是分类?分类的实现机制、原理是怎样的?我们应该怎样为一个分类提供实例变量呢?--涉及到第2点关联对象的考察)
- 关联对象(Runtime分析和查看 分类和关联对象的实现机制、原理)
- 扩展、代理怎么使用(分类和扩展的区别在哪里?)
- KVO、KVC( KVO、KVC的实现机制、原理、包括涉及到了哪些设计思想)
- NSNotification(通知的实现机制和原理)
- 属性关键字(声明属性时,会用到一些关键字的实际问题)
分类(Category):
1.1你用分类都做了哪些事 -作用?
- 声明私有方法 - 把分类的头文件放到对应数组类的.m中,就满足了私有方法的一个声明和使用,又对外不暴露
- 分解体积庞大的类文件
- 把Framework的私有方法公开
分类的特点:(更好的回答分类和扩展的区别在哪里)
- 在运行时决议
- 在编写完分类文件之后,并没有把分类中添加的内容附加到宿主类中
- 也就说宿主中还没有分类中的方法,而是在运行时通过runtime把分类内容真实的添加到对应的宿主类上 - 可以为系统类添加分类(关于UIView的一些获取坐标的分类方法,实际上是我们在工程中植入了对应UI系统文件的一个分类,而不能给系统类添加扩展)
1.2 分类中都可以添加哪些内容?
- 实例方法
- 类方法
- 协议
- 实例属性(实例属性只声明了对应的get和set方法,但没有在分类中添加上相应的实例变量)
- 想要添加实例变量,可以通过关联对象来为分类添加实例变量
1.3 <--分类结构体-->
1.4 加载调用栈(了解)
备注:
- _objc_init:runtime初始化方法。
- images:指的是镜像。
1.5 源码分析
这里以添加实例方法举例:
从remethodizeClass开始入手分析:
- 我们只分析分类当中实例方法添加的逻辑,因此在这里我们假设 isMeta = NO
- 生成一个新的二维数组,用来存放分类中的方法
- 遍历分类数组,采用倒叙遍历
- 获取宿主类当中的rw数据,其中包含宿主类的方法列表信息
- 将分类方法拼接到rw的methods上--->
- 具体如何拼接 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]));
}
}
"重要总结"
分类实现原理由运行时决议,不同分类中含有同名分类方法,谁最终生效,取决于谁最后参与编译
假如分类中添加的方法恰好是宿主类中的同名方法,分类方法会"覆盖"同名的宿主类方法
(消息传递过程中会优先查找数组靠前的元素,若找到了就会调用,但宿主类的同名方法仍然存在)
1. 分类添加的同名方法可以"覆盖"原宿主类方法
-效果上是覆盖的,实际上呢宿主类的同名方法仍然存在,只是memmove移动到了后面。
-在我们消息发送过程中,是根据选择器名称来查找的,一旦查找到对应的实现就会返回
-由于分类方法位于数组靠前的位置,若分类和宿主类方法重名,会先查找到分类的方法
2. 最后编译的分类同名方法才会最终生效,其他分类都会被覆盖掉
-若我们添加两个分类,两个分类中都有同名方法,哪个会生效,取决于分类的编译顺序
-因为是倒序编译,最后编译的分类同名方法才会最终生效,其他都会被覆盖掉
3. 名字相同的分类会引起编译报错
-因为在生成具体分类的时候,经过runtime在编译过程中,会把我们添加的分类名字以下划线方式拼接到宿主类上
-或者更复杂的命名规则,总之名字相同,就会类似于我们定义了两个同名变量,会引起编译报错