分类(Category)

Category是Objective-C 2.0之后添加的语言特性，分类、类别其实都是指的Category。Category的主要作用是为已经存在的类添加方法。

我们用分类都做了什么事

声明私有方法(我们定义一个分类,只把头文件放在对应宿主文件的.m当中,满足私有方法的声明和使用,对外不暴露)
分解体积庞大的类文件(比如一个类的功能特别复杂,那么我们可以按照功能来对类当中的方法进行分类,把同一个功能的方法放在一个分类文件当中)
把Framewrok的私有方法公开化

特点

运行时决议(我们在编写好分类的文件后,它并没有把分类的内容添加到宿主类上面,这个时候宿主类中还没有分类中的方法,而是在运行时通过runtime把分类中添加的内容真实的添加到宿主类上面)
可以为系统类添加分类(比如我们经常会用到获取UIView坐标的分类方法,就是在对UIView添加了分类)

分类中可以添加哪些内容

实例方法
类方法
协议
属性(其实只是声明了get、set方法,并没有添加实例变量,可以通过关联对象来添加实例变量)

我们来看看分类的底层结构

struct category_t {
    const char *name;//分类的名称
    classref_t cls;//分类所属的宿主类
    struct method_list_t *instanceMethods;//实例方法列表
    struct method_list_t *classMethods;//类方法列表
    struct protocol_list_t *protocols;//协议
    struct property_list_t *instanceProperties;//实例属性列表
   
    method_list_t *methodsForMeta(bool isMeta) {
        if (isMeta) return classMethods;
        else return instanceMethods;
    }
    property_list_t *propertiesForMeta(bool isMeta, struct header_info *hi);
};

我们通过分类的结构就可以更好的印证我们能够为分类添加哪些内容,这里并没有实例变量的成员结构.

源码分析

objc-runtime-new.mm
这里主要分析实例方法的添加逻辑.
我们从 remethodizeClass 这个方法开始分析

static void remethodizeClass(Class cls)
{
    category_list *cats;
    bool isMeta;
    runtimeLock.assertWriting();
//判断当前类是否是元类对象,也就是判断添加的方法是实例方法还是类方法
    isMeta = cls->isMetaClass();
    // 获取cls中未完成整合的所有分类
    if ((cats = unattachedCategoriesForClass(cls, false/*not realizing*/))) {
        if (PrintConnecting) {
            _objc_inform("CLASS: attaching categories to class '%s' %s", 
                         cls->nameForLogging(), isMeta ? "(meta)" : "");
        }
      //将cats拼接到cls上
        attachCategories(cls, cats, true /*flush caches*/);        
        free(cats);
    }
}

来看看attachCategories这个拼接分类到宿主类的方法

static void 
attachCategories(Class cls, category_list *cats, bool flush_caches)
{
    if (!cats) return;//如果当前类没有分类的话直接返回
    if (PrintReplacedMethods) printReplacements(cls, cats);
    //判断当前类是否是元类对象
    bool isMeta = cls->isMetaClass();

    /*
二维数组 [[method_t,method_t,...],[method_t],[method_t,method_t,method_t],...]
  */
    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));//协议列表

    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);
        if (proplist) {
            proplists[propcount++] = proplist;
        }
          //协议列表添加规则,同方法列表添加规则
        protocol_list_t *protolist = entry.cat->protocols;
        if (protolist) {
            protolists[protocount++] = protolist;
        }
    }
    // 获取宿主类当中的rw数据,其中包含宿主类的方法列表信息
    auto rw = cls->data();
    // 主要是针对 分类中有关于内存管理相关方法情况下的一些特殊处理
    prepareMethodLists(cls, mlists, mcount, NO, fromBundle);
    /*
    methods代表类的方法列表,attachLists方法表示将mcount个元素的mlists(方法列表)拼接到rw(宿主类)的methods(方法列表)上
    */
    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);
}

演示图例

分类方法添加到对象方法列表中

添加分类的流程

获取分类列表的count，然后原来的类方法列表内存移动count
分类列表内存拷贝到原来的类方法列表的前方
同样的方法，优先调用分类的方法
分类具有同样的方法，根据编译顺序决定，取最后编译分类的方法列表

拓展(Extension)

我们用拓展都做了什么事

声明私有属性
声明私有方法
声明私有成员变量

拓展的特定

编译时决议
只以声明存在,没有具体实现，寄生于宿主类.m中
不能为系统类添加扩展

分类、扩展区别

分类中原则上只能增加方法(能添加属性的的原因只是通过runtime解决无setter/getter的问题而已)
类扩展不仅可以增加方法，还可以增加实例变量（或者属性），只是该实例变量默认是@private类型的(用范围只能在自身类，而不是子类或其他地方)
类扩展中声明的方法没被实现，编译器会报警，但是类别中的方法没被实现编译器是不会有任何警告的。这是因为类扩展是在编译阶段被添加到类中，而类别是在运行时添加到类中。
类扩展不能像分类那样拥有独立的实现部分(@implementation部分)，也就是说，类扩展所声明的方法必须依托对应类的实现部分来实现。

分类与拓展