1、load方法
load方法会在runtime加载类、分类时调用（在main函数开始之前），与这个类是否用到无关。
类、分类中的load方法
从苹果源码网站下载下来runtime的objc4-723源码。
obje-runtime-new.mm文件中有个load_images方法指明加载文件到内存中，其中call_load_methods这句代码便对应load方法的处理：
- 这里可以看出是先调用所有类文件里的load方法，再调用所有Category文件里的load方法
void call_load_methods(void)
{
static bool loading = NO;
bool more_categories;
loadMethodLock.assertLocked();
// Re-entrant calls do nothing; the outermost call will finish the job.
if (loading) return;
loading = YES;
void *pool = objc_autoreleasePoolPush();
do {
// 1. Repeatedly call class +loads until there aren't any more
while (loadable_classes_used > 0) {
//首先调用类的load方法
call_class_loads();
}
// 2. Call category +loads ONCE
//然后调用分类的load方法
more_categories = call_category_loads();
// 3. Run more +loads if there are classes OR more untried categories
} while (loadable_classes_used > 0 || more_categories);
objc_autoreleasePoolPop(pool);
loading = NO;
}
再看call_class_loads方法里的逻辑：
- 这里可以看出是找到每个class中load方法存放的内存地址，然后通过内存地址来调用load方法的
static void call_class_loads(void)
{
int i;
// Detach current loadable list.
struct loadable_class *classes = loadable_classes;
int used = loadable_classes_used;
loadable_classes = nil;
loadable_classes_allocated = 0;
loadable_classes_used = 0;
// Call all +loads for the detached list.
//循环处理所有的类文件里的load方法
for (i = 0; i < used; i++) {
Class cls = classes[i].cls;
//这个load_method是个指针类型，里面存放的是load方法的内存地址
load_method_t load_method = (load_method_t)classes[i].method;
if (!cls) continue;
if (PrintLoading) {
_objc_inform("LOAD: +[%s load]\n", cls->nameForLogging());
}
//此处直接通过load方法的内存地址来调用load方法
(*load_method)(cls, SEL_load);
}
// Destroy the detached list.
if (classes) free(classes);
}
再看call_category_loads方法里的逻辑：
- 同样，调用Category中的load方法也是直接通过内存地址的方法调用，此处便不再作注解
static bool call_category_loads(void)
{
int i, shift;
bool new_categories_added = NO;
// Detach current loadable list.
struct loadable_category *cats = loadable_categories;
int used = loadable_categories_used;
int allocated = loadable_categories_allocated;
loadable_categories = nil;
loadable_categories_allocated = 0;
loadable_categories_used = 0;
// Call all +loads for the detached list.
for (i = 0; i < used; i++) {
Category cat = cats[i].cat;
load_method_t load_method = (load_method_t)cats[i].method;
Class cls;
if (!cat) continue;
cls = _category_getClass(cat);
if (cls && cls->isLoadable()) {
if (PrintLoading) {
_objc_inform("LOAD: +[%s(%s) load]\n",
cls->nameForLogging(),
_category_getName(cat));
}
(*load_method)(cls, SEL_load);
cats[i].cat = nil;
}
}
// Compact detached list (order-preserving)
shift = 0;
for (i = 0; i < used; i++) {
if (cats[i].cat) {
cats[i-shift] = cats[i];
} else {
shift++;
}
}
used -= shift;
// Copy any new +load candidates from the new list to the detached list.
new_categories_added = (loadable_categories_used > 0);
for (i = 0; i < loadable_categories_used; i++) {
if (used == allocated) {
allocated = allocated*2 + 16;
cats = (struct loadable_category *)
realloc(cats, allocated *
sizeof(struct loadable_category));
}
cats[used++] = loadable_categories[i];
}
// Destroy the new list.
if (loadable_categories) free(loadable_categories);
// Reattach the (now augmented) detached list.
// But if there's nothing left to load, destroy the list.
if (used) {
loadable_categories = cats;
loadable_categories_used = used;
loadable_categories_allocated = allocated;
} else {
if (cats) free(cats);
loadable_categories = nil;
loadable_categories_used = 0;
loadable_categories_allocated = 0;
}
if (PrintLoading) {
if (loadable_categories_used != 0) {
_objc_inform("LOAD: %d categories still waiting for +load\n",
loadable_categories_used);
}
}
return new_categories_added;
}
之前，我们在看Category的时候，当类文件和分类文件中写了同名方法时，我们调用方法后，分析得出只调用了分类中的方法（多个分类只调用一个）。这是因为调用方法时利用的是objc_sendMsg的机制其调用函数的。
现在明显可以看出load方法和其他方法的不同，调用load方法本就在runtime加载时，是通过找到load方法存储的内存地址调用的，所以每个class的load方法都会被调用。
父类、子类中的load方法
还是来看一下源码：
obje-runtime-new.mm文件中有个prepare_load_methods方法，在这里面schedule_class_load这句代码对应的是处理load方法时对class文件的加载顺序处理：
- 可以看出在处理自己的之前，会先处理自己的父类
static void schedule_class_load(Class cls)
{
if (!cls) return;
assert(cls->isRealized()); // _read_images should realize
if (cls->data()->flags & RW_LOADED) return;
// Ensure superclass-first ordering
//在处理自己之前, 递归调用,传入的参数是自己的父类
schedule_class_load(cls->superclass);
//将cls(类)添加到loadable_classes数组中（加入的新class在数组后面）
add_class_to_loadable_list(cls);
cls->setInfo(RW_LOADED);
}
load方法的总结
load方法会在runtime加载类、分类时调用
每个类、分类的+load，在程序运行过程中只调用一次
-
调用顺序
先调用类的+load（先编译，先调用）
调用子类的+load之前会先调用父类的+load
再调用分类的+load（先编译，先调用）
也就是说：
1.当父类和子类都实现load函数时,父类的load方法执行顺序要优先于子类
2.当子类未实现load方法时,不会调用父类load方法
3.类中的load方法执行顺序要优先于类别(Category)
4.当有多个类别(Category)都实现了load方法,这几个load方法都会执行,但执行顺序不确定(取决于分类文件的编译顺序)
2、initialize
initialize方法是在类第一次接受到消息时调用，必须是类使用到了才会被调用。它是通过发送objc_sendMsg的机制的方式去调用的。
类、分类中的initialize方法
在学习category的时候，我们已经知道如果是使用objc_sendMsg的机制去调用方法的话，都是会先调用分类的同名方法，所以如果分类实现了+initialize方法，就覆盖类本身的+initialize方法。
父类、子类中的initialize方法
如果子类没有实现+initialize，会调用父类的+initialize（所以父类的+initialize可能会被调用多次）。
因为源码太过分散，我就不贴源码了，采用伪代码的方法简单表示一下：
//以上说明是建立在class本身或者class的分类实现了initialize方法的基础上。
//如果class本身没有实现initialize方法，且其分类中也没有实现initialize方法，
//那么就会沿着其父类向上寻找，一直找到实现了initialize方法的父类，调用该父类的initialize方法
if(class本身没有被初始化){
if(class有父类 && 父类没有被初始化){
if(class的父类有分类 && 分类中实现了initialize方法){
调用class的父类的分类中的initialize方法
}else{
调用class的父类中的initialize方法
}
}else{
if(class有分类 && 分类中实现了initialize方法){
调用class的分类中的initialize方法
}else{
调用class本身的initialize方法
}
}
}
initialize方法的总结
+initialize方法会在类第一次接收到消息时调用
-
调用顺序
先调用父类的+initialize，再调用子类的+initialize(先初始化父类，再初始化子类，每个类只会初始化1次)
类和分类中都含有+initialize时，调用分类中的+initialize方法
也就是说：
1.父类的initialize方法会比子类先执行
2.当子类未实现initialize方法时,会调用父类initialize方法,子类实现initialize方法时,会覆盖父类initialize方法。
3.当有多个Category都实现了initialize方法,会覆盖类中的方法,只执行最后一个(取决于分类文件的编译顺序)
3、总结
<1>Category中有load方法吗？load方法是什么时候调用的？load 方法能继承吗？
有load方法
load方法在runtime加载类、分类的时候调用
load方法不遵守继承规则，一般情况下不会主动去调用load方法，都是让系统自动调用
<2>load、initialize方法的区别什么？
-
调用方式
load是根据函数地址直接调用的
initizlize是通过objc_sendMsg调用 -
调用时刻
load是runtime加载类、分类的时候调用（只会调用一次）
initizlize是类第一次接收到消息的时候调用，每一个类只会initizlize一次（父类的initizlize方法可能会被调用多次，但是这是因为子类没有实现initizlize方法，objc_sendMsg方法通过isa找到父类的同名方法）
<3>load、initialize方法在category中的调用的顺序？以及出现继承时他们之间的调用过程？
-
load
1>先调用类的load
a)先编译的类优先调用load方法
b)调用子类的load方法之前，会先调用父类的load方法
2>再去调用分类的load
a)先编译的分类，优先调用load -
initizlize
1>先初始化父类
a)有分类中实现了initizlize，调用先编译的分类的initizlize方法
2>再初始化子类(子类如果没有实现initizlize，会调用到父类的initizlize方法)
a)有分类中实现了initizlize，调用先编译的分类的initizlize方法
