我们上文提到过 class_data_bits_t，说到它与方法相关~
类结构
struct objc_class : objc_object {
// Class ISA; //指向类的指针
Class superclass; //指向当前类的父类
cache_t cache; // formerly cache pointer and vtable
class_data_bits_t bits; // class_rw_t * plus custom rr/alloc flags
}
cache_t cache; //用于缓存指针和 vtable，加速方法的调用
class_data_bits_t bits; // 存储类的方法、属性、遵循的协议等信息的地方
class_data_bits_t的结构体，其中只含有一个 64位的 bits 用于存储与类有关的信息。我们看到注释，class_data_bits_t 相当于 class_rw_t 指针加上 rr/alloc 的标志。
class_data_bits_t 结构体的方法，用于返回class_rw_t 指针（）
class_rw_t* data() {
return (class_rw_t *)(bits & FAST_DATA_MASK);
}
#define FAST_DATA_MASK 0x00007ffffffffff8UL
（这个掩码 111 ffffffffff 1000 3-47为1，前面说过X86-64，地址的有效位是47位，后三位为0对齐）
执行 class_data_bits_t 结构体中的 data() 方法或者调用 objc_class 中的 data() 方法会返回同一个 class_rw_t * 指针，因为 objc_class 中的方法只是对 class_data_bits_t 中对应方法的封装。
Objc 类中的属性、方法还有遵循的协议等信息都保存在 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;
};
其中还有一个指向常量的指针 ro，其中存储了当前类在编译期就已经确定的属性、方法以及遵循的协议。
struct class_ro_t {
};
类在内存中的位置是编译期就确定的，类定义的实例方法，会被添加到class_ro_t 的baseMethodList
类的结构中的class_data_bits_t 中的3~47位/ class_data_bits_t.data()是一个 class_ro_t * 指针。然后在加载 Objc 运行时的过程中，在 realizeClass 方法中：
const class_ro_t *ro = (const class_ro_t *)cls->data();
class_rw_t *rw = (class_rw_t *)calloc(sizeof(class_rw_t), 1);
rw->ro = ro;
rw->flags = RW_REALIZED|RW_REALIZING;
cls->setData(rw);
使用class_ro_t *，初始化一个 class_rw_t 结构体（设置结构体 ro 的值以及 flag），最后设置为正确的 data
realizeClass，该方法的主要作用是对类进行第一次初始化，其中包括：
分配可读写数据空间
返回真正的类结构
在这段代码运行之后，类的只读指针 class_ro_t 以及可读写指针 class_rw_t 都被正确的设置了。但是到这里，其 class_rw_t 中的方法，属性以及协议列表均为空，realizeClass结尾调用 methodizeClass 进行设置
static void methodizeClass(Class cls)
{
bool isMeta = cls->isMetaClass();
auto rw = cls->data();
auto ro = rw->ro;
// Methodizing for the first time
// Install methods and properties that the class implements itself.
method_list_t *list = ro->baseMethods();
if (list) {
prepareMethodLists(cls, &list, 1, YES, isBundleClass(cls));
rw->methods.attachLists(&list, 1);
}
property_list_t *proplist = ro->baseProperties;
if (proplist) {
rw->properties.attachLists(&proplist, 1);
}
protocol_list_t *protolist = ro->baseProtocols;
if (protolist) {
rw->protocols.attachLists(&protolist, 1);
}
// Attach categories.
category_list *cats = unattachedCategoriesForClass(cls, true /*realizing*/);
attachCategories(cls, cats, false /*don't flush caches*/);
if (cats) free(cats);
}
类自己实现的方法（包括分类）、属性和遵循的协议加载到 methods、 properties 和 protocols 列表中。例如，将 class_ro_t baseMethods 中的方法添加到 class_rw_t methods 数组之后，我们访问 methods 才会获取当前类的实例方法。
说了这么多，到现在我们可以简单看一下方法的结构，与类和对象一样，方法在内存中也是一个结构体。
struct method_t {
SEL name;
const char *types;
IMP imp;
};
其中包含方法名，类型（类型编码）还有方法的实现指针 IMP：
总结
类的方法、属性以及协议在编译期间存放到了“错误”的位置，直到 realizeClass 执行之后，才放到了 class_rw_t 指向的只读区域 class_ro_t，这样我们即可以在运行时为 class_rw_t 添加方法，也不会影响类的只读结构。在 class_ro_t 中的属性在运行期间就不能改变了，再添加方法时，会修改 class_rw_t 中的 methods 列表，而不是 class_ro_t 中的 baseMethods
objc_class 结构体中还有一个cache_t cache 的成员
struct cache_t {
struct bucket_t *_buckets;
mask_t _mask; // 分配用来缓存bucket的总数
mask_t _occupied; // 当前实际占用的缓存bucket的个数
}
struct bucket_t {
private:
cache_key_t _key;
IMP _imp; // 函数指针，指向了一个方法的具体实现
}
cache_t中的bucket_t *_buckets其实就是一个散列表，用来存储Method的链表。
Cache的作用已经说过。主要是为了优化方法调用的性能，当调用方法时，优先在isa对应类的Cache查找，如果没有找到，再到methodLists查找。
