一、Category（类别，分类）的使用场景

• 为已经存在的类添加方法和属性
• 把不同的功能组织到不同的category
• 模拟多继承（另外模拟多继承的还有protocol）

1）给类扩展:类别或者继承

category相比继承的缺点

1.新的扩展方法还需要父类的实现，与原方法重名。若使用类别则会覆盖。所谓覆盖其实也不是很准确，具体解释见原理。
2.category不能添加实例变量，具体解释见原理。
3.如果一个类有多个category，不同的类别同时定义同一个方法，则调用哪个不一定，具体解释见原理。

category相比inherit的优点

1.category可以修改原类基础上扩展类的方法，实现私有类 方法扩展以及一些不能修改源码类的扩展，也就是说不会入侵原类的代码结构，比继承更为轻量级。
2.category可以将类的实现分散到多个文件。
3.category可以创建私有方法的前向引用：在类别里声明一个类的私有方法，不需要实现，编译不会报错，运行时会调用私有方法。继承不能继承私有方法。
4.category可以向类添加非正式协议：因为Objective-C里面的类大都是NSObject的子类，所以在NSObject的类别里定义函数，所有对象都能使用

2）添加属性:runtime

直接在category的.h中添加这时候会有warning

⚠️ Property 'name' requires method 'setName:' to be defined - use @dynamic or provide a method implementation in this category

类别不会自动帮属性生成getter/setter方法，也不能生成带下划线的实例变量。我们可以用runtime【关联对象】去实现category唯一有的类添加新的属性并生成getter/settet方法。

runtime我们提供了以下方法

参数:  id object：被关联的对象  
          const void *key：关联的key，要求唯一
          id value：关联的对象（如dog）
          objc_AssociationPolicy policy：内存管理的策略

//关联对象 
void objc_setAssociatedObject(id object, const void *key, id value, objc_AssociationPolicy policy)
 
//获取关联的对象
id objc_getAssociatedObject(id object, const void *key)
 
//移除关联的对象
void objc_removeAssociatedObjects(id object)

当对象被释放时，会根据这个策略来决定是否释放关联的对象，当策略是RETAIN/COPY时，会释放（release）关联的对象，当是ASSIGN，将不会释放。
值得注意的是，我们不需要主动调用removeAssociated来接触关联的对象，如果需要解除指定的对象，可以使用setAssociatedObject置nil来实现。

举个🌰

我为Student+teach.h类添加了个name属性，.h文件如下

#import "Student.h"

@interface Student (teach)

//不会生成添加属性的getter和setter方法，必须我们手动生成
@property (nonatomic, copy) NSString * name;

@end

.m文件如下

#import "Student+teach.h"
//导入头文件
#import <objc/runtime.h>

@implementation Student (teach)
//定义关联的key
static const char *key = "name";

//getter方法
- (NSString *)name {
    //根据key获取关联的值
    return objc_getAssociatedObject(self, key);
}

