实例对象                               
instance &ISA_MASK                              
  isa------------>类对象                   
其他成员变量        class   &ISA_MASK  
                   isa---------------->元类对象  &ISA_MASK
                superclass             isa-------------->基元类对象(isa----->它本身)    
            属性/对象方法/协议/成员变量    superclass
                                       类方法
# if __arm64__
#   define ISA_MASK   0x0000000ffffffff8ULL
# elif __x86_64__
#   define ISA_MASK   0x00007ffffffffff8ULL
# endif
MASK: 掩码,一般用来按位与(&)运算的
按位 & 可以用来取出特定的位

struct objc_object {
    isa_t isa;  //联合体+位域的方式存储信息的
}

union isa_t {  //共用体
    Class cls;
    uintptr_t bits;  //存放所有的数据
    struct {  //利用了位域技术,这个结构体纯粹就是为了增加可读性,其它没什么作用
        //占1位 最低的地址(0b0000 0000 最后一位代表这个值)
        uintptr_t nonpointer        : 1;  
        uintptr_t has_assoc         : 1;  
        uintptr_t has_cxx_dtor      : 1;
        uintptr_t shiftcls          : 33; //代表类/元类对象的地址
        uintptr_t magic             : 6;
        uintptr_t weakly_referenced : 1;
        uintptr_t deallocating      : 1;
        uintptr_t has_sidetable_rc  : 1;
        uintptr_t extra_rc          : 19;
    };
//结构体中位的总和是64位,即8个字节,虽然优化后存储了大量的信息,但是利用共用体和位域技术可以共用一块内存
}

    static StripedMap<SideTable>& SideTables() {
        return *reinterpret_cast<StripedMap<SideTable>*>(SideTableBuf);
    }

    //MARK: StripedMap底层结构 可以存放64个SideTable
    class StripedMap {
        enum { StripeCount = 64 };    //ios设备  StripeCount = 64字节
    }
    struct SideTable {
        spinlock_t slock;           //自旋锁：用于上锁/解锁SideTable
        RefcountMap refcnts;        //OC对象引用计数Map（key为对象，value为引用计数）-引用计数表
        weak_table_t weak_table;    //OC对象弱引用Map-弱引用表
    }
    

    //weak_table 是一个哈希表的结构, 根据 weak 指针指向的对象的地址计算哈希值, 哈希值相同的对象按照下标 +1 的形式向后查找可用位置, 
    是典型的闭散列算法. 最大哈希偏移值即是所有对象中计算出的哈希值和实际插入位置的最大偏移量, 在查找时可以作为循环的上限.
    //通过对象的地址，可以找到weak_table_t结构中的weak_entry_t
    //weak_entry_t 中保存了所有指向这个对象的 weak 指针.
    //⚠️弱引用表底层结构
    struct weak_table_t {
        weak_entry_t *weak_entries;         //hash数组(动态数组)
        size_t    num_entries;              //hash数组中元素的个数
        uintptr_t mask;                     //hash数组长度-1，而不是元素的个数，一般是做位运算定义的值
        uintptr_t max_hash_displacement;    //hash冲突的最大次数(最大哈希偏移值)
    };
    
     /* union联合体特点
     1.联合体中可以定义多个成员，联合体的大小由最大的成员大小决定
     2.联合体的成员公用一个内存，一次只能使用一个成员
     3.对某一个成员赋值，会覆盖其他成员的值
     4.存储效率更高，可读性更强，可以提高代码的可读性，可以使用位运算提高数据的存储效率
     */
    //弱引用实体,一个对象对应一个weak_entry_t,保存对象的弱引用;保存弱应用的是个联合体,当弱引用小于等于4个的时候,直接用inline_referrers数组保存
    大于四个时用referrers动态数组
    struct weak_entry_t { //对应关系是[referent weak指针的数组]
        DisguisedPtr<objc_object> referent;   //被弱引用的对象
        union { //联合体（共用体）共用体的所有成员占用同一段内存
            struct {
                weak_referrer_t *referrers;  //指向 referent 对象的weak指针数组。动态数组保存弱引用的指针
                uintptr_t        out_of_line_ness : 2;     //这里标记是否超过内联边界, 下面会提到
                uintptr_t        num_refs : PTR_MINUS_2;   //数组中已占用的大小
                uintptr_t        mask;          //数组下标最大值(数组大小 - 1)
                uintptr_t        max_hash_displacement;  //最大哈希偏移值
            };
            struct {
                //这是一个取名叫内联引用的数组，WEAK_INLINE_COUNT宏定义值为4 初始化时默认使用的数组
                weak_referrer_t  inline_referrers[WEAK_INLINE_COUNT];  //静态数组
            };
        };
        //当指向这个对象的 weak 指针不超过 4 个, 则直接使用数组 inline_referrers, 省去了哈希操作的步骤, 如果 weak 指针个数超过了4个, 就要使用第一个结构体中的动态数组weak_referrer_t *referrers
        bool out_of_line() {
            return (out_of_line_ness == REFERRERS_OUT_OF_LINE);
        }

        weak_entry_t& operator=(const weak_entry_t& other) {
            memcpy(this, &other, sizeof(other));
            return *this;
        }

        weak_entry_t(objc_object *newReferent, objc_object **newReferrer)
            : referent(newReferent)
        { //构造方法，里面初始化了静态数组
            inline_referrers[0] = newReferrer;
            for (int i = 1; i < WEAK_INLINE_COUNT; i++) {
                inline_referrers[i] = nil;
            }
        }
    };

全局SideTables哈希表                Sidetable              weak_table                  weak_entries       weak_entry_t
                                  slock自旋锁          weak_entries(hash数组)         [weak_entry_t]--->  referent 弱引用对象地址
[Sidetable]  SideTables[对象地址] refcnts引用计数表      num_entries(hash数组中元素的个数) [weak_entry_t]     []数组存放weak指针地址的数组
[Sidetable]----------------->   weak_table弱引用表 ----> mask (hash数组长度-1)          [weak_entry_t]
  ......                           
[Sidetable]
[Sidetable]

