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方法（道理同category）

也就是说：

• 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方法