//setter方法
- (void)setName:(NSString *)name {
    //参数设置
    objc_setAssociatedObject(self, key, name, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}

@end

运行测试代码

   Student *xiaoming = [[Student alloc] init];
    xiaoming.name = @"xiaoming";
    NSLog(@"%@",xiaoming.name);

打印结果

2017-05-23 13:49:52.166 RuntimeTest[3009:178563] xiaoming

注：这里区分一下属性和成员变量的区别

1.我声明了一个属性name。

@property (nonatomic, copy) NSString * name;

会为我生成一个以下划线为开头的实例变量_name，也不需要写@synthesize name；，会自动还是你歌城getter/setter方法。那么在.m文件中可以直接使用_name实例变量，也可以self.name通过属性的getter/setter设置。

2.大括号

@interface MyViewController:UIViewController
{
 NSString *name;
}
@end

此时用点语法会提示,编辑器会提示让你把.改为->。因为点语法是调用方法，为代码里没有getter/setter方法。

3.点语法的说明

如果点表达式出现在=左边，则该属性的setter的方法将会被调用。右边则为getter方法。

4.synthesize的用法

@synthesize name = myname;
会自动生成实例变量myname而不是默认的_name,自动生成getter/setter方法，所以它的作用是指定实例变量名称。

3）模拟多继承：消息转发、delegate和protocol、类别

oc不支持多线程，由于消息机制消息名字查找发生在运行时而非编译时，多个基类可能导致二义性问题。模拟多线程有以下几个方法： 消息转发，delegate和protocol，类别。

类别：

如上🌰。

delegate和protocol：

委托协助主体完成操作任务，将需要定制化的操作预留给委托对象来自定义实现，类似子类化主体。
除此之外，可以用作事件监听。

消息转发：

当向某对象发送消息但是runtime system在当前类和父类中都找不到该方法的实现时，runtime不会立即报错，而是有以下步骤，

模拟多线程.png

简述流程：
1.动态方法解析：向当前类发送resolveInstanceMethod:的信号，检查是否像这个类动态添加了方法。
相关链接：http://blog.csdn.net/haishu_zheng/article/details/12873151
2.快速消息发送：检查这个类是否实现了forwardingTargetForSelector:方法，是吸纳了就调用。若返回值对象非空nil或者非self，则向该返回对象重新发送信息。
利用快速消息转发forwardingTargetForSelector:方法重写，结合【类别】或者【类型强转】可以实现多继承方法

思考问题：如果将其类型转成`id ，也可以编译通过，并实现转发。可是会带来什么隐患呢？

3.标准信息发送：runtime发送methodSignatureForSelector:消息获取Selector对应的方法签名。返回值非空则通过forwardInvocation:转发消息，返回值为空则向当前对象发送doesNotRecognizeSelector:消息，程序崩溃退出。
标准消息转发需要重写 methodSignatureForSelector: 和 forwardInvocation: 两个方法即可。

二、category的原理和特性

1）原理

runtime的源码里可以找到_read_images函数:

void _read_images(header_info **hList, uint32_t hCount, int totalClasses, int unoptimizedTotalClasses) {
...
    // Discover categories. 
    for (EACH_HEADER) {
        category_t **catlist = 
            _getObjc2CategoryList(hi, &count);
        bool hasClassProperties = hi->info()->hasCategoryClassProperties();

        for (i = 0; i < count; i++) {
            category_t *cat = catlist[i];
            Class cls = remapClass(cat->cls);

            if (!cls) {
                // Category's target class is missing (probably weak-linked).
                // Disavow any knowledge of this category.
                catlist[i] = nil;
                if (PrintConnecting) {
                    _objc_inform("CLASS: IGNORING category \?\?\?(%s) %p with "
                                 "missing weak-linked target class", 
                                 cat->name, cat);
                }
                continue;
            }

            // Process this category. 
            // First, register the category with its target class. 
            // Then, rebuild the class's method lists (etc) if 
            // the class is realized. 
            bool classExists = NO;
            if (cat->instanceMethods ||  cat->protocols  
                ||  cat->instanceProperties) 
            {
                addUnattachedCategoryForClass(cat, cls, hi);
                if (cls->isRealized()) {
                    remethodizeClass(cls);
                    classExists = YES;
                }
                if (PrintConnecting) {
                    _objc_inform("CLASS: found category -%s(%s) %s", 
                                 cls->nameForLogging(), cat->name, 
                                 classExists ? "on existing class" : "");
                }
            }

            if (cat->classMethods  ||  cat->protocols  
                ||  (hasClassProperties && cat->_classProperties)) 
            {
                addUnattachedCategoryForClass(cat, cls->ISA(), hi);
                if (cls->ISA()->isRealized()) {
                    remethodizeClass(cls->ISA());
                }
                if (PrintConnecting) {
                    _objc_inform("CLASS: found category +%s(%s)", 
                                 cls->nameForLogging(), cat->name);
                }
            }
        }
    }
...
}

里面提到了两个比较重要的函数:

1. addUnattachedCategoryForClass()
2. remethodizeClass()

• addUnattachedCategoryForClass()主要是构建class和category的哈希表，如果不存在则生成，如果存在则重新构建，主要是class到category的一个映射关系。
• remethodizeClass调用了attachCategories方法，这个方法里面把category里的方法，属性和协议列表都添加到相应的类里面，从本质来说，调用类的方法和分类的方法都是一样的。

2）category重名函数覆盖

在看源码的attachLists方法

 void attachLists(List* const * addedLists, uint32_t addedCount) {
      if (addedCount == 0) return;

      if (hasArray()) {
          // many lists -> many lists
          uint32_t oldCount = array()->count;
          uint32_t newCount = oldCount + addedCount;
          setArray((array_t *)realloc(array(), array_t::byteSize(newCount)));
          array()->count = newCount;
          memmove(array()->lists + addedCount, array()->lists, 
                  oldCount * sizeof(array()->lists[0]));
          memcpy(array()->lists, addedLists, 
                 addedCount * sizeof(array()->lists[0]));
      }
      else if (!list  &&  addedCount == 1) {
          // 0 lists -> 1 list
          list = addedLists[0];
      } 
      else {
          // 1 list -> many lists
          List* oldList = list;
          uint32_t oldCount = oldList ? 1 : 0;
          uint32_t newCount = oldCount + addedCount;
          setArray((array_t *)malloc(array_t::byteSize(newCount)));
          array()->count = newCount;
          if (oldList) array()->lists[addedCount] = oldList;
          memcpy(array()->lists, addedLists, 
                 addedCount * sizeof(array()->lists[0]));
      }
  }

第一个判断语句中C函数 memmove(dest, src, len)和memcpy(des, src, size)完成了将旧函数数组后移空出位置，把新的函数数组添加到原数组空位的过程。
下一个判断语句意思为如果list没有值，那么直接赋值给它。
最后一个判断语句是找到多个函数名一样的，进行插入。

综上所述，category里新增的和原来类重名的函数将会被添加在原函数列表的前面，并不是覆盖。如果想要调用原函数的方法，只需要便利函数列表，调用最后一个来执行。这就是category重名函数覆盖，并且同个类多个category重名调用不确定的原因。（有些文章指出执行顺序跟编译顺序有关）

3）Category和Extension的区别

1、Extension在编译期决议，它就是类的一部分，在编译期和头文件里的@interface以及实现文件里的@implement一起形成一个完整的类，它伴随类的产生而产生，亦随之一起消亡。Extension一般用来隐藏类的私有信息，你必须有一个类才能为这个类添加Extension，所以你无法为系统的类比如NSString添加Extension。
2、Category则完全不一样，它是在运行期决议的。
3、Extension可以添加属性、成员变量，而Category一般不可以。

总之，就Category和Extension的区别来看，Extension可以添加实例变量，而Category是无法添加实例变量的。因为Category在运行期，对象的内存布局已经确定，如果添加实例变量就会破坏类的内部布局，这对编译型语言来说是灾难性的。

4）Category不能添加成员变量

因为方法和属性并不“属于”类实例，而成员变量“属于”类实例。我们所说的“类实例”概念，指的是一块内存区域，包含了isa指针和所有的成员变量。所以假如允许动态修改类成员变量布局，已经创建出的类实例就不符合类定义了，变成了无效对象。但方法定义是在objc_class中管理的，不管如何增删类方法，都不影响类实例的内存布局，已经创建出的类实例仍然可正常使用。

第一次发简书文章，如果所述有错误或者不明确的地方，望大家不吝赐教😁 ~

参考：
美团技术文档： http://tech.meituan.com/DiveIntoCategory.html