#define WGTallMask (1<<0)       1向左移动0位   0000 0001   <<0   0000 0001
#define WGRichMask (1<<1)       1向左移动1位   0000 0001   <<1   0000 0010
#define WGHandsomeMask (1<<2)   1向左移动2位   0000 0001   <<2   0000 0100

//结构体是支持位域技术的;下面的结构体只占1个字节,拿出来三位用来存储对应的值,
struce {
    char tall : 1;     //只占一位(不用关心char类型,只看后面的1)   
    char rich : 1;     //只占一位
    char handsome : 1; //只占一位
    //0b0000 0000 最后一位代表tall,倒数第二位代表rich,倒数第三位代表handsome
} _tallRichHandsome

结构体中的成员是独立存在,每个成员占4个字节      共用体:大家共用一块内存空间 
struct Date {                            union Data {
    int year;  //4个字节                      int year;  //4个字节  
    int month; //4个字节                      int month; //4个字节
    int day;   //4个字节                      int day;   //4个字节
}                                        }
    
---------0x0000                          ---------0x0000
   year  -->4个字节                       存year|month|day -->4个字节
---------0x0004                          ---------0x0004
   month--->4个字节
---------0x0008
   day----->4个字节
---------0x000c

    struct objc_class {
        Class isa;
        Class superclass;
        cache_t cache;          //方法缓存
        class_data_bits_t bits; //用于获取具体的类信息
    }
    
    #define FAST_DATA_MASK          0x00007ffffffffff8UL
    bits & FAST_DATA_MASK ------> class_rw_t
    
    struct class_rw_t {
        uint32_t flags;
        uint32_t version;
        const class_ro_t *ro;
        method_array_t methods;       //方法列表(分类+类)、二维数组、可读可写
        property_array_t properties;  //属性列表(分类+类)、二维数组、可读可写
        protocol_array_t protocols;   //属性协议(分类+类)、二维数组、可读可写
        Class firstSubclass;
        Class nextSiblingClass;
        char *demangledName;
    }

元素1             元素2           元素3           元素4           元素... 
method_list_t    method_list_t   method_list_t  method_list_t   ...

method_list_t一维数组
 元素1        元素2       元素3       元素4     元素... 
method_t    method_t   method_t   method_t    ...

struct method_t {
    SEL name;            
    const char *types;   
    IMP imp;             
}

    //编译期已经确定的内容
    struct class_ro_t {
        uint32_t flags;
        uint32_t instanceStart;
        uint32_t instanceSize;  //instance对象占用的内存空间
    #ifdef __LP64__
        uint32_t reserved;
    #endif
        const uint8_t * ivarLayout;
        const char * name;      //类名
        method_list_t * baseMethodList;   //一维数组
        protocol_list_t * baseProtocols;  //一维数组
        const ivar_list_t * ivars;        //成员变量列表-一维数组
        const uint8_t * weakIvarLayout;
        property_list_t *baseProperties;  //一维数组
    }

    method_list_t一维数组
     元素1        元素2       元素3       元素4     元素... 
    method_t    method_t   method_t   method_t    ...

    struct method_t {
        SEL name;
        const char *types;
        IMP imp;
    }

struct method_t {
    SEL name;            //函数名(方法名)
    const char *types;   //编码(返回值类型、参数类型)
    IMP imp;             //指向函数的指针(函数地址)
}

    - (void)viewDidLoad {
        [super viewDidLoad];
        NSLog(@"-----%s",@encode(int));
        NSLog(@"-----%s",@encode(id));
        NSLog(@"-----%s",@encode(SEL));
    }
    打印结果: -----i
            -----@
            -----:

//这个方法的types是(i24@0:8i16f20)
// i: 返回值类型  @是第一个参数id类型就是消息接收者  :是SEL  i表示int类型 f表示float类型
// 24代表所有参数的字节数(id-8字节 SEL-8字节 int-4字节 float-4字节)
// @代表第一个参数id,0表示这个参数从哪里开始,
// 8代表参数:(SEL)开始的字节数  16代表参数i开始的字节数 20代表f开始的字节数
-(int)test:(int)age height:(float)height;

struct objc_class {
    Class isa;
    Class superclass;
    cache_t cache;          //方法缓存
    class_data_bits_t bits; //用于获取具体的类信息
}

struct cache_t {
    struct bucket_t *_buckets;  //数组,其实就是个散列表,里面存放的是bucket_t，即[bucket_t]
    mask_t _mask;               //散列表长度-1(数组元素个数-1)
    mask_t _occupied;           //已经缓存的方法数量
}
为什么_mask的长度是散列表长度-1? 因为如果等于散列表长度,而@selector(test)&_mask的值要小于等于  
散列表的下标而最大的下标是散列表长度-1

struct bucket_t {               //散列表
    cache_key_t _key;           //SEL作为Key
    IMP _imp;                   //函数的内存地址
}

例如: [person test]    //_key = @selector(test)  _imp = test的地址

数组下标index  元素    
   0        NULL
   1        NULL
   2        NULL
   3        bucket_t(_key,_imp)
   4        ......

(1)receiver是否为nil---否--->(2)从receive Class的cache中查找方法---找到--->调用方法结束查询
     是                         没有找到
     退出       (3)从receive Class的class_rw_t中查找方法---找到--->调用方法结束查询
                                  |                     并将方法缓存到receive的cache中
                                  |
                               没有找到
                (4)从superClass的cache中查找方法---找到--->调用方法结束查询
                                  |               并将方法缓存到receive的cache中
                                  |
                                没有找到
              (5)从superClass的class_rw_t中查找方法---找到--->调用方法结束查询
                                  |                   并将方法缓存到receive的cache中
                                  |
                                没有找到
                 (6)上层是否还有superClass---否--->动态方法解析阶段
                                  |
                                  |
                                  是
                            继续(4)步骤

            是否曾经有动态解析---> 是 ---> 消息转发
                    | 否
    调用+(BOOL)resolveInstanceMethod:(SEL)sel
    或者+(BOOL)resolveClassMethod:(SEL)sel来动态解析方法
                    |
              标记为已经动态解析
                    |
                  消息发送

@interface Person : NSObject
-(void)test;
@end

