一、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不会立即报错，而是有以下步骤，
简述流程：
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);
}
}
}
}
...
}
里面提到了两个比较重要的函数:
addUnattachedCategoryForClass()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
