Paste_Image.png

通过这张图描述了实例对象，类，元类之间的关系；
图中实线是 super_class 指针，虚线是 isa 指针。
从图中看出：

• 当发送一个实例方法的消息时，isa 指针会在这个类的实例方法列表中查找；
• 当发送一个类方法的消息时，isa 指针会在这个类的 meta-class 的方法列表中查找，meta-class 之所以重要，是因为它存储着一个类的所有类方法。
• 每个类都会有一个单独的 meta-class，因为每个类的类方法基本不可能完全相同。

image

[super class] 与 [self class] 的区别

@implementation Student

- (instancetype)init {
    self = [super init];
    if (self) {
        NSLog(@"%@", NSStringFromClass([self class]));
        NSLog(@"%@", NSStringFromClass([super class]));
    }
    return self;
}
@end

借助 clang 编译器，会被编译器转化为：

static instancetype _I_Student_init(Student * self, SEL _cmd) {
 self = ((Student *(*)(__rw_objc_super *, SEL))(void *)objc_msgSendSuper)((__rw_objc_super){(id)self, (id)class_getSuperclass(objc_getClass("Student"))}, sel_registerName("init"));
 if (self) {
  id obj1 = ((Class (*)(id, SEL))(void *)objc_msgSend)((id)self, sel_registerName("class"));
  id obj2 = ((Class (*)(__rw_objc_super *, SEL))(void *)objc_msgSendSuper)((__rw_objc_super){(id)self, (id)class_getSuperclass(objc_getClass("Student"))}, sel_registerName("class"));
  NSLog((NSString *)&__NSConstantStringImpl__var_folders_hj_pwgsq9614nb0vq4zd315tcx80000gn_T_Student_e7cbc1_mi_0,obj1);
  NSLog((NSString *)&__NSConstantStringImpl__var_folders_hj_pwgsq9614nb0vq4zd315tcx80000gn_T_Student_e7cbc1_mi_1,obj2);
 }
 return self;
}

由此可见：
[self class] 编译器最终转成 objc_msgSend(self,@selector(class))，消息的接收者是当前所在类的实例对象，这个时候就会去 self 所在类 Student 去查找 class 方法，如果当前类 Student 没有 class 会向 Student 父类 Person 类找 class 方法，如果 Person 类也没有找到 class 方法，最终会找到最顶级父类 NSObject 的 class 方法，并调用了 object_getClass(self)，由于消息接收者是 self 当前类实例对象，所以最终 [self class] 输出 Student；

[super class] 最终编译器转化成了 objc_msgSendSuper(struct objc_super *,SEL)

OBJC_EXPORT void objc_msgSendSuper(void /* struct objc_super *super, SEL op, ... */ )

/// Specifies the superclass of an instance. 
struct objc_super {
    /// Specifies an instance of a class.
    __unsafe_unretained id receiver;

    /// Specifies the particular superclass of the instance to message. 
#if !defined(__cplusplus)  &&  !__OBJC2__
    /* For compatibility with old objc-runtime.h header */
    __unsafe_unretained Class class;
#else
    __unsafe_unretained Class super_class;
#endif
    /* super_class is the first class to search */
};

objc_super 是一个结构体，结构体里面有两个指针，一个是接收消息的 receiver，另一个是指向当前类的父类 super_class，通过 super_class 指针从父类的方法列表开始查找 selector，由于消息接收者还是当前类的实例对象 self，那么 objc_msgSendSuper 最后就转变成，

objc_msgSend(objc_super->receiver, @selector(class))
- (Class)class {
    return object_getClass(self);
}

由于找到了父类 NSObject 里面的 class 方法的 IMP，又因为传入的入参 objc_super->receiver = self。self 就是 Student，调用 class，所以父类的方法 class 执行 IMP 之后，输出还是 Student，最后输出两个都一样，都是输出 Student。

isMemberOfClass 和 isKindOfClass 的区别

+ (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;
}

isKindOfClass：是判断方法调用者对象的类是否等于传入的这个类或者其子类；
isMemberOfClass：object_getClass() 取得的是对象的 isa 指针指向的对象，也就是判断传入的类对象的元类对象是否与传入的这个对象相等，所以这个 cls 应该是元类对象才有可能相等，是检测方法调用者对象的类是否等于传入的这个类；