#import "Person.h"
#import <objc/runtime.h>
@implementation Person
/*
 typedef struct objc_method *Method;
 objc_method其实等价于method_t结构体
 struct method_t {
            SEL name;
            const char *types;
            IMP imp;
 };
 */
-(void)otherTest{
    NSLog(@"---%s---",__func__);
}
//对象方法
+(BOOL)resolveInstanceMethod:(SEL)sel {
    if (sel == @selector(test)) {
        //动态添加test对象方法的实现
        //1. 获取其它方法:传self,因为是在类方法中,所以self代表类对象,而对象方法是添加到类对象中的
        Method otherMethod = class_getInstanceMethod(self, @selector(otherTest));
        //2.方法添加到什么上面? 肯定是添加到类对象中,而这个方法就是在类方法中,所以self就代表类对象
        class_addMethod(self,
                        sel,  
                        method_getImplementation(otherMethod),
                        method_getTypeEncoding(otherMethod)
                        );
        //3.返回YES代表有动态添加方法,其实返回YES/NO都没关系,因为系统拿到这个返回值也不会做事情,只是打印
        return YES;
    }
    return [super resolveInstanceMethod:sel];
}
@end

- (void)viewDidLoad {
    [super viewDidLoad];
    Person *person = [[Person alloc]init];
    [person test];
}
打印结果: ----[Person otherTest]---

@interface Person : NSObject
+(void)test;
@end

#import "Person.h"
#import <objc/runtime.h>

@implementation Person
+(void)otherTest{
    NSLog(@"---%s---",__func__);
}
//类方法
+(BOOL)resolveClassMethod:(SEL)sel {
    if (sel == @selector(test)) {
        //获取类方法
        Method otherMethod = class_getClassMethod(self, @selector(otherTest));
        //将类方法添加到元类对象中, 类(self)的object_getClass就是元类对象
        class_addMethod(object_getClass(self),
                        sel,
                        method_getImplementation(otherMethod),
                        method_getTypeEncoding(otherMethod)
                        );
        return YES;
    }
    return [super resolveClassMethod:sel];
}

@end

- (void)viewDidLoad {
    [super viewDidLoad];
    [Person test];
}
打印结果: ---+[Person otherTest]---

(1)调用forwardingTargetForSelector方法---返回值不为nil--->(2)objc_megSend(返回值,SEL)
                        |
                        |  返回值为nil
        调用methodSignatureForSelector:方法---返回值为nil--->调用doesNotRecognizeSelector:方法
         [作用是返回一个有用有效的方法签名]
                        |
                        | 返回值不为nil
        再给最后一次机会去调用forwardInvocation:方法,来处理        

@interface Person : NSObject
-(void)test;
@end

#import "Person.h"
#import "Student.h"
@implementation Person
//1.方法一,消息转发:将消息转发给别人,将方法交给一个指定的对象去实现
-(id)forwardingTargetForSelector:(SEL)aSelector {
    if (aSelector == @selector(test)) {
        //底层实际上是这么处理的:objc_msgSend([[Student alloc]init], aSelector)
        return [[Student alloc]init];
    }
    return 0;
}

⚠️：这里Student对象中的方法有如下要求：方法名必须和调用的方法名要一致，方法参数类型要一致,参数名称可以不一致；  
方法返回值类型可以不一致

//2.如果方法一没有实现(相当于返回nil),或者返回值为nil,就继续调用下面这个方法
- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector {
    //返回一个方法签名: 方法签名(返回值类型、参数类型)
    if (aSelector == @selector(test)) {
        //"v16@0:8": 代表-(void)test的方法签名
        return [NSMethodSignature signatureWithObjCTypes:"v16@0:8"];
        //方法签名也可以这样写,前提是知道要实现的对象,并且对象有这个方法(知道一下就可以了)
        //return [[[Student alloc]init] methodSignatureForSelector:aSelector];
        return 
    }
    return [super methodSignatureForSelector:aSelector];
}

