我们先来看看isa的位置

我们先来在main里面写下如下代码：

#import <objc/runtime.h>

@interface Person:NSObject{
@public
  int _age;
}
-(void)run;
+(void)walk;
@end
@implementation Person
-(void)run{
  NSLog(@"run...");
}

+(void)walk{
  NSLog(@"walk...");
}

@end

struct objc_classA{
  Class isa;
};

int main(int argc, const char * argv[]) {
 @autoreleasepool {
    Person *p =  [[Person alloc]init];//Person的实例对象
      
    Class pClass = object_getClass(p);//Person的类对象
      
    struct  objc_classA *pClassA = (__bridge struct objc_classA *)(pClass);//使用结构体转化，拿到isa
      
    Class metaPClass = object_getClass(pClass);//Person的元类对象
      
    p->_age = 10;
    [p run];
    [Person walk];
      
    NSLog(@"p:%p",p);
    NSLog(@"pClass:%p",pClass);
    NSLog(@"metaPClass:%p",metaPClass);
    NSLog(@"End");//打个断点
  }
  return 0;
}

先来说说o结构体bjc_classA的作用：

因为Person的类对象pClass，打印不出isa，所以转为具体的结构体 objc_classA

为什么这么写呢：

我们通过点击Class(command+鼠标左键)进入
//object.mm
typedef struct objc_class *Class;

再次点击objc_class入
//objc-runtime-new.h
struct objc_class : objc_object {
    //Class ISA;
     Class superclass;
     ...
}
我们发现：它继承了objc_object，点击objc_object进入定义，发现
struct objc_object {
private:
        isa_t isa;
public:
        Class ISA();
        Class getIsa();
        ...
 }
里面有一个isa对象哟

补充：在ISA()方法里面 有一个ISA_MASK宏定义
inline Class 
objc_object::ISA() 
{
assert(!isTaggedPointer()); 
#if SUPPORT_INDEXED_ISA
if (isa.nonpointer) {
    uintptr_t slot = isa.indexcls;
    return classForIndex((unsigned)slot);
}
return (Class)isa.bits;
#else
return (Class)(isa.bits & ISA_MASK);
#endif
}

ISA_MASK定义（command+鼠标左键）
if __arm64__ --> #define ISA_MASK        0x0000000ffffffff8ULL
# elif __x86_64__ -->#define ISA_MASK    0x00007ffffffffff8ULL