objc_getClass 和 object_getClass 的区别

Class _Nullable objc_getClass(const char * _Nonnull name)
const char * _Nonnull object_getClassName(id _Nullable obj)

• objc_getClass
objc_getClass 参数是类名的字符串，返回的就是这个类的类对象；

• object_getClass
object_getClass 参数是 id 类型，它返回的是这个 id 的 isa 指针所指向的 Class，如果是 instance 对象，返回 class 对象；如果是 class 对象，返回 meta-class 对象；如果是 meta-class 对象，返回 NSObject 的 meta-class 对象；

NSObject

@interface NSObject <NSObject> {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wobjc-interface-ivars"
    Class isa  OBJC_ISA_AVAILABILITY;
#pragma clang diagnostic pop
}
typedef struct objc_class *Class;

万物皆对象，通过源码分析，NSObject 里面包含一个 objc_class 结构体类型的 isa 指针；

isa_t

// Class、uintptr_t、结构体公用一块内存空间，isa_t 是一个 Class、同时是一个 64 位地址 bits、是一个 64 位结构体。
union isa_t 
{
    isa_t() { }
    isa_t(uintptr_t value) : bits(value) { }

    Class cls;
    uintptr_t bits;

#if SUPPORT_PACKED_ISA

# if __arm64__
#   define ISA_MASK        0x0000000ffffffff8ULL
#   define ISA_MAGIC_MASK  0x000003f000000001ULL
#   define ISA_MAGIC_VALUE 0x000001a000000001ULL
    struct {
        uintptr_t nonpointer        : 1;
        uintptr_t has_assoc         : 1;
        uintptr_t has_cxx_dtor      : 1;
        uintptr_t shiftcls          : 33; // MACH_VM_MAX_ADDRESS 0x1000000000
        uintptr_t magic             : 6;
        uintptr_t weakly_referenced : 1;
        uintptr_t deallocating      : 1;
        uintptr_t has_sidetable_rc  : 1;
        uintptr_t extra_rc          : 19;
#       define RC_ONE   (1ULL<<45)
#       define RC_HALF  (1ULL<<18)
    };

# elif __x86_64__
#   define ISA_MASK        0x00007ffffffffff8ULL
#   define ISA_MAGIC_MASK  0x001f800000000001ULL
#   define ISA_MAGIC_VALUE 0x001d800000000001ULL
    struct {
        uintptr_t nonpointer        : 1;
        uintptr_t has_assoc         : 1;
        uintptr_t has_cxx_dtor      : 1;
        uintptr_t shiftcls          : 44; // MACH_VM_MAX_ADDRESS 0x7fffffe00000
        uintptr_t magic             : 6;
        uintptr_t weakly_referenced : 1;
        uintptr_t deallocating      : 1;
        uintptr_t has_sidetable_rc  : 1;
        uintptr_t extra_rc          : 8;
#       define RC_ONE   (1ULL<<56)
#       define RC_HALF  (1ULL<<7)
    };

# else
#   error unknown architecture for packed isa
# endif

// SUPPORT_PACKED_ISA
#endif

};

image

isa_t 是一个 union 类型的结构体，其中的 isa_t、cls、 bits 还有结构体共用同一块地址空间，而 isa 总共会占据 64 位的内存空间。
词语解析：
nonpointer：代表是否开启 isa 指针优化。nonpointer = 1，代表开启 isa 指针优化Tagged Pointer。
has_assoc：是否有设置过关联对象，如果没有，释放时会更快。
has_cxx_dtor：是否有 C++ 或者 Objc 的析构函数，如果没有，释放时会更快。
shiftcls：类指针，存储着 Class、Meta-Class 对象的内存地址信息，arm64 架构中有 33 位可以存储类指针，在 __x86_64__ 架构中有 44 位可以存储类指针。
magic：判断对象是否初始化完成。
weakly_referenced：是否有被弱引用指向过，如果没有，释放时会更快。
deallocating：对象是否正在释放。
has_sidetable_rc：判断该对象的引用计数是否过大，如果过大则需要其他哈希表来进行存储。
extra_rc：存放该对象的引用计数值 -1 后的结果。对象的引用计数超过 1，会存在这个这个里面，如果引用计数为 10，extra_rc 的值就为 9。