//3.返回完方法签名后,会调用下面的方法,如果方法签名中返回nil,那么就不会调用下面这个方法
//NSInvocation封装了一个方法调用,包括:方法调用者、方法名、方法参数
-(void)forwardInvocation:(NSInvocation *)anInvocation {
    //方法调用者:anInvocation.target
    //方法名:anInvocation.selector
    //方法参数: [anInvocation getArgument:NULL atIndex:0]
    //(1)可以指定一个对象来执行
    //anInvocation.target = [[Student alloc]init];
    //[anInvocation invoke];
    //上面的会报错,所以尽量用下面的方法来调用
    [anInvocation invokeWithTarget:[[Student alloc]init]];
}
@end

    #import "Person.h"
    @implementation Person

    /// 返回一个方法签名
    - (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector {
        if (aSelector == @selector(test)) {
            return [NSMethodSignature signatureWithObjCTypes:"v16@0:8"];
        }
        return [super methodSignatureForSelector:aSelector];
    }

    /// 这里可以尽情的实现方法调用
    -(void)forwardInvocation:(NSInvocation *)anInvocation {
        //这里可以随便处理,如打印一个信息,或者什么都不写都可以
        NSLog(@"我要尽情的处理");
    }
    @end

@implementation Person
/// 返回一个方法签名
- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector {
    if (aSelector == @selector(test:)) {
        return [NSMethodSignature signatureWithObjCTypes:"v20@0:8i16"];
    }
    return [super methodSignatureForSelector:aSelector];
}

/// 这里可以尽情的实现方法调用
-(void)forwardInvocation:(NSInvocation *)anInvocation {
    //参数顺序: receiver、selector、other arguments
    int age;
    [anInvocation getArgument:&age atIndex:2];
    //anInvocation还可以获取方法返回值: getReturnValue
    NSLog(@"---%d",age+10);
}
@end

- (void)viewDidLoad {
    [super viewDidLoad];
    Person *person = [[Person alloc]init];
    [person test:10];
}
打印结果:  ---20

@interface Student : NSObject
+(void)test;
@end

@implementation Student
+(void)test {
    NSLog(@"---%s",__func__);
}
@end

@interface Person : NSObject
+(void)test;
@end

@implementation Person
//如果消息转发的是类方法,那么这个方法应该也是类方法,所以方法用+号,但是一般我们直接敲方法出来的都是  
实例方法,因为编译器对于类方法没有提示,所以我们需要根据方法类型来决定是用+还是-

+(id)forwardingTargetForSelector:(SEL)aSelector {
    if (aSelector == @selector(test)) {
        //因为转发的是类方法,所以消息的接收者应该是类对象
        return [Student class];
    }
    return [super forwardingTargetForSelector:aSelector];
}
@end

- (void)viewDidLoad {
    [super viewDidLoad];
    [Person test];
}

打印结果: ---+[Student test]


@implementation Person
//如果消息转发的是类方法,那么这个方法应该也是类方法,所以方法用+号,但是一般我们直接敲方法出来的都是实例方法,  
因为编译器对于类方法没有提示,所以我们需要根据方法类型来决定是用+还是-
//+(id)forwardingTargetForSelector:(SEL)aSelector {
//    if (aSelector == @selector(test)) {
//        //因为转发的是类方法,所以消息的接收者应该是类对象
//        return [Student class];
//    }
//    return [super forwardingTargetForSelector:aSelector];
//}

/// 如果上面的方法返回为nil或者没有处理,就会继续执行下面的方法, 记得也是类方法(+)
+ (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector {
    if (aSelector == @selector(test)) {
        return [NSMethodSignature signatureWithObjCTypes:"v@:"];
    }
    return [super methodSignatureForSelector:aSelector];
}
// 这里也是个类方法
+(void)forwardInvocation:(NSInvocation *)anInvocation {
    NSLog(@"123123123");
}
@end
    
打印结果: 123123123

@interface Person : NSObject
/*
 写上这么一个属性,编译器会自动帮我们
 1.生成对应的getter/setter方法的声明
 -(void)setAge:(int)age;
 -(int)age;
 2._age成员变量
 {
    int _age;
 }
 3. getter/setter方法的实现
 -(void)setAge:(int)age {
     _age = age;
 }
 -(int)age {
     return _age;
 }
 */
@property(nonatomic, assign)int age;
@end
    
@implementation Person
/*
 1.@synthesize关键词是很早之前的写法,现在已经不需要再写这个关键词了,Xcode默认已经实现了,只要写  
 上属性@property,就会自动生成成员变量和getter/setter方法的实现
 2.@synthesize age = _age; 为age属性生成_age的成员变量,并且自动生成getter/setter方法的实现,  
 这里可以指定成员变量的名称,例如也可以这样写@synthesize age = _age1111;
 */
@synthesize age = _age;

/*
如果我们不希望Xcode自动帮我们生成属性的getter/setter方法的实现和对应的成员变量,可以这么写@dynamic age;
提醒编译器不要自动生成getter/setter的实现、不要自动生成对应的成员变量
外部仍然可以调用setAge方法,因为@dynamic并不影响属性的getter/setter方法的声明
 */
@dynamic age;

@end

@interface Student : Person
@end

@implementation Student
-(instancetype)init {
    if (self = [super init]) {
        NSLog(@"[self class] = %@",[self class]);           //Student
        NSLog(@"[self superclass] = %@",[self superclass]); //Person
        NSLog(@"------------------------------");
        NSLog(@"[super class] = %@",[super class]);         //Student
        NSLog(@"[super superclass] = %@",[super superclass]);//Person
    }
    return self;
}
@end

@interface Person : NSObject
@end

@implementation Person
@end

- (void)viewDidLoad {
    [super viewDidLoad];
    Student *student = [[Student alloc]init];
}

打印结果: [self class] = Student
        [self superclass] = Person
        ------------------------------
        [super class] = Student
        [super superclass] = Person

@interface Person : NSObject
-(void)run;
@end
@implementation Person
-(void)run {
    NSLog(@"----%s",__func__);
}
@end

@implementation Student
-(void)run {
    [super run];
}
@end

C++代码
static void _I_Student_run(Student * self, SEL _cmd) {
    ((void (*)(__rw_objc_super *, SEL))(void *)objc_msgSendSuper)((__rw_objc_super){  
    (id)self,
    (id)class_getSuperclass(objc_getClass("Student"))},
    sel_registerName("run"));
}

C++代码简化版 __rw_objc_super、objc_msgSendSuper在Runtime源码中可以找到
static void _I_Student_run(Student * self, SEL _cmd) {
    objc_msgSendSuper((__rw_objc_super){
    (id)self, 
    (id)class_getSuperclass(objc_getClass("Student")) //Student的父类Person类
    }, sel_registerName("run"));
}

struct __rw_objc_super { 
    struct objc_object *object; 
    struct objc_object *superClass; 
    __rw_objc_super(struct objc_object *o,struct objc_object *s):object(o),superClass(s){} 
};

//objc_super data structure, including the instance of the class that is to receive the
//message and the superclass at which to start searching for the method implementation.
//翻译过来就是objc_super是一个结构体,包含了一个消息接收者和消息接收者的父类,这个父类就是查找方法开始的地方
//简单说: 就是调用 [super 方法名],查看方法是从该类的父类开始查找的
objc_msgSendSuper(struct objc_super * _Nonnull super, SEL _Nonnull op, ...)
    OBJC_AVAILABLE(10.0, 2.0, 9.0, 1.0, 2.0);

struct objc_super {
    id receiver;        //消息接收者
    Class super_class;  //消息接收者的父类, 查找方法从这个类开始搜索
};

class、superclass在Runtime中的源码
- (Class)class {
    return object_getClass(self);
}
- (Class)superclass {
    return [self class]->superclass;
}

-(instancetype)init {
     if (self = [super init]) {
        //下面的底层结构是: objc_msgSend(self,@selector(class))
         NSLog(@"[self class] = %@",[self class]);           //Student
         NSLog(@"[self superclass] = %@",[self superclass]); //Person
         NSLog(@"------------------------------");
         //下面的底层结构是: objc_msgSendSuper({self,[Person Class]},@selecot(class))
         NSLog(@"[super class] = %@",[super class]);         //Student
         NSLog(@"[super superclass] = %@",[super superclass]);//Person
     }
     return self;
 }

类方法：类的类对象(元类)是否等于指定的类对象(元类对象)【类的元类是否等于指定的元类对象】
+ (BOOL)isMemberOfClass:(Class)cls {
    return object_getClass((id)self) == cls;
}
//实例方法：对象的类是否等于指定的类对象
- (BOOL)isMemberOfClass:(Class)cls {
    return [self class] == cls;
}
//类方法：类的类对象(元类)是否等于指定的类对象(元类)或者是指定的类对象(元类)的子类
//【类的元类是否等于指定的元类对象或者是指定元类对象的子类】
+ (BOOL)isKindOfClass:(Class)cls {
    for (Class tcls = object_getClass((id)self); tcls; tcls = tcls->superclass) {
        if (tcls == cls) return YES;
    }
    return NO;
}
//对象方法：对象的类对象是否是指定的类对象或者是指定的类对象的子类
- (BOOL)isKindOfClass:(Class)cls {
    for (Class tcls = [self class]; tcls; tcls = tcls->superclass) {
        if (tcls == cls) return YES;
    }
    return NO;
}

Person *per = [[Person alloc]init];
NSLog(@"%d",[NSObject isKindOfClass:[NSObject class]]);     //1
NSLog(@"%d",[NSObject isMemberOfClass:[NSObject class]]);   //0
NSLog(@"-----");
NSLog(@"%d",[per isKindOfClass:[Person class]]);            //1
NSLog(@"%d",[per isMemberOfClass:[Person class]]);          //1
NSLog(@"-----");
NSLog(@"%d",[per isKindOfClass:[NSObject class]]);          //1
NSLog(@"%d",[per isMemberOfClass:[NSObject class]]);        //0

打印结果： 1
         0
         -----
         1
         1
         -----
         1
         0

@->代表全局变量   %->局部变量   i32->32位4字节的整数   align->对齐
load->读出      store->写入   label->代码标签       call->调用函数
icmp->两个整数值比较,返回布尔值
br->选择分支,根据条件来转向label,不根据条件跳转的话类似goto
alloca->在当前执行的函数的堆栈帧中分配内容,当该函数返回其调用者时,将自动释放内容
详细语法可参考:https://llvm.org/docs/LangRef.html

1.动态创建一个类(参数:父类、类名、额外的内存空间)
Class objc_allocateClassPair(Class superclass, const char * name, size_t extraBytes)
2. 注册一个类(要在类注册之前添加成员变量,因为注册类就相当于添加了类的结构,如果类结构确定了,成员变量就无法添加了)
Void objc_registerClassPair(Class __unsafe_unretained cls)
3. 销毁一个类
Void objc_disposeClassPair(Class cls)
4. 获取isa指向的Class
Class object_getClass(id  obj)
5. 设置isa指向的Class
Class object_setClass(id obj, Class cls)
6. 判断一个OC对象是否为Class
Bool object_isClass(id  obj)
7. 判断一个Class是否为元类
Bool class_isMetaClass(Class cls)
8. 获取父类
Class class_getSuperclass(Class cls)

@interface Person : NSObject
-(void)run;
@end
@implementation Person
-(void)run {
    NSLog(@"----%s",__func__);
}
@end

@interface Car : NSObject
-(void)run;
@end
@implementation Car
-(void)run {
    NSLog(@"----%s",__func__);
}
@end

- (void)viewDidLoad {
    [super viewDidLoad];
    //1. 动态创建一个类(Pair是一对的意思,创建的是一个父类对象和类对象)
    //(父类,类名,额外的内存大小)
    Class newClass = objc_allocateClassPair([NSObject class], "Dog", 0);
    //2. 注册这个类
    objc_registerClassPair(newClass);
    // 创建一个Dog对象
    id dog = [[newClass alloc]init];
    
    Person *person = [[Person alloc]init];
    [person run];
    //4. 获取isa指向的Class(类对象,类对象,元类对象)
    NSLog(@"%p---%p---%p",  
    object_getClass(person),[Person class],object_getClass([Person class]));
    //4. 打印结果:0x107422d78---0x107422d78---0x107422d50
    
    //5. 将person对象的isa指针设置为指向Car类对象;可以实现中途让对象调用其它类的同名的方法
    object_setClass(person, [Car class]);
    [person run];
    //5. 打印结果:-----[Car run]
    
    //6. 判断一个OC对象是否为Class(元类对象也是特殊的类对象)
    NSLog(@"%d---%d---%d",object_isClass(person),  
    object_isClass([person class]),object_isClass(object_getClass([Person class])));
    //6. 打印结果:0---1---1

    //7. 判断一个Class是否为元类(参数必须传Class类型)
    NSLog(@"%d---%d",class_isMetaClass([person class]),  
    class_isMetaClass(object_getClass([Person class])));
    //7. 打印结果:0---1
    
    //8.获取父类(参数必须传Class类型)特例:NSObject元类对象的superClass指向NSOject类对象
    NSLog(@"---%@---%@---%@",class_getSuperclass([person class]),  
          class_getSuperclass([Person class]),
          class_getSuperclass(object_getClass([Person class])));
    //8. 打印结果: ---NSObject---NSObject---NSObject
}

void run(id self,SEL _cmd) {
    NSLog(@"%@---%@",self, NSStringFromSelector(_cmd));
}
- (void)viewDidLoad {
    [super viewDidLoad];
    //1. 动态创建一个类(Pair是一对的意思,创建的是一个父类对象和类对象)
    //(父类,类名,额外的内存大小一般写0即可)
    Class newClass = objc_allocateClassPair([NSObject class], "Dog", 0);
    //添加成员变量(类对象、成员变量名称、成员变量占用字节数、内存对其子节一般写1、成员变量类型的编码@encode)
    //成员变量添加一定要在注册类之前
    class_addIvar(newClass, "_age", 4, 1, @encode(int));
    class_addIvar(newClass, "_weight", 4, 1, @encode(int));
    //添加方法
    class_addMethod(newClass, @selector(run), (IMP)run, "v@:");
    
    //2. 注册这个类(一旦注册完相当于类对象、元类对象的结构就创建好了)
    objc_registerClassPair(newClass);
    
    // 创建一个Dog对象
    id dog = [[newClass alloc]init];
    //这里因为没有对应的getter/setter方法,所以只能通过KVC去设置访问
    [dog setValue:@100 forKey:@"_age"];
    [dog setValue:@200 forKey:@"_weight"];
    NSLog(@"%@---%@",[dog valueForKey:@"_age"],[dog valueForKey:@"_weight"]);
    //打印结果: 100---200
    
    //调用方法
    [dog run];
    //打印结果: <Dog: 0x600000ccc650>---run
    
    //3. 销毁不需要的类
    objc_disposeClassPair(newClass);
}

1. 获取一个实例变量
Ivar class_getInstanceVariable(Class cls, const char * name)
2. 拷贝实例变量列表(最后需要用free释放)
Ivar * class_copyIvarList(Class cls, unsigned int * outCount)
3. 设置和获取成员变量的值
Void object_setIvar(id obj, Ivar ivar, id value)
id object_getIvar(id obj, Ivar ivar)
4. 动态添加成员变量(已经注册的类是不能动态添加成员变量的)
Bool class_addIvar(Class cls,const char * name,size_t size,uint8_t alignment,const char * types)
5. 获取成员变量的相关信息
const char *ivar_getName(Ivar v)
const char *ivar_getTypeEncoding(Ivar v)

@interface Person : NSObject
@property(nonatomic, assign)int age;
@property(nonatomic, copy)NSString *nameStr;
@end

@implementation Person
@end

- (void)viewDidLoad {
    [super viewDidLoad];
    //1. 获取一个实例/成员变量的描述信息
    Ivar ageIvar = class_getInstanceVariable([Person class], "_age");
    NSLog(@"---%s---%s",ivar_getName(ageIvar),ivar_getTypeEncoding(ageIvar));
    //打印结果:---_age---i
    
    //2. 设置和获取成员变量的值
    Person *person = [[Person alloc]init];
    object_setIvar(person, ageIvar, @10);
    NSLog(@"---%d",person.age);
    //打印结果: ----459048901 结果出乎意料了,因为我们的_age成员变量类型是int,  
    但是我们传递的是NSNumber类型,所以这样会出问题,但可以这样设置,首先将int类型转为(void *)指针,  
    指针变量就是存储值的,然后将指针转为id,再通过桥接即可
    object_setIvar(person, ageIvar, (__brigde id)(void *)10);
    
    //正常情况下:
    Ivar nameIvar = class_getInstanceVariable([Person class], "_nameStr");
    object_setIvar(person, nameIvar, @"123");   //设置值
    NSLog(@"---%@---%@",person.nameStr,object_getIvar(person, nameIvar)); //获取值
    //打印结果:---123---123
}

- (void)viewDidLoad {
    [super viewDidLoad];
    //1. 拷贝实例变量列表
    unsigned int count;  //成员变量的数量
    //C语言中:ivars其实就是个数组,指针可以当成数组来用的
    Ivar *ivars = class_copyIvarList([Person class], &count);
    for (int i = 0; i < count; i++) {
        //取出i位置的成员变量
        Ivar iva = ivars[i];
        NSLog(@"---%s---%s",ivar_getName(iva),ivar_getTypeEncoding(iva));
    }
    //打印结果:---_age---i
             ---_nameStr---@"NSString"
    //2. Runtime中用copy、create创建的都需要用free去销毁
    free(ivars);
}

@interface Person : NSObject
@property(nonatomic, assign)int age;
@property(nonatomic, copy)NSString *nameStr;
@property(nonatomic, assign)int weight;
@end

@implementation Person
@end

@interface NSObject (WGJson)
+(instancetype)WG_objectWithJson:(NSDictionary *)json;
@end

@implementation NSObject (WGJson)
+(instancetype)WG_objectWithJson:(NSDictionary *)json {
    id obj = [[self alloc]init];
    unsigned int count;  //成员变量的数量
    Ivar *ivars = class_copyIvarList(self, &count);
    for (int i = 0; i < count; i++) {
        //取出i位置的成员变量
        Ivar iva = ivars[i];
        //C语言的成员变量字符串
        const char *charName = ivar_getName(iva);
        //C语言字符串转为OC语言
        NSMutableString *name = [NSMutableString stringWithUTF8String:charName];
        //将成员变量的_去除
        [name deleteCharactersInRange:NSMakeRange(0, 1)];
        //设置值
        [obj setValue:json[name] forKey:name];
    }
    return obj;
}
@end

1. 获取一个属性
objc_property_t class_getProperty(Class cls, const char * name)
2. 拷贝属性列表(最后需要调用free释放)
objc_property_t * class_copyPropertyList(Class cls, unsigned int * outCount)
3. 动态添加属性
Bool class_addProperty(Class cls, const char *name,  
const objc_property_attribute_t *attributes, unsigned int attributeCount)
4. 动态替换属性
Void class_replaceProperty(Class cls, const char *name,  
const objc_property_attribute_t *attributes, unsigned int attributeCount)
5. 获取属性的一些信息
const char * property_getName(objc_property_t property);
const char * property_getAttributes(objc_property_t property)

1. 获得一个实例方法、类方法
Method class_getInstanceMethod(Class cls, SEL name)
Method class_getClassMethod(Class cls, SEL name)
2. 方法实现相关操作
IMP class_getMethodImplementation(Class cls, SEL name)
IMP method_setImplementation(Method m, IMP imp)
Void method_exchangeImplementations(Method m1, Method m2)
3. 拷贝方法列表(最后需要调用free释放)
Method *class_copyMethodList(Class cls, unsigned int *outCount)
4. 动态添加方法
BOOL class_addMethod(Class cls, SEL name, IMP imp, const char *types)
5. 动态替换方法
IMP class_replaceMethod(Class cls, SEL name, IMP imp, const char *types)
6. 获取方法的相关信息(带copy的需要调用free去释放)
SEL method_getName(Method m)
IMP method_getImplementation(Method m)
const char *method_getTypeEncoding(Method m)
unsigned int method_getNumberOfArguments(Method m)
char *method_copyReturnType(Method m)
char *method_copyArgumentType(Method m, unsigned int index)
7. 选择器相关
const char *sel_getName(SEL sel)
SEL sel_registerName(const char *str)
8. 用block作为方法实现
IMP imp_implementationWithBlock(id block)
id imp_getBlock(IMP anImp)
BOOL imp_removeBlock(IMP anImp)

@interface Person : NSObject
-(void)run;
-(void)test;
@end

@implementation Person
-(void)run {
    NSLog(@"---%s",__func__);
}
-(void)test {
    NSLog(@"---%s",__func__);
}
@end

- (void)viewDidLoad {
    [super viewDidLoad];
    Person *person = [[Person alloc]init];
    //1. 替换方法(若替换对象方法,则第一个参数传递类对象,若是类方法,则传递元类对象)
    class_replaceMethod([Person class], @selector(run), (IMP)myRun, "v@:");
    [person run];
    //打印结果:---my Run
    
    //2. 用block作为方法实现
    class_replaceMethod([Person class], @selector(run), imp_implementationWithBlock(^{
        NSLog(@"this is block task");
    }), "v@:");
    [person run];
    //打印结果: this is block task
}

- (void)viewDidLoad {
    [super viewDidLoad];
    Person *person = [[Person alloc]init];
    //1.交换方法
    Method runMethod = class_getInstanceMethod([Person class], @selector(run));
    Method testMethod = class_getInstanceMethod([Person class], @selector(test));
    //交换的实际上是class_rw_t中method中的IMP,是不会去交换cache缓存列表中的method中的IMP的,因为这个方法
    //一旦调用,就会清空cache缓存中的方法列表
    method_exchangeImplementations(runMethod, testMethod);
    //此时调用run方法调用的应该是test方法
    [person run];
    //打印结果: ----[Person test]
}

- (void)viewDidLoad {
    [super viewDidLoad];
    self.view.backgroundColor = [UIColor whiteColor];
    
    UIButton *btn1 = [[UIButton alloc]initWithFrame:CGRectMake(100, 100, 80, 40)];
    btn1.backgroundColor = [UIColor redColor];
    [btn1 addTarget:self action:@selector(clickRedBtn:) forControlEvents:UIControlEventTouchUpInside];
    
    UIButton *btn2 = [[UIButton alloc]initWithFrame:CGRectMake(100, 200, 80, 40)];
    btn2.backgroundColor = [UIColor yellowColor];
    [btn2 addTarget:self action:@selector(clickYeallowBtn:) forControlEvents:UIControlEventTouchUpInside];
    
    UIButton *btn3 = [[UIButton alloc]initWithFrame:CGRectMake(100, 300, 80, 40)];
    btn3.backgroundColor = [UIColor blueColor];
    [btn3 addTarget:self action:@selector(clickBlueBtn:) forControlEvents:UIControlEventTouchUpInside];
    [self.view addSubview:btn1];
    [self.view addSubview:btn2];
    [self.view addSubview:btn3];
}

-(void)clickRedBtn:(UIButton *)sender {
    NSLog(@"点击了红色按钮");
}
-(void)clickYeallowBtn:(UIButton *)sender {
    NSLog(@"点击了黄色按钮");
}
-(void)clickBlueBtn:(UIButton *)sender {
    NSLog(@"点击了蓝色按钮");
}
@end

//想拦截按钮的点击事件,就要创建UIControl的分类,来拦截到  
方法-(void)sendAction:(SEL)action to:(id)target forEvent:(UIEvent *)event

@interface UIControl (WGHookMethod)
@end

#import "UIControl+WGHookMethod.h"
#import <objc/runtime.h>

@implementation UIControl (WGHookMethod)
+(void)load {
    //系统方法
    Method method1 = class_getInstanceMethod(self, @selector(sendAction:to:forEvent:));
    //自定义方法
    Method method2 = class_getInstanceMethod(self, @selector(WG_sendAction:to:forEvent:));
    //交换方法
    method_exchangeImplementations(method1, method2);
}
-(void)WG_sendAction:(SEL)action to:(id)target forEvent:(UIEvent *)event {
    //拦截到按钮的点击事件后,可以做自己想做的事情,但注意,一旦拦截到按钮点击事件后,按钮本身添加的事件就不会再次响应了
    NSLog(@"self:%@---target:%@---selectorName:%@",self, target, NSStringFromSelector(action));
    //如果我们在拦截到按钮事件后,处理完自己想处理的事,仍然想让按钮继续处理它的事件,那么可以这么做
    //去调用WG_sendAction:to:forEvent:)方法即可,本来应该调用系统方法sendAction:to:forEvent:),  
    但是因为已经方法交换了,所以调用WG_sendAction:to:forEvent:)方法最终才能去执行  
    系统方法sendAction:to:forEvent:),
    [self WG_sendAction:action to:target forEvent:event];
}
@end

