分类与拓展

分类(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部分)，也就是说，类扩展所声明的方法必须依托对应类的实现部分来实现。