注：本文提到的 nonpointer 等同于 indexed，在 objc 最新源码已改名为 nonpointer。

isa 的初始化

inline void 
objc_object::initInstanceIsa(Class cls, bool hasCxxDtor)
{
    assert(!cls->instancesRequireRawIsa());
    assert(hasCxxDtor == cls->hasCxxDtor());

    initIsa(cls, true, hasCxxDtor);
}

inline void 
objc_object::initIsa(Class cls, bool nonpointer, bool hasCxxDtor) 
{ 
    assert(!isTaggedPointer()); 
    
    if (!nonpointer) {
        isa.cls = cls;
    } else {
        assert(!DisableNonpointerIsa);
        assert(!cls->instancesRequireRawIsa());

        isa_t newisa(0);

#if SUPPORT_INDEXED_ISA
        assert(cls->classArrayIndex() > 0);
        newisa.bits = ISA_INDEX_MAGIC_VALUE;
        // isa.magic is part of ISA_MAGIC_VALUE
        // isa.nonpointer is part of ISA_MAGIC_VALUE
        newisa.has_cxx_dtor = hasCxxDtor;
        newisa.indexcls = (uintptr_t)cls->classArrayIndex();
#else
        newisa.bits = ISA_MAGIC_VALUE;
        // isa.magic is part of ISA_MAGIC_VALUE
        // isa.nonpointer is part of ISA_MAGIC_VALUE
        newisa.has_cxx_dtor = hasCxxDtor;
        newisa.shiftcls = (uintptr_t)cls >> 3;
#endif
        isa = newisa;
    }
}

可以看到 nonpointer 是固定传 true，因为现在 iOS 已经迁移到 64 位系统了，也就是目前逻辑基本直走 else 分支，然后是 SUPPORT_INDEXED_ISA：

#if __ARM_ARCH_7K__ >= 2
#   define SUPPORT_INDEXED_ISA 1
#else
#   define SUPPORT_INDEXED_ISA 0
#endif

SUPPORT_INDEXED_ISA = 1 是另外一种优化，用 isa 内 indexcls 存储着类在类列表内的索引，用于 apple watch 设备。

newisa.bits = ISA_MAGIC_VALUE

这里给 bits 赋初始，ISA_MAGIC_VALUE = 0x001d800000000001ULL，我们把它转化成二进制：

ISA_MAGIC_VALUE = 0x000001a000000001ULL转换成二进制是11010000000000000000000000000000000000001

image

isa.shiftcls = (uintptr_t)cls >> 3

将当前地址右移三位的主要原因是用于将 Class 指针中无用的后三位清楚减小内存的消耗，因为类的指针要按照字节（8 bits）对齐内存，其指针后三位都是没有意义的 0。

ISA_MASK 分别是通过掩码的方式获取 isa 的类指针。

inline Class 
objc_object::ISA() 
{
    assert(!isTaggedPointer()); 
    return (Class)(isa.bits & ISA_MASK);
}

Tagged Pointer

在2013年9月苹果提出了 Tagged Pointer 的概念，对于64位程序，引入 Tagged Pointer 后，相关逻辑能减少一半的内存占用，以及 3 倍的访问速度提升，100 倍的创建、销毁速度提升。
例如，要存储一个 NSNumber 对象，其值是一个整数。正常情况下，如果这个整数只是一个 NSInteger 的普通变量，那么它所占用的内存是与 CPU 的位数有关，在 32 位 CPU 下占 4 个字节，在 64 位 CPU 下是占 8 个字节的。而指针类型的大小通常也是与 CPU 位数相关，一个指针所占用的内存在 32 位 CPU 下为 4 个字节，在 64 位 CPU 下也是 8 个字节。如果没有Tagged Pointer对象，从 32 位机器迁移到 64 位机器中后，虽然逻辑没有任何变化，但这种 NSNumber、NSDate 一类的对象所占用的内存会翻倍。

image

为了改进上面提到的内存占用和效率问题，苹果提出了Tagged Pointer对象。由于 NSNumber、NSDate 一类的变量本身的值需要占用的内存大小常常不需要 8 个字节，拿整数来说，4 个字节所能表示的有符号整数就可以达到 20 多亿（注：2^31=2147483648，另外 1 位作为符号位)，对于绝大多数情况都是可以处理的。

