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