- (void)viewDidLoad {
    [super viewDidLoad];
    self.view.backgroundColor = [UIColor whiteColor];
    NSString *name = nil;
    NSMutableArray *muArr = [NSMutableArray array];
    [muArr addObject:@"123"];
    [muArr addObject:name];
}
程序crash: *** Terminating app due to uncaught exception 'NSInvalidArgumentException',  
reason: '*** -[__NSArrayM insertObject:atIndex:]: object cannot be nil'

@interface NSMutableArray (WGHookMutableArray)
@end

#import "NSMutableArray+WGHookMutableArray.h"
#import <objc/runtime.h>

@implementation NSMutableArray (WGHookMutableArray)
+(void)load {
    //这里不能填写self,因为NSString、NSArray、NSDictionary属于类簇,类簇的真实类型是其它类型
    //Method method1 = class_getInstanceMethod(self, @selector(insertObject:atIndex:));
    
    Class cls = NSClassFromString(@"__NSArrayM");
    Method method1 = class_getInstanceMethod(cls, @selector(insertObject:atIndex:));
    Method method2 = class_getInstanceMethod(cls, @selector(WG_insertObject:atIndex:));
    method_exchangeImplementations(method1, method2);
}
-(void)WG_insertObject:(id)anObject atIndex:(NSUInteger)index {
    if (anObject == nil) { //如果添加的元素为nil,直接返回,不需要再去调用添加的方法了
        return;
    }
    //如果不为nil,则可以继续进行添加元素的方法
    [self WG_insertObject:anObject atIndex:index];
}
@end