所以我们可以将一个对象的指针拆成两部分，一部分直接保存数据，另一部分作为特殊标记，表示这是一个特别的指针，不指向任何一个地址。所以，引入了Tagged Pointer对象之后，64 位 CPU 下 NSNumber 的内存图变成了以下这样：

image

运行之后，我们得到的结果如下，可以看到，除去最后的数字最末尾的 2 以及最开头的 0xb，其它数字刚好表示了相应 NSNumber 的值。

2017-08-26 19:58:08.232 TaggedPointer[87063:1919845] number1 Tagged Pointer is 0xb000000000000072
2017-08-26 19:58:08.232 TaggedPointer[87063:1919845] number2 Tagged Pointer is 0xb0000000000006f2
2017-08-26 19:58:08.232 TaggedPointer[87063:1919845] number3 Tagged Pointer is 0xb0000000000022b2

尝试放一个 8 字节的长的整数到NSNumber实例中，对于这样的实例，由于Tagged Pointer无法将其按上面的压缩方式来保存，那么应该就会以普通对象的方式来保存，我们的实验代码如下：

2017-08-26 20:00:11.833 TaggedPointer[87122:1921799] number1 Tagged Pointer is 0xb000000000000072
2017-08-26 20:00:11.833 TaggedPointer[87122:1921799] number2 Tagged Pointer is 0xb0000000000006f2
2017-08-26 20:00:11.833 TaggedPointer[87122:1921799] number3 Tagged Pointer is 0xb0000000000022b2
2017-08-26 20:00:11.833 TaggedPointer[87122:1921799] bigNumber Tagged Pointer is 0x6100000251a0

运行之后，结果如下，验证了我们的猜测，bigNumber的地址更像是一个普通的指针地址，和它本身的值看不出任何关系。

可见，当 8 字节可以承载用于表示的数值时，系统就会以Tagged Pointer的方式生成指针，如果 8 字节承载不了时，则又用以前的方式来生成普通的指针。

苹果引入Tagged Pointer，不但减少了 64 位机器下程序的内存占用，还提高了运行效率。完美地解决了小内存对象在存储和访问效率上的问题。

objc_class

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

    class_rw_t *data() { 
        return bits.data();
    }
}

class_rw_t* data() {
    return (class_rw_t *)(bits & FAST_DATA_MASK);
}

通过源码分析：
objc_class 里面包含一个 objc_class 结构体类型的 superclass 指针，可以通过 superclass 指针，查找到父类；
cache_t 结构体的 cache 指针，cache 主要用于方法性能优化，对使用过的方法进行缓存，便于第二次查找；
class_data_bits_t 结构体的 bits 指针，只含有一个 64 位的 bits 用于存储与类有关的信息；

在 objc_class 结构体中的注释写到 class_data_bits_t 相当于 class_rw_t 指针加上 rr/alloc 的标志。

通过将 bits 与 FAST_DATA_MASK 进行位运算，返回 class_rw_t * 指针，其中 Objc 的类的属性、方法、以及遵循的协议都放在 class_rw_t 结构体中；

cache_t

struct cache_t {
    struct bucket_t *_buckets;
    mask_t _mask;
    mask_t _occupied;

public:
    struct bucket_t *buckets();
    mask_t mask();
    mask_t occupied();
    void incrementOccupied();
    void setBucketsAndMask(struct bucket_t *newBuckets, mask_t newMask);
    void initializeToEmpty();

    mask_t capacity();
    bool isConstantEmptyCache();
    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);
    struct bucket_t * find(cache_key_t key, id receiver);

    static void bad_cache(id receiver, SEL sel, Class isa) __attribute__((noreturn));
};

struct bucket_t {
private:
    cache_key_t _key;
    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);
};

cache 主要是为了优化方法调用的性能，一个接收者对象接收到一个消息时，它会根据 isa 指针去查找能够响应这个消息的对象。在实际使用中，这个对象只有一部分方法是常用的，很多方法其实很少用或者根本用不上。这种情况下，如果每次消息来时，我们都是 methodLists 中遍历一遍，性能势必很差。这时，cache 就派上用场了。在我们每次调用过一个方法后，这个方法就会被缓存到 cache 列表中，下次调用的时候就会优先去 cache 中查找，才去 methodLists 中查找方法。

