分类、类别、类目（Category）及关联对象

---

（编译 命令）
xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc KXPerson+Test.m

1、Category的使用场合是什么？

(1).为某个类拓展方法，分模块。

2、Category 编译之后的底层结构

struct _category_t {
        const char *name;
        struct _class_t *cls;
        const struct _method_list_t *instance_methods;   //对象方法列表
        const struct _method_list_t *class_methods;      //类对象方法列表
        const struct _protocol_list_t *protocols;        //协议列表
        const struct _prop_list_t *properties;           //属性列表
};

3、Category的实现原理

(1). Category 编译之后的底层结构是struct category_t，里面存储着分类的对象方法列表、类方法列表、属性列表、协议列表等信息

(2). 在程序运行的时候，runtime会将Category的数据，合并到类信息中（类对象、元类对象中）。

4、Category的加载处理过程

(1).首先是编译，在编译过程中会把分类中的类方法合并到分类的类方法列表中，把分类中的对象方法合并到分类的对象方法列表< const struct _method_list_t *instance_methods>中，把分类中的属性合并到分类的属性列表< const struct _prop_list_t *properties>中，把分类中的协议合并到分类的协议列表< const struct _protocol_list_t *protocols>中。

(2).其次是加载，通过Runtime加载某个类的所有Category数据：把所有Category的方法、属性、协议数据，合并到一个大数组中（后面参与编译的Category数据，会在数组的前面）。

(3).最后，将合并后的分类数据（方法、属性、协议），插入到类原来数据的前面

5、Category能否添加成员变量？如果可以，如何给Category添加成员变量？

不能直接给Category添加成员变量，但是可以间接实现Category有成员变量的效果

6、Category和Class Extension的区别是什么？

(1).Class Extension在  *编译*  的时候，它的数据就已经包含在类信息中
(2).Category是在  *运行时*，才会将数据合并到类信息中

7、Category中有load方法吗？load方法是什么时候调用的？load 方法能继承吗？

(1).有load方法
(2).load方法在runtime加载类、分类的时候调用
(3).load方法可以继承，但是一般情况下不会主动去调用load方法，都是让系统自动调用

• (1) +load方法

     <1>+load方法会在runtime加载 类、分类 时调用
  
     <2>每个类、分类的+load，在程序运行过程中只调用一次
  
     <3>调用顺序:
            a. 先调用类的+load
            * 按照编译先后顺序调用（先编译，先调用）
            * 调用子类的+load之前会先调用父类的+load
  
            b.再调用分类的+load
            * 按照编译先后顺序调用（先编译，先调用）
  

• (2) +initialize方法

      <1>+initialize方法会在类第一次接收到消息时调用
  
      <3>调用顺序：
            a.先调用父类的+initialize，再调用子类的+initialize
            b. (先初始化父类，再初始化子类，每个类只会初始化1次)
  

• (3)initialize和+load的很大区别是，+initialize是通过objc_msgSend进行调用的，所以有以下特点

     <1>如果子类没有实现+initialize，会调用父类的+initialize（所以父类的+initialize可能会被调用多次）
     <2>如果分类实现了+initialize，就覆盖类本身的+initialize调用
  

8、load、initialize方法的区别什么？它们在category中的调用的顺序？以及出现继承时他们之间的调用过程？

load、initialize方法的区别什么？
1.调用方式
1> load是根据函数地址直接调用
2> initialize是通过objc_msgSend调用

2.调用时刻
1> load是runtime加载类、分类的时候调用（只会调用1次）
2> initialize是类第一次接收到消息的时候调用，每一个类只会initialize一次（父类的initialize方法可能会被调用多次）

load、initialize的调用顺序？
1.load
1> 先调用类的load
a) 先编译的类，优先调用load
b) 调用子类的load之前，会先调用父类的load

2> 再调用分类的load
a) 先编译的分类，优先调用load

2.initialize
1> 先初始化父类
2> 再初始化子类（可能最终调用的是父类的initialize方法）

• Category能否添加成员变量？如果可以，如何给Category添加成员变量？

答：1、不能直接给Category添加成员变量，但是可以间接实现Category有成员变量的效果。
2、可以使用关联对象的方式可以实现给Category有成员变量的效果。

关联对象

思考：如何实现给分类添加成员变量？

默认情况下，因为分类底层结构的限制，不能添加成员变量到分类中。但可以通过关联对象来间接实现。

• 关联对象提供了以下API:

• 添加关联对象
  参数：
  id object：被关联的对象
  const void * key：key
  id value：关联的值
  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)

• 关联策略：objc_AssociationPolicy

objc_AssociationPolicy	对应的修饰符
OBJC_ASSOCIATION_ASSIGN	assign
OBJC_ASSOCIATION_RETAIN_NONATOMIC	strong, nonatomic
OBJC_ASSOCIATION_COPY_NONATOMIC	copy, nonatomic
OBJC_ASSOCIATION_RETAIN	strong, atomic
OBJC_ASSOCIATION_COPY	copy, atomic

• 关联对象的原理

  
  
  Category-100.png

Category-101.png

#import 
#import "KXPerson.h"
#import "KXPerson+Test.h"
#import 

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        KXPerson *person = [[KXPerson alloc] init];
        person.age = 10;
        person.name = @"jack";
        person.weight = 30;
        
        
        KXPerson *person2 = [[KXPerson alloc] init];
        person2.age = 20;
        person2.name = @"rose";
        person2.name = nil;
        person2.weight = 50;
        
        NSLog(@"person - age is %d, name is %@, weight is %d", person.age, person.name, person.weight);
        NSLog(@"person2 - age is %d, name is %@, weight is %d", person2.age, person2.name, person2.weight);
    }
    return 0;
}

#import 

//struct MJPerson_IMPL
//{
//    Class isa;
//    int _age;
//};

@interface KXPerson : NSObject
//{
//    int _age;
//}
//
//- (void)setAge:(int)age;
//- (int)age;

@property (assign, nonatomic) int age;

@end

--------------------------------------

#import "KXPerson.h"

@implementation KXPerson

//- (void)setAge:(int)age
//{
//    _age = age;
//}
//
//- (int)age
//{
//    return _age;
//}

@end

#import "KXPerson.h"

@interface KXPerson (Test)
@property (copy, nonatomic) NSString *name;
@property (assign, nonatomic) int weight;

@end

----------------------------------

#import "KXPerson+Test.h"
#import 

@implementation KXPerson (Test)

- (void)setName:(NSString *)name
{
    objc_setAssociatedObject(self, @selector(name), name, OBJC_ASSOCIATION_COPY_NONATOMIC);
}

- (NSString *)name
{
    // 隐式参数
    // _cmd == @selector(name)
    return objc_getAssociatedObject(self, _cmd);
}

- (void)setWeight:(int)weight
{
    objc_setAssociatedObject(self, @selector(weight), @(weight), OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}

- (int)weight
{
    // _cmd == @selector(weight)
    return [objc_getAssociatedObject(self, _cmd) intValue];
}

//- (NSString *)name
//{
//    return objc_getAssociatedObject(self, @selector(name));
//}
//- (int)weight
//{
//    return [objc_getAssociatedObject(self, @selector(weight)) intValue];
//}

@end