- (void)viewDidLoad {
    [super viewDidLoad];
    self.view.backgroundColor = [UIColor whiteColor];
    NSString *obj = nil;
    NSMutableDictionary *muDic = [NSMutableDictionary dictionary];
    //下面代码等价于 [muDic setObject:@"zhangSan" forKey:@"name"];
    muDic[@"name"] = @"zhangSan";
    muDic[obj] = @"ceShi";
}
程序crash: *** Terminating app due to uncaught exception 'NSInvalidArgumentException',  
reason: '*** -[__NSDictionaryM setObject:forKeyedSubscript:]: key cannot be nil'

@interface NSMutableDictionary (WGHookMutableDictionary)
@end

#import "NSMutableDictionary+WGHookMutableDictionary.h"
#import <objc/runtime.h>

@implementation NSMutableDictionary (WGHookMutableDictionary)
+(void)load {
    Class cls = NSClassFromString(@"__NSDictionaryM");
    Method method1 = class_getInstanceMethod(cls, @selector(setObject:forKeyedSubscript:));
    Method method2 = class_getInstanceMethod(cls, @selector(WG_setObject:forKeyedSubscript:));
    method_exchangeImplementations(method1, method2);
}
-(void)WG_setObject:(id)obj forKeyedSubscript:(id<NSCopying>)key {
    if (key == nil) {
        return;
    }
    [self WG_setObject:obj forKeyedSubscript:key];
}
@end

    //.h文件
    @interface WGTestModel : NSObject

    @property(nonatomic, strong) NSString *name;
    @property(nonatomic, assign) int age;

    +(void)run;
    -(void)eat;
    -(void)sleepWithTime:(NSTimeInterval)time;

    @end

    //.m文件
    @interface WGTestModel()
    {
        NSString *_parents;
        BOOL _isSex;
    }

    @end

    @implementation WGTestModel

    +(void)run {
        NSLog(@"开始跑步了");
    }
    -(void)eat {
        NSLog(@"开始吃饭了");
    }
    -(void)sleepWithTime:(NSTimeInterval)time {
        NSLog(@"我睡了%f分钟了",time);
    }
    -(void)love {
        NSLog(@"我喜欢你");
    }

    @end

