面试题
load、initialize方法的区别是什么？他们在Category中的调用顺序？
load调用原理
1.+load方法会在runtime加载类、分类的时候调用，系统会主动调用
2.每个类、分类的+load，在程序运行中只会调用一次
3.调用顺序
1>先调用父类的+load
a)按照编译顺序先后调用（先编译，先调用）
b)调用子类的+load之前会先调用父类的+load
2>再调用分类的+load
a)按照编译先后顺序调用（先编译，先调用）
首先给出结论，接下来通过代码验证和源码分析。
load代码验证
先来一段代码，分析load方法的调用情况。
创建Person类继承至NSObject，Person+Test1分类，Person+Test2分类；再创建Student类继承至Person，Student+Test1分类，Person+Test2分类；最后创建Dog也是继承至NSObject，与Person类对照。
@interface Person : NSObject
@end
@implementation Person
+ (void)load{
NSLog(@"Person +load");
}
@end
@interface Person (Test1)
@end
@implementation Person (Test1)
+ (void)load{
NSLog(@"Person (Test1) +load");
}
@end
@interface Person (Test2)
@end
@implementation Person (Test2)
+ (void)load{
NSLog(@"Person (Test2) +load");
}
@end
@interface Student : Person
@end
@implementation Student
+ (void)load{
NSLog(@"Student +load");
}
@end
@interface Student (Test1)
@end
@implementation Student (Test1)
+ (void)load{
NSLog(@"Student (Test1) +load");
}
@end
@interface Student (Test2)
@end
@implementation Student (Test2)
+ (void)load{
NSLog(@"Student (Test1) +load");
}
@end
@interface Dog : NSObject
@end
+ (void)load{
NSLog(@"Dog +load");
}
运行上面代码，在外部不调用Person，Student，Dog中的方法，每个.m文件中+load都调用了一遍。运行结果如下图。
代码主要验证下load方法的调用顺序
1>只在Person.m、Person+Test1.m、Person+Test2.m中实现+load方法，其他.m文件中的+load方法都屏蔽掉，观察调用类和分类的+load方法顺序。
运行结果显示先调用类的+load，再调用分类的+load。
2>只在Person.m、Student.m、Dog.m中实现+load方法，其他.m文件中的+load方法都屏蔽掉，观察没有分类时，调用类的+load方法顺序。
上图中可以看出文件的编译顺序是Dog.m->Student.m->Person.m，其中Student继承至Person。而运行结果Dog中+load调用先于Person，说明调用类中+load方法是按照编译顺序调用，先编译先调用。Student的编译顺序先于Person，为什么调用顺序反而在后面呢？这是因为Student继承至Person，调用子类的+load前会先调用父类的+load。
3>只在Persson+Test1.m、Persson+Test2.m、Student+Test1.m、Student +Test2.m中实现+load方法，其他.m文件中的load方法都屏蔽掉，观察调用分类的+load方法顺序。
上图中可以看出分类文件的编译顺序是Person+Test1.m->Person+Test2.m->Student+Test1.m-> Student +Test2.m，而运行的结果和编译顺序是一样的。说明调用分类的+load是按照编译顺序，先编译先调用。
从上面的三步分别验证，再看第一次运行的结果截图，这个顺序是完全符合的。这样也就验证了最开头的+load调用顺序的总结。并且在外部完全不调用+load方法的时候，+load方法依然会被调用，其实就是runtime在加载类和分类的时候就主动调用了+load方法，同时结合以上运行结果，程序运行过程中只会调用一次+load方法。
load源码分析
为什么调用+load会出现以上的规律呢?我们通过runtime源码来一探究竟。
先贴一个源码解析的流程图
首先来到runtime的初始化方法，在objc-os.mm中搜索_objc_init。
再来到load_images，这个函数中主动调用了load方法。
我们先看看系统是怎么去查找load方法的，进入到prepare_load_methods函数。
这里发现类和分类都是分别按照编译的顺序取出来，分类取出来之后就直接按编译顺序放到了一个loadable_list中，而类取出来中又调用了
schedule_class_load函数，在这个函数中其实是给类和父类调用顺序排序。
上图可以看出，每个类中的+load方法都只会调用一次，递归的将类和父类都添加到loadable_list中，并且父类会排在前面。
接下来再看看add_class_to_loadable_list和add_category_to_loadable_list中具体做了什么
查找load方法的逻辑总结（prepare_load_methods）
类和其对应的load方法，赋值给loadable_class，最后统一添加到loadable_classes中
顺序是按文件编译的顺序，但是父类会强制排在子类前面，并且每个类只会被添加一次分类和其对应的load方法，赋值给loadable_category,最后统一添加到loadable_categories中
顺序就是按编译的顺序
接着在来看call_load_methods，调用load方法逻辑。
这里就可以发现在调用load方法时，是优先调用类的+load方法，再调用分类的+load方法。
call_class_loads和call_category_loads中具体如何执行的，我们继续向下看。
在类和分类中都是直接找到+load方法然后调用。所以不存在先调用调用子类的+load，就不调用父类的+load，也不存在先调用分类的+load，就不调用原本类中的+load。类和分类中的+load都会在runtime初始化时主动被系统调用，并且在运行过程中只调用一次。
initialize调用原理
1.+initialize方法会在类第一次接收到消息时调用
2.调用顺序
a)先调用父类的+initialize，再调用子类的+initialize（先初始化父类，再初始化子类，每个类只会初始化一次）
+initialize是通过objc_msgSend进行调用的，所以有以下特点
a)如果子类没有实现+initialize，会调用父类的+initialize（所以父类的+initialize可能会被调用多次）
b)如果分类实现了+initialize，就会覆盖类本身的+initialize调用
接下来通过代码验证和源码分析。
代码验证
@interface Person : NSObject
@end
@implementation Person
+ (void)initialize{
NSLog(@"Person +initialize");
}
@end
@interface Person (Test1)
@end
@implementation Person (Test1)
+ (void)initialize{
NSLog(@"Person (Test1) +initialize");
}
@end
@interface Person (Test2)
@end
@implementation Person (Test2)
+ (void)initialize{
NSLog(@"Person (Test2) +initialize");
}
@end
@interface Student : Person
@end
@implementation Student
+ (void)initialize{
NSLog(@"Student +initialize");
}
@end
@interface Student (Test1)
@end
@implementation Student (Test1)
+ (void)initialize{
NSLog(@"Student (Test1) +initialize");
}
@end
@interface Student (Test2)
@end
@implementation Student (Test2)
+ (void)initialize{
NSLog(@"Student (Test1) +initialize");
}
@end
@interface Dog : NSObject
@end
@implementation Dog
+ (void)initialize{
NSLog(@"Dog +initialize");
}
@end
1>以上代码，在外部不调用所有类和分类，运行结果是没有调用任何一个+initialize方法。
2.0>只在Person.m、Student.m、Dog.m中实现+initialize方法，其他.m文件中的+initialize方法都屏蔽掉，在外部调用[Person alloc];[Student alloc]; [Dog alloc];，分别给Person类发送了alloc，给Student类发送了alloc，给Dog类发送了alloc消息，观察运行结果。
2.1>在外部调用[Person alloc];[Student alloc]; [Dog alloc];[Person alloc];[Student alloc]; [Dog alloc]，多次分别给Person类发送了alloc，给Student类发送了alloc，给Dog类发送了alloc消息，与2.0作为对照，观察运行结果。
2.2>在外部调用[Student alloc];[Person alloc];[Dog alloc];，调换Student和Person发送alloc消息的顺序，同样与2.0作为对照，观察运行结果。
#import <Foundation/Foundation.h>
#import "Person.h"
#import "Student.h"
#import "Dog.h"
int main(int argc, const char * argv[]) {
@autoreleasepool {
//2.0
[Person alloc];
[Student alloc];
[Dog alloc];
//2.1
[Person alloc];
[Student alloc];
[Dog alloc];
[Person alloc];
[Student alloc];
[Dog alloc];
[Person alloc];
[Student alloc];
[Dog alloc];
//2.2
[Student alloc];
[Person alloc];
[Dog alloc];
}
return 0;
}
运行结果
2019-07-11 20:58:54.031975+0800 Category-initialize[12113:4824617] Person +initialize
2019-07-11 20:58:54.032140+0800 Category-initialize[12113:4824617] Student +initialize
2019-07-11 20:58:54.032152+0800 Category-initialize[12113:4824617] Dog +initialize
以上2.0，2.1，2.2三种运行结果都是一致。
通过以上四种情况的结果，说明+initialize方法会在类第一次接收到消息的时候调用。并且会先调用父类的+initialize，再调用子类的+initialize。
3>只在Person.m中实现+initialize方法，其他所有.m中的+initialize方法都屏蔽，包括Person的子类Student。在外部调用[Student alloc];，观察运行结果。
2019-07-11 21:28:06.730804+0800 Category-initialize[12336:4875791] Person +initialize
2019-07-11 21:28:06.730959+0800 Category-initialize[12336:4875791] Person +initialize
结果是调用了两次父类Person中的+int initialize，进一步说明先调用父类的+initialize，再调用子类的+initialize，同时子类没有实现+initialize，会调用父类的+initialize。
4>每个.m中都实现+initialize，在外部调用[Person alloc];[Student alloc]; [Dog alloc];，观察运行结果。
结果调用了Person+Test1和Student+Test1中的+initialize方法。也说明了如果分类实现了+initialize，就覆盖类本身的+initialize调用。而多个分类中的调用顺序是，后编译先调用，都是符合的。
initialize源码分析
为什么调用+initialize会出现以上的规律呢?我们也通过runtime源码来一探究竟。
先贴一个源码解析的流程图
因为+initialize是在类第一次接收到消息时调用，那底层一定是调用了objc_msgSend，相当于objc_msgSend(cls,@selector(@"alloc"))给类cls发送了一条alloc消息。 在runtime源码中搜索objc_msgSend，结果在objc-msg-arm64.s中发现其是通过汇编实现的。无法看懂汇编的情况下我们只能先行分析，发送消息，通过isa找到类，然后要经历查找方法和调用方法两个步骤，而+initialize就可能是在这两个过程中调用的。
我们通过XCode断点alloc方法，然后显示汇编来查看汇编中查找方法和调用方法的流程。步骤Debug->Debug workflow->Always Show Disassembly，找到callq-msgSend并且断点，跳到断点处，control+stepinto进入到实现内部，发现最后回来到_objc_msgSend_uncached，断点并跳到此处，control+stepinto进入到实现内部，我们终于找到了一个不是汇编的函数_class_lookupMethodAndLoadCache3，在runtime源码中搜索找到该方法在objc-runtime-new.mm中，我们就来顺着这个方法看看内部的实现。
接下来进入lookUpImpOrForward函数内部。
再接着进入到_class_initialize函数内部。
最后来到callInitialize函数内部，发现+initialize就是通过objc_msgSend进行调用的。
结合底层源码，也都一一验证了关于+initialize调用原理的总结。为什么是在类第一次收到消息时调用？为什么调用子类的+initialize会先调用父类的+initialize？以及+initialize调用的两个特点，都能得到解答。
接下来进行面试题的总结。
load、initialize方法的区别是什么？他们在Category中的调用顺序？
1.调用方式
1>load是根据函数地址调用
2>initialize是通过objc_msgSend调用2.调用时刻
1>load是runtime加载类、分类的时候调用（只会调用一次）
2>initialize是类第一次接收到消息的时候调用，每一个类只会initialize一次（父类的initialize方法可能会调用多次）load、initialize调用顺序
1.load
1>先调用类的load
a)先编译的类，优先调用load
b)调用子类的load之前，会优先调用父类的load2>再调用分类的load
a)先编译的分类，优先调用load2.intialize
1>先初始化父类
2>再初始化子类（可能最终调用的是父类的initialize方法）