从源码中可以看出，
_buckets 指针是一个指向 bucket_t 结构体的哈希表，_buckets 哈希表里面包含多个 bucket_t，每个 bucket_t 里面存放着 SEL 和 imp 函数的内存地址的对应关系；
_mask 是一个 uint32_t 的指针，表示整个 _buckets 哈希表的长度；
_occupied 也是一个 uint32_t 的指针，在 _buckets 哈希表中已经缓存的方法数量；

在 bucket_t 结构体中，_key 是一个 unsigned long 的指针，其实是一个被 hash 化的一串数值，就是方法的 sel，也就是方法名；_imp 指针保持着对应的函数地址；

cache_t 如何缓存 sel

void cache_fill(Class cls, SEL sel, IMP imp, id receiver)
{
    cache_fill_nolock(cls, sel, imp, receiver);
}

static void cache_fill_nolock(Class cls, SEL sel, IMP imp, id receiver)
{
    // Never cache before +initialize is done
    // 系统要求在类初始化完成之前，不能进行方法返回，因此如果类没有完成初始化就 return
    if (!cls->isInitialized()) return;

    // Make sure the entry wasn't added to the cache by some other thread 
    // before we grabbed the cacheUpdateLock.
    // 因为有可能其他线程已经把该方法缓存起来，如果缓存中已经缓存过了，不用再缓存，直接 return
    if (cache_getImp(cls, sel)) return;

    cache_t *cache = getCache(cls);
    cache_key_t key = getKey(sel);

    // Use the cache as-is if it is less than 3/4 full
    mask_t newOccupied = cache->occupied() + 1;
    mask_t capacity = cache->capacity();
    if (cache->isConstantEmptyCache()) {
        // Cache is read-only. Replace it.
        cache->reallocate(capacity, capacity ?: INIT_CACHE_SIZE);
    }
    else if (newOccupied <= capacity / 4 * 3) {
        // Cache is less than 3/4 full. Use it as-is.
    }
    else {
        // Cache is too full. Expand it.
        cache->expand();
    }

    // Scan for the first unused slot and insert there.
    // There is guaranteed to be an empty slot because the 
    // minimum size is 4 and we resized at 3/4 full.
    bucket_t *bucket = cache->find(key, receiver);
    if (bucket->key() == 0) cache->incrementOccupied();
    bucket->set(key, imp);
}

void cache_t::expand()
{
    cacheUpdateLock.assertLocked();
    
    uint32_t oldCapacity = capacity();
    uint32_t newCapacity = oldCapacity ? oldCapacity*2 : INIT_CACHE_SIZE;

    if ((uint32_t)(mask_t)newCapacity != newCapacity) {
        // mask overflow - can't grow further
        // fixme this wastes one bit of mask
        newCapacity = oldCapacity;
    }

    reallocate(oldCapacity, newCapacity);
}

void cache_t::reallocate(mask_t oldCapacity, mask_t newCapacity)
{
    bool freeOld = canBeFreed();

    bucket_t *oldBuckets = buckets();
    bucket_t *newBuckets = allocateBuckets(newCapacity);

    // Cache's old contents are not propagated. 
    // This is thought to save cache memory at the cost of extra cache fills.
    // fixme re-measure this

    assert(newCapacity > 0);
    assert((uintptr_t)(mask_t)(newCapacity-1) == newCapacity-1);

    setBucketsAndMask(newBuckets, newCapacity - 1);
    
    if (freeOld) {
        cache_collect_free(oldBuckets, oldCapacity);
        cache_collect(false);
    }
}

• 先看缓存中是否已经存在了该方法，如果已经存在，直接return掉；
• 如果缓存是只读的，则需要重新申请缓存空间；
• 如果存入缓存后的大小小于当前大小的 3/4，则当前缓存大小还可以使用，无需扩容；
• 如果缓存太满，需要扩容，扩容为原来大小的 2 倍，重新申请缓存空间；

enum {
    INIT_CACHE_SIZE_LOG2 = 2,
    INIT_CACHE_SIZE      = (1 << INIT_CACHE_SIZE_LOG2)
};

如果是首次调用这个函数，会使用一个初始容量值 INIT_CACHE_SIZE 来设定缓存容量；从 INIT_CACHE_SIZE 的定义显示它的值是 4，也就是说苹果给 cache_t 设定的初始容量是 4。