typedef struct objc_object WGTestModel;  
struct objc_object {
    Class _Nonnull isa;         指向自己所属的类
};

实际上cache_t结构体内部本质是一个散列表(哈希表),用来缓存调用过的方法,进而提高访问方法的速度
struct cache_t {
    struct bucket_t *_buckets;     //缓存方法的散列表(也可称为数组)
    mask_t _mask;                  //总槽位-1(实际就是散列表总长度-1)
    mask_t _occupied;              //实际已经使用的槽位(已经占用的散列表长度)
    
    public:
    struct bucket_t *buckets();    //_buckets对外的一个获取函数
    mask_t mask();                 //获取缓存容量_mask
    mask_t occupied();             //获取已经占用的缓存个数_occupied
    void incrementOccupied();      //增加缓存，_occupied自++
    //设置一个新的_buckets
    void setBucketsAndMask(struct bucket_t *newBuckets, mask_t newMask);  
    void initializeToEmpty();      //初始化cache并设置为空

    mask_t capacity();             //获取_buckets的容量
        思考:为什么需要mask()+1? 扩容算法需要：expand()中的扩容算法基本逻辑 
        (最小分配的容量是4，当容量存满3/4时，进行扩容，扩容当前容量的两倍)；  
        这样最小容量4的 1/4就是1，这就是mask() + 1的原因。
        mask_t cache_t::capacity() {
            //当mask()=0时,返回0;当mask()>0时,返回mask()+1
            return mask() ? mask()+1 : 0; 
        }