发现：从64bit开始isa要进行一次位域运算，才能得出真正的isa地址```

分析：我们在NSLog(@"End");处打个断点

从控制台我们看log

run...
walk...
p:0x101828830
pClass:0x100001270
metaPClass:0x100001248

1.实例对象的isa的指针的首地址就是实例对象的首地址

输入：p/x p 
结果：(Person *) $0 = 0x0000000101828830
输入：p/x &(p->isa)
结果：(Class *) $1 = 0x0000000101828830

2.类对象的isa的指针的首地址就是类对象的首地址

输入：p/x pClassA
结果：(objc_classA *) $5 = 0x0000000100001270
输入：p/x &(pClassA->isa)
结果：(Class *) $6 = 0x0000000100001270

3.元类对象的isa的指针的首地址就是元类对象的首地址(同样的方式可看)

4.实例对象的isa指向的是类对象

输入：p/x p->isa
结果 ：(Class) $2 = 0x001d800100001271 Person
输入： p/x 0x001d800100001271 & 0x00007ffffffffff8ULL
结果：(unsigned long long) $3 = 0x0000000100001270
输入：p/x pClass
结果 ：(Class) $4 = 0x0000000100001270 Person

5.类对象的isa指向的是元类对象

输入：p/x pClassA->isa
结果：(Class) $8 = 0x001d800100001249
输入：p/x 0x001d800100001249 & 0x00007ffffffffff8ULL
结果：(unsigned long long) $9 = 0x0000000100001248
输入：p/x metaPClass
结果：Class) $10 = 0x0000000100001248

我们在来看看isa到底为什么联系：实例对象、类对象、元类对象（也可以理解为到底有啥作用），接下来我们来分析下：
- instance的isa指向class：当调用对象方法的时候，通过实例对象的isa找到类对象，最后找到类对象里面的对象方法，然后执行相应的对象方法
- class的isa指向meta-class:当调用类方法的时候，通过类对象的isa找到元类对象，最后找到元类对象里面的类方法，然后执行相应的类方法
- 我们通过@property方法写的属性，存在class里的属性表里面
- 分析：（我们查看源码command+属性左键）

这里就里面的源码进行了简单的简化 （由于里面的源码有大量的代码量）
（感兴趣的可以自己按照源码自己写一个出来）
#ifndef myClassInfo_h
#define myClassInfo_h
# if __arm64__
#   define ISA_MASK        0x0000000ffffffff8ULL
# elif __x86_64__
#   define ISA_MASK        0x00007ffffffffff8ULL
# endif

#if __LP64__
typedef uint32_t mask_t;
#else
typedef uint16_t mask_t;
#endif
typedef uintptr_t cache_key_t;

struct bucket_t {
    cache_key_t _key;
    IMP _imp;
};

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

struct entsize_list_tt {
    uint32_t entsizeAndFlags;
    uint32_t count;
};

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

struct method_list_t : entsize_list_tt {
    method_t first;
};

struct ivar_t {
    int32_t *offset;
    const char *name;
    const char *type;
    uint32_t alignment_raw;
    uint32_t size;
};

struct ivar_list_t : entsize_list_tt {
    ivar_t first;
};

struct property_t {
    const char *name;
    const char *attributes;
};

struct property_list_t : entsize_list_tt {
    property_t first;
};

struct chained_property_list {
    chained_property_list *next;
    uint32_t count;
    property_t list[0];
};

typedef uintptr_t protocol_ref_t;
struct protocol_list_t {
    uintptr_t count;
    protocol_ref_t list[0];
};

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

struct class_rw_t {
   uint32_t flags;
   uint32_t version;
   const class_ro_t *ro;
   method_list_t * methods;    // 方法列表
   property_list_t *properties;    // 属性列表
   const protocol_list_t * protocols;  // 协议列表
   Class firstSubclass;
   Class nextSiblingClass;
   char *demangledName;
};

#define FAST_DATA_MASK          0x00007ffffffffff8UL
struct class_data_bits_t {
    uintptr_t bits;
public:
    class_rw_t* data() {
        return (class_rw_t *)(bits & FAST_DATA_MASK);
    }
};

/* OC对象 */
struct my_objc_object {
    void *isa;
};

/* 类对象 */
struct my_objc_class : my_objc_object {
   Class superclass;
   cache_t cache;
   class_data_bits_t bits;
public:
   class_rw_t* data() {
       return bits.data();
   }
   
   my_objc_class* metaClass() {
       return (my_objc_class *)((long long)isa & ISA_MASK);
   }
};

#endif /* myClassInfo_h */

我们在main.mm文件里面
 #import <Foundation/Foundation.h>
 #import <objc/runtime.h>
 #import "myClassInfo.h"

@interface Person:NSObject{
@public
    int _age;
}
-(void)run;
+(void)walk;
//@property (nonatomic,strong) NSString *name;
@end

@implementation Person
-(void)run{
    NSLog(@"run...");
}
+(void)walk{
    NSLog(@"walk...");
}

@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        Person *p =  [[Person alloc]init];
        
        Class pClass = object_getClass(p);
        
        struct  objc_classA *pClassA = (__bridge struct objc_classA *)(pClass);
        
        Class metaPClass = object_getClass(pClass);
             
        //使用myClassInfo类转化实例对象p
        struct my_objc_class *myP  =(__bridge struct my_objc_class *) p;
        class_rw_t  *myPData = myP->data();
        
        //使用myClassInfo类转化类对象pClass
        struct my_objc_class *myClass  =(__bridge struct my_objc_class *) pClass;
        class_rw_t  *myClassData = myClass->data();
        
        //使用myClassInfo类转化元类对象metaPClass
        struct my_objc_class *myMetaClass  =(__bridge struct my_objc_class *) metaPClass;
        class_rw_t  *myMetaClassData = myMetaClass->data();
        
        NSLog(@"End");
    }
    return 0;
}

我们在NSLog(@"End");处打个断点

发现：
1.鼠标放在myClassData上，会出现对象信息：在myClassData->methods->first.name:发现有一个run对象方法
2.鼠标放在myMetaClassData上，会出现对象信息：在myMetaClassData->methods->first.name:发现有一个walk类方法
3.将：//@property (nonatomic,strong) NSString *name;打开
鼠标放在myMetaClassData上，会出现对象信息：在myClassData->properties->first.name:
发现一个name属性

上面的只是简单的看下：其实从源码看出，下面的图的关系