• 重新设置哈希表的长度 _mask = newCapacity-1，然后将旧内存释放掉，清空缓存；
• 当通过 find() 方法返回的 bucket->key() == 0，就说明该位置上是空的，没有缓存过方法，因此可以进行插入操作 bucket->set(key, imp)，也就是将方法缓存到这个位置上。

注意：传入 cls 得到缓存列表，如果是 instance 对象，返回 class 对象；如果是 class 对象，返回 meta-class 对象；如果是 meta-class 对象，返回 NSObject 的 meta-class 对象；

cache_t 如何查找 sel

bucket_t * cache_t::find(cache_key_t k, id receiver)
{
    assert(k != 0);

    bucket_t *b = buckets();
    mask_t m = mask();
    // 通过 cache_hash() 计算出 key 值 k 对应的 index 值 begin，用来记录查询起始索引；
    mask_t begin = cache_hash(k, m);
    // begin 赋值给 i，用于切换索引
    mask_t i = begin;
    do {
        // 用这个 i 从哈希表取值，如果取出来的 bucket_t 的 key = k，则查询成功，返回该 bucket_t。
        // 如果 key = 0，说明在索引 i 的位置上还没有缓存过方法，同样需要返回该 bucket_t，用于中止缓存查询。
        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);
}

static inline mask_t cache_next(mask_t i, mask_t mask) {
    return (i+1) & mask;
}

static inline mask_t cache_next(mask_t i, mask_t mask) {
    return i ? i-1 : mask;
}

cache_t 如何查找 sel，本质上就是根据 key 如何查找 index 的过程；
根据 key 计算出 index 值的这个算法称作哈希算法，尽可能减少不同的 key 得出相同 index 的情况出现，这种情况被称作哈希碰撞，同时还要保证得出的 index 值在合理的范围。index 越大，意味着对应的哈希表的长度越长，这是需要占用实际物理空间的，而内存是有限的。
哈希表是一种通过牺牲一定空间，来换取时间效率的设计思想。

SEL

objc_msgSend函数第二个参数类型为SEL，它是selector在Objc中的表示类型（Swift中是Selector类）。selector是方法选择器，可以理解为区分方法的id，而这个id的数据结构是SEL，即表示一个方法的selector的指针。

Paste_Image.png

• 方法的selector用于表示运行时方法的名字，Objective-C在编译时，会依据每一个方法的名字、参数序列，生成一个唯一的整型标识(int类型的地址)，这个标识就是SEL。
• 在Objective-C中，只要方法名相同，那么方法的SEL就是一样的，每一个方法都对应着一个SEL，所以在Objective-C中，同一个类中或者这个类的继承体系中，不能存在2个同名的方法，不同的类可以拥有相同的selector，不同的类的实例对象执行相同的selector，会在各自的方法列表中根据selector去寻找对应的IMP。
• 在本质上，SEL只是一个指向方法的指针（被hash化得KEY值），能提高方法的查询速度。

IMP

IMP实际上是一个函数指针，指向方法实现的首地址。其定义如下：

id (*IMP)(id, SEL, ...)

第一个参数是指向 self 的指针(如果是实例方法，则是类实例的内存地址；如果是类方法，则是指向元类的指针)，第二个参数是方法选择器( selector )，接下来是方法的实际参数列表。

SEL就是为了查找方法的最终实现IMP的，由于每个方法对应唯一的SEL，因此我们可以通过SEL方便快速准确地获得它所对应的IMP。

Method

Method是一种代表类中的某个方法的类型。

Paste_Image.png

而objc_method在上面的方法列表中提到过，它存储了方法名，方法类型和方法实现：

Paste_Image.png

注意：

• 方法名类型为SEL，前面提到过相同名字的方法即使在不同类中定义，它们的方法选择器也相同。
• 方法类型method_types是个char指针，其实存储着方法的参数类型和返回值类型。
• method_imp指向了方法的实现，本质上是一个函数指针。

Ivar

Ivar是一种代表类中实例变量的类型。

Paste_Image.png

Paste_Image.png

参考资料
https://www.infoq.cn/article/deep-understanding-of-tagged-pointer/
https://draveness.me/isa