    bool isConstantEmptyCache();    //判断_buckets是否为空
    bool canBeFreed();

    static size_t bytesForCapacity(uint32_t cap);
    static struct bucket_t * endMarker(struct bucket_t *b, uint32_t cap);

    void expand();  //扩容
    void reallocate(mask_t oldCapacity, mask_t newCapacity);   //重新分配
    //通过 cache_key_t 查找receiver中的 bucket_t *
    struct bucket_t * find(cache_key_t key, id receiver);

    static void bad_cache(id receiver, SEL sel, Class isa) __attribute__((noreturn));
}
    
bucket_t * cache_t::find(cache_key_t k, id receiver){
    assert(k != 0);
    bucket_t *b = buckets();
    mask_t m = mask();
    mask_t begin = cache_hash(k, m);    //找到对应的下标
    mask_t i = begin;
    do {
        if (b[i].key() == 0  ||  b[i].key() == k) {
            return &b[i];
        }
    } while ((i = cache_next(i, m)) != begin); //哈希表会有碰撞问题
    // hack
    Class cls = (Class)((uintptr_t)this - offsetof(objc_class, cache));
    cache_t::bad_cache(receiver, (SEL)k, cls);
}

//发生映射的关系是: key&mask=index,index一定是<=mask的;key就是方法名称,mask就是总槽位-1
//散列表(又叫哈希表)的实现原理是f(key)=index,通过一个函数直接找到对应的index
static inline mask_t cache_hash(cache_key_t key, mask_t mask) {
    return (mask_t)(key & mask);  //取余法计算索引
}

struct bucket_t {
    private:
        cache_key_t _key;    //指方法的名字:@selector()
        IMP _imp;            //函数地址
    public:
        inline cache_key_t key() const { return _key; }
        inline IMP imp() const { return (IMP)_imp; }
        inline void setKey(cache_key_t newKey) { _key = newKey; }
        inline void setImp(IMP newImp) { _imp = newImp; }
        void set(cache_key_t newKey, IMP newImp);
};

    方法
    struct method_t {
        SEL name;              //函数名
        const char *types;     //包含了函数返回值、参数编码的字符串
        IMP imp;               //指向函数的指针(函数地址)
    };
    属性
    struct property_t {
        const char *name;
        const char *attributes;
    };