前言
可怜身上衣正单，心忧炭贱愿天寒
----有感于各种强制解除劳动关系却仍有人为血汗工厂打工
要了解这些方法的调用顺序，首先要了解category的底层结构和加载处理过程。
category的底层结构和加载处理过程
下图是category的底层结构
加载处理过程：
通过Runtime加载某个类的所有Category数据
把所有Category的方法、属性、协议数据，合并到一个大数组中
后面参与编译的Category数据，会在数组的前面
将合并后的分类数据（方法、属性、协议），插入到类原来数据的前面
然后category的普通方法是走的msg_Send方法，即通过isa指针和superclass指针查找方法列表，找到就直接执行，不再继续找。
普通方法的调用顺序
我们先说结论：当父类和子类和子类的类别同时实现某个方法test，当调用test方法时，他会走msg_send()消息转发机制，只调用最先找到的那个方法，查找顺序为分类->类->父类，如果两个分类实现同一个方法，那么先执行后编译的那个，也就是编译文件列表里下面那个；下面我们证明一下。
我们首先创建一个RMAnimal 类，在里边声明一个+（void）test方法，然后创建RMPerson类继承自RMAnimal，再创建RMPerson+weight，RMPerson+Height分类，同时实现+（void）test
@interface RMAnimal : NSObject
+ (void)test;
@end
@implementation RMAnimal
+ (void)test {
NSLog(@"test ============RMAnimal");
}
@end
@implementation RMPerson
+ (void)test {
NSLog(@"test ============RMPerson");
}
@end
@implementation RMPerson (weight)
+ (void)test {
NSLog(@"test ============RMPerson (weight)");
}
@end
@implementation RMPerson (Height)
+ (void)test {
NSLog(@"test ============RMPerson (Height)");
}
@end
执行代码 [RMPerson test];
[RMPerson test];
最终打印结果是
test ============RMPerson (weight)
此时的编译顺序如下：
可以看到两个类别的编译顺序为RMPerson+Height，RMPerson+weight，只是执行了RMPerson+weight的test方法，这说明类别里的方法后编译的先被找到。那么为什么呢，因为在底层category最后将类别的方法，属性和协议与原来的类结合到一起的时候（执行attachCategories方法如下），取数组元素是执行一个while循环 倒序取的，所以在后边的方法，会被放到前边。
attachCategories(Class cls, category_list *cats, bool flush_caches)
{
if (!cats) return;
if (PrintReplacedMethods) printReplacements(cls, cats);
bool isMeta = cls->isMetaClass();
// fixme rearrange to remove these intermediate allocations
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));
// Count backwards through cats to get newest categories first
int mcount = 0;
int propcount = 0;
int protocount = 0;
int i = cats->count;
bool fromBundle = NO;
while (i--) {
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, entry.hi);
if (proplist) {
proplists[propcount++] = proplist;
}
protocol_list_t *protolist = entry.cat->protocols;
if (protolist) {
protolists[protocount++] = protolist;
}
}
auto rw = cls->data();
prepareMethodLists(cls, mlists, mcount, NO, fromBundle);
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);
}
+ (void)load方法的执行顺序
1、如果所有的父类和子类以及父类的类别和子类类别都实现了load方法，所有的load方法都会被执行，且执行顺序为，父类->子类->所有的类别，当子类里有平级关系（比如class Man 和class Woman均继承自于Person），则按照Compile Sources 出现的顺序执行（上边的先执行），所有的类别有不分父类类别和子类类别，均按照Compile Sources 出现的顺序执行。
2、当子类未实现 load 方法时，在加载该子类时，不会去调用其父类 load 方法。
参考链接:iOS load方法调用机制解析
+ (void)initialize方法的执行顺序
1、initialize 方法是在这个类第一次被使用到时才调用，具体为第一次调用该类的相关方法；
2、父类的 initialize 先执行；
3、如果子类没有实现 initialize，则会调用父类的initialize；
4、如果子类实现了 initialize，那么就直接执行子类的 initialize
5、理论上只会调用一次，但是因为采用了 objc_msgSend 来调用，所以如果子类没有实现 initialize，那么就会多次调用父类的 initialize，可以通过添加 if (self == [ClassName self]) 来进行判断；
6、不像 load 方法，会区分类和分类保存在两个数组中分别执行， 分类的 initialize 方法会覆盖原来类的 initialize，且遵循分类的编译顺序原则，最靠后的分类最终替换掉之前的 initialize 方法；
