OC中对象类型的分类
OC中对象类型可以分为如下三类：
- instance 实例对象
- class 类对象
- meta-class 元类对象
我们可以通过代码来获取以上三种类型的实例
- 实例对象
NSObject *objectInstance1 = [[NSObject alloc] init];
NSObject *objectInstance2 = [[NSObject alloc] init];
- 实例对象调用
class方法，得到类对象
Class objectClass1 = [objectInstance1 class];
Class objectClass2 = [objectInstance2 class];
- 通过调用运行时方法
object_getClass，获取元类对象。
#import <objc/runtime.h>
Class objectMetaClass1 = object_getClass(objectClass1);
Class objectMetaClass2 = object_getClass(objectClass2);
注意，元类对象不能通过类对象调用class方法获得！
我们打印一下他们的内存地址
objectInstance1:0x100544cb0
objectInstance2:0x10053fc70
objectClass1:0x7fffad7cb140
objectClass2:0x7fffad7cb140
objectMetaClass1:0x7fffad7cb0f0
objectMetaClass2:0x7fffad7cb0f0
能够看出，只有两个实例对象的内存地址不同，类和元类内存地址都是相同的。
原因就是他们各自存储的内容和用途不同。
instance、class和meta-class内存结构和用途
首先来看它们各自在内存中存储信息
instance
- isa指针
- 其他成员变量
class
- isa指针
- superclass指针
- 成员变量描述信息
- 属性信息
- 对象方法信息
- 协议信息
meta-class
- isa指针
- superclass指针
- 类方法信息
注意：
class和meta-class是同一种类型，内存结构是完全一样的，只是其中存储的信息和用途不同。
接下来看一下isa指针和superclass指针各自的作用
isa指针作用
- instance 实例对象的isa指针指向类对象
- class 类对象的isa指针指向元类对象
- meta-class 元类对象的isa指针指向基类的元类对象
superclass指针作用
- class 类对象的superclass指针指向父类的类对象。如果没有父类,指向nil
- meta-class 元类对象的superclass指向父类的元类对象
- 基类的元类对象的superlcass指针指向基类的class对象
下图是一张经典图，以上结论就是对下图的总结
方法的调用过程
通过上图我们就能知道，当一个方法被调用时，整个的方法调用过程。
定义Person类继承自NSObject，并定义一个类方法和一个实例方法
@interface Person : NSObject
- (void)personInstanceMethod;
+ (void)personClassMethod;
@end
@implementation Person
- (void)personInstanceMethod {
NSLog(@"personInstanceMethod");
}
+ (void)personClassMethod {
NSLog(@"personClassMethod");
}
@end
定义Student类继承自Person，同样定义一个类方法和一个实例方法
@interface Student : Person
- (void)studentInstanceMethod;
+ (void)studentClassMethod;
@end
@implementation Student
- (void)studentInstanceMethod {
NSLog(@"studentInstanceMethod");
}
+ (void)studentClassMethod {
NSLog(@"studentClassMethod");
}
@end
Person调用实例方法
Person *person = [[Person alloc] init];
[person personInstanceMethod];
调用过程：
-> 实例对象person通过isa指针找到Person类对象
-> 从Person类对象中保存的实例方法中找到personInstanceMethod方法进行调用
Person调用类方法
[Person personClassMethod];
调用过程：
-> 类对象Person通过isa指针找到Person的元类对象
-> 从Person元类对象中保存的类方法中找到personClassMethod方法进行调用
Student调用父类Person的实例方法
Student *student = [[Student alloc] init];
[student personInstanceMethod];
调用过程：
-> 实例对象student通过isa指针找到Student类对象
-> 发现Student类对象保存的实例方法中，没有personInstanceMethod方法实现
-> 通过Student类对象中superclass找到Person类对象
-> 从Person类对象中保存的实例方法中，找到personInstanceMethod方法进行调用
Student调用父类Person的类方法
[Student personClassMethod];
调用过程：
-> 类对象Student通过isa指针找到Student元类对象
-> 发现Student元类对象中保存的类方法中，没有personClassMethod方法实现
-> 通过Student元类对象中superclass找到Person元类对象
-> 从Person元类对象中保存的类方法中，找到personClassMethod方法进行调用
一个特殊的方法调用
为NSObject实现一个分类，定义一个实例方法test。
@interface NSObject (Test)
@end
@implementation NSObject (Test)
- (void)test {
NSLog(@"%s --- %@", __func__, self);
}
@end
定义一个Person类继承自NSObject，定义一个类方法test，不给出方法的实现。
@interface Person : NSObject
+ (void)test;
@end
@implementation Person
@end
按照面向对象的经验，Person调用类方法test，会抛出找不到方法实现的异常。
[Person test];
实际运行发现，并没有抛出异常，控制台打印如下。
-[NSObject(Test) test] --- Person
我们来分析一下整个调用过程是怎么样的。
-> Person类对象通过isa指针找到Person元类对象
-> 发现Person元类对象中保存的类方法中，没有test方法实现
-> Person元类对象通过superclass找到基类（NSObject）的元类对象
-> 发现基类的元类对象中保存的类方法中，没有test方法实现
-> 基类的元类对象再通过superclass指针，找到基类的类对象
-> 在基类的类对象中发现test方法的实现，调用test方法
代码验证
下面我们来对上面的描述使用代码的方式进行验证。
OC的类并不提供给我们直接访问isa指针和superclass指针的方法，既然我们已经知道类对象的底层实现，我们就可以自己写一个结构体，通过桥接的方式，将OC的类对象转换成我们自己实现的类对象结构体。
// 自定义类结构体
struct dpl_objc_class {
Class isa;
Class superclass;
};
Person *person = [[Person alloc] init];
Student *student = [[Student alloc] init];
Class personClass = [person class];
Class personMetaClass = object_getClass(personClass);
Class studentClass = [student class];
Class studentMetaClass = object_getClass(studentClass);
// 转换成自定义class的结构体类型
struct dpl_objc_class *myPersonClass = (__bridge struct dpl_objc_class *)(personClass);
struct dpl_objc_class *myPersonMetaClass = (__bridge struct dpl_objc_class *)(personMetaClass);
struct dpl_objc_class *myStudentClass = (__bridge struct dpl_objc_class *)([Student class]);
struct dpl_objc_class *myStudentMetaClass = (__bridge struct dpl_objc_class *)(studentMetaClass);
NSLog(@"断点需要 ---");
在断点需要的位置打个断点，在控制台来查看我们需要的信息。
isa指针
(lldb) p/x (long)person->isa
(long) $0 = 0x001d8001000014b1
(lldb) p/x personClass
(dpl_objc_class *) $1 = 0x00000001000014b0
(lldb) p/x personClass->isa
(Class) $2 = 0x001d800100001489
(lldb) p/x personMetaClass
(dpl_objc_class *) $3 = 0x0000000100001488
按照之前所说，实例对象的isa指针指向类对象，类对象的isa指向元类对象，但是通过打印我们发现二者并不相同。
这个原因就在于，在新版runtime源码中，实例对象isa指针的值需要对ISA_MASK做位运算之后才能得到类对象的地址，同理类对象的isa指针也是一样。
ISA_MASK在runtime源码中的定义如下：
# if __arm64__
# define ISA_MASK 0x0000000ffffffff8ULL
# elif __x86_64__
# define ISA_MASK 0x00007ffffffffff8ULL
因为我们的实例是运行在模拟器上，所以实例对象isa指针需要&上0x00007ffffffffff8才能得到最终的类对象的地址，类对象的isa指针也是同样。
验证结果如下
(lldb) p/x (long)person->isa
(long) $0 = 0x001d8001000014b1
(lldb) p/x personClass
(dpl_objc_class *) $1 = 0x00000001000014b0
(lldb) p/x 0x001d8001000014b1 & 0x00007ffffffffff8
(long) $2 = 0x00000001000014b0
(lldb) p/x personClass->isa
(Class) $3 = 0x001d800100001489
(lldb) p/x personMetaClass
(dpl_objc_class *) $4 = 0x0000000100001488
(lldb) p/x 0x001d800100001489 & 0x00007ffffffffff8
(long) $5 = 0x0000000100001488
superclass指针
(lldb) p/x studentClass->superclass
(Class) $0 = 0x00000001000014b0 Person
(lldb) p/x personClass
(dpl_objc_class *) $1 = 0x00000001000014b0
(lldb) p/x studentMetaClass->superclass
(Class) $2 = 0x0000000100001488
(lldb) p/x personMetaClass
(dpl_objc_class *) $3 = 0x0000000100001488
类对象superclass指针直接指向父类的类对象，类对象的元类对象superclass指针直接指向父类的元类对象。
最终结论
- 实例对象 isa & ISA_MASK -> 类对象
- 类对象 isa & ISA_MASK -> 元类对象
- 类对象的superclass指针直接指向父类对象
- 元类对象的superclass指针直接指向父类元类对象
