一、类的结构体

1.类的本质

在OC中，类是一个指向 objc_class 结构体的指针。

typedef struct objc_class *Class;

struct objc_class {
    Class _Nonnull isa  OBJC_ISA_AVAILABILITY;

#if !__OBJC2__
    Class _Nullable super_class                              OBJC2_UNAVAILABLE;
    const char * _Nonnull name                               OBJC2_UNAVAILABLE;
    long version                                             OBJC2_UNAVAILABLE;
    long info                                                OBJC2_UNAVAILABLE;
    long instance_size                                       OBJC2_UNAVAILABLE;
    struct objc_ivar_list * _Nullable ivars                  OBJC2_UNAVAILABLE;
    struct objc_method_list * _Nullable * _Nullable methodLists                    OBJC2_UNAVAILABLE;
    struct objc_cache * _Nonnull cache                       OBJC2_UNAVAILABLE;
    struct objc_protocol_list * _Nullable protocols          OBJC2_UNAVAILABLE;
#endif

} OBJC2_UNAVAILABLE;

包含 isa 指针、成员变量列表、方法列表、方法缓存以及协议列表。
但在OC2.0版本中 已经不使用了（#if !OBJC2和OBJC2_UNAVAILABLE）。
在新版中，objc_class 继承结构体 objc_object，并且结构体内有一些函数（因为是c++结构体，在c上做了扩展，因此结构体中可以包含参数）。

struct objc_class : objc_object {
    // Class ISA;
    Class superclass;
    //方法缓存
    cache_t cache;             // formerly cache pointer and vtable
    //其中只含有一个 64 位的 bits 用于存储与类有关的信息
    class_data_bits_t bits;    // class_rw_t * plus custom rr/alloc flags

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

注释掉了Class ISA，是由于继承的objc_object结构体中有isa指针。

struct objc_object {
private:
    isa_t isa;

public:

    // ISA() assumes this is NOT a tagged pointer object
    Class ISA();

    // getIsa() allows this to be a tagged pointer object
    Class getIsa();

objc_class结构体内部，class_rw_t是通过bits调用data方法的来的。在data方法内部，将bits与 FAST_DATA_MASK进行位运算，会得到class_rw_t结构体。

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

class_rw_t结构体（rw代表readwrite可读可写，t代表table表）

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

指向常量的指针 ro，其中存储了当前类在编译期就已经确定的属性、方法以及遵循的协议。
其中还包含一个struct class_ro_t的结构体（ro代表readonly，只读）

struct class_ro_t {
    uint32_t flags;
    uint32_t instanceStart;
    //instance对象占用的内存空间
    uint32_t instanceSize;
#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;
};

2.class_ro_t 和 class_rw_t 的分析

class_rw_t结构体内有一个指向class_ro_t结构体的指针。
每个类都对应有一个class_ro_t结构体和一个class_rw_t结构体。在编译期间，class_ro_t结构体就已经确定，objc_class中的bits的data部分存放着该结构体的地址。在runtime运行之后，具体说来是在运行runtime的realizeClass 方法时，会生成class_rw_t结构体，该结构体包含了class_ro_t，并且更新data部分，换成class_rw_t结构体的地址。
类的realizeClass运行之前：

realizeClass运行之前

类的realizeClass运行之后：

realizeClass运行之后

二、isa 指针

在OC中，任何类的定义都是对象。类和类的实例（对象）没有任何本质上的区别。任何对象都有 isa 指针。

    NSString *str = @"aaa";

str 本质是一个 objc_object 结构体，而这个结构体的成员变量 isa 指针指向了 NSString 类，NSString 类其实是类对象。
struct objc_classs结构体里存放的数据称为元数据(metadata)，类对象的isa指针指向的我们称之为元类(metaclass)。元类中保存了创建类对象以及类方法所需的所有信息。

isa_t

//共用体中可以定义多个成员，共用体的大小由最大的成员大小决定
//共用体的成员公用一个内存
//对某一个成员赋值，会覆盖其他成员的值
//存储效率更高
union isa_t 
{
    Class cls;
    uintptr_t bits;   //存储下面结构体每一位的值
    struct {
        uintptr_t nonpointer        : 1;  // 0:普通指针，存储Class、Meta-Class；1:存储更多信息
        uintptr_t has_assoc         : 1;  // 有没有关联对象
        uintptr_t has_cxx_dtor      : 1;  // 有没有C++的析构函数（.cxx_destruct）
        uintptr_t shiftcls          : 33; // 存储Class、Meta-Class的内存地址
        uintptr_t magic             : 6;  // 调试时分辨对象是否初始化用
        uintptr_t weakly_referenced : 1;  // 有没有被弱引用过
        uintptr_t deallocating      : 1;  // 正在释放
        uintptr_t has_sidetable_rc  : 1;  // 0:引用计数器在isa中；1:引用计数器存在SideTable
        uintptr_t extra_rc          : 19; // 引用计数器-1
    };
}

三、类的封装、继承和多态

1、封装

封装就是对类的一些字段、方法进行保护，不被外界访问到。

#import <Foundation/Foundation.h>
@interface Car : NSObject
{
     //这个属性就是对外进行保密的相当于private，所以我们需要在外部访问的话，必须定义get/set方法
     //默认的是private的，但是我们可以使用@public设置为public属性的,那么在外部可以直接访问：person->speed = 100;
     //当然我们一般不这么使用，因为这会破坏封装性，这种用法相当于C中的结构体中权限
     //一共四种：@public,@protected,@private,@package,这个和Java中是相同的
     @public
            NSInteger speed;
 }

OC也有四种访问权限修饰符：@public、@protected、@private、@package
其中默认的修饰符是@private。
OC的方法中是没有修饰符概念的，一般都是公开访问的，如果想让一个方法不被外界访问的话，只需要在.m文件中实现这个方法，不在头文件中进行定义。

2、继承

继承是指一个新类（子类）拥有被继承类（父类）的全部属性和方法。
继承的优点：代码重用。继承的缺点：父类的改变会影响所有子类。子类与父类的耦合度很高，当子类中需要自己独特的行为，可以重写父类的方法。如果重写父类的方法，但是还想用父类的功能，可以使用super调用父类的方法。
在继承体系中，方法的调用顺序：
（1）在自己的类中查找
（2）如果没有再去父类中找
（3）如果父类中没有则去父类的父类中查找，一直找到基类。
OC中类方法也是可以继承的，也是可以重写的。类方法和实例方法可以重名，但子类中不能定义和父类中同名的成员变量。
OC是单继承：一个类只能继承一个直接父类。
OC是多层继承：B可以继承A，C可以继承B，则C也继承A。

3.多态

（1）多态
多态一般要和继承结合起来说，其本质是子类通过覆盖或重载父类的方法，来使得对同一类对象同一方法的调用产生不同的结果。
程序中的多态：父类指针指向子类对象。
（2）原理
动态绑定
动态类型能使程序直到执行时才确定对象的真实类型。
动态类型绑定能使程序直到执行时才能确定要对哪个对象调用的方法。
（3）条件
有继承关系
子类重写父类方法
父类指针指向子类对象
（4）注意点
如果父类指针指向子类对象，如果需要调用子类特有的方法，必须先强制类型转换为子类才能调用。
如果存在多态，父类是可以访问子类特有的方法
如果不存在多态，父类是不可以访问子类特有方法的

@interface Phone : NSObject
@property (nonatomic,strong) NSString *name;
- (void)call;
@end

#import "Phone.h"
@implementation Phone
- (void)call{
    NSLog(@"%s",__func__);
}
- (NSString *)description
{
    return [NSString stringWithFormat:@"%@", _name];
}
@end

---------------
#import "Phone.h"
@interface IPhone : Phone
@end

#import "IPhone.h"
@implementation IPhone
- (void)call{
    NSLog(@"%s",__func__);
}
@end
---------------
#import "Phone.h"
@interface Android : Phone
@end

#import "Android.h"
@implementation Android
- (void)call{
    NSLog(@"%s",__func__);
}
@end
---------------
- (void)viewDidLoad {
    [super viewDidLoad];
    Phone *p = [[IPhone alloc]init];
    p.name = @"iPhone";
    [p call];
    NSLog(@"%@",p);

    Phone *a = [[Android alloc]init];
    a.name = @"Android";
    [a call];
    NSLog(@"%@",a);
}

2020-07-29 19:55:07.826467+0800 StartNow[6683:196183] -[iPhone call]
2020-07-29 19:55:07.826678+0800 StartNow[6683:196183] <iPhone: 0x6000019ac110>
2020-07-29 19:55:07.826788+0800 StartNow[6683:196183] -[Android call]
2020-07-29 19:55:07.826886+0800 StartNow[6683:196183] <Android: 0x6000019a05d0>

四、分类（category）、扩展（extension）和协议（protocol）

1、分类

分类（类别Category）的作用：

扩展已有类的功能。
（1）可以将类的实现分散到不同的文件或不同的框架中，也可以提供类的扩展
（2）创建对私有方法的前向引用：如果其他类中的方法未实现，在访问其他类的私有方法时编译器报错这时使用类别，在类别中声明这些方法（不必提供方法实现），编译器不会产生警告。
（3）向对象添加非正式协议：创建一个NSObject的类别称为“创建一个非正式协议”，因为可以作为任何类的委托对象使用。有两个方面的局限性： (1)无法向类中添加新的实例变量，类别没有位置容纳实例变量。(2)名称冲突，即当类别中的方法与原始类方法名称冲突时，类别具有更高的优先级。类别方法将完全取代初始方法从而无法再使用初始方法。这个类似于方法的重载，但是这里是直接覆盖了原方法。

分类的属性

分类原则上是不能添加属性的。但@property是可以编译通过的，只是无法生成setter和getter方法，但只要调用属性就会报错。可以使用runtime手动添加setter和getter方法。
runtime可以添加属性的原因：
关联对象都由AssociationsManager管理，AssociationsManager里面是由一个静态AssociationsHashMap来存储所有的关联对象的。这相当于把所有对象的关联对象都存在一个全局map里面。而map的key是这个对象的指针地址（任意两个不同对象的指针地址一定是不同的），而这个map的value又是另外一个AssociationsHashMap，里面保存了关联对象的kv对。

不能添加成员变量，能添加方法的原因

Objective-C类是由Class类型来表示的，它实际上是一个指向objc_class结构体的指针。在上面的objc_class结构体中，ivars是objc_ivar_list（成员变量列表）指针；methodLists是指向objc_method_list指针的指针。在Runtime中，objc_class结构体大小是固定的，不可能往这个结构体中添加数据，只能修改。所以ivars指向的是一个固定区域，只能修改成员变量值，不能增加成员变量个数。methodList是一个二维数组，所以可以修改*methodLists的值来增加成员方法，虽没办法扩展methodLists指向的内存区域，却可以改变这个内存区域的值（存储的是指针）。因此，可以动态添加方法，不能添加成员变量。

本类和分类的话，分类优先于本类的方法。

2、扩展

扩展一般用于私有方法、私有属性、私有成员变量。扩展只存在于一个.h文件中，或者只寄生于一个类的.m文件中。
其实.m文件中的如下代码就是一个extension。

@interface ViewController ()

@end

3、分类和扩展的异同点分析

（1）分类

• 分类只能添加方法，不能添加成员变量。
• 分类中可以访问原来类中的成员变量，但是只能访问@property和@public属性。
• 添加方法加上前缀，添加方法会覆盖父类的同名方法，可以防止意外覆盖，也防止被别人覆盖。
• 分类中添加成员变量，要通过setter和getter方法进行添加。
  （2）扩展
• 类扩展的属性和方法都是私有的，也可以定义在.h中，这样就是共有的，类扩展中的方法是一定要实现的方法。Category没有这个限制。

4、协议

（1）非正式协议
非正式协议就是类别，即凡是NSObject或其子类的类吧，都是非正式协议。
（2）协议
协议类似于接口。协议只能定义公用的一套接口，但不能提供具体的实现方法。也就是说，它只告诉你要做什么，但具体怎么做不关心。具体的实现要在遵守这个协议的类中实现。
<NSObject>是基协议，是最根本的协议，其中声明了很多最基本的方法，如description，retain，release。建议每个新协议都要遵守NSObject协议

• 协议只能声明方法，不能声明属性

@protocol SportProtocol <NSObject>
//{
//    int  _age;
//}
// 方法声明列表
// 注意: 如果没有使用任何关键字修饰协议中的方法, 那么该方法默认就是required的
@required
// 如果协议中的方法是@required的, 而遵守协议的类又没有实现该方法, 那么会报一个警告
- (void)playFootball;
@optional // 可选
// 如果协议中的方法是@optional的, 而遵守协议的类又没有实现该方法, 那么不会报警告
- (void)playBasketball;
- (void)playBaseball;
// 注意:@required和@optional仅仅使用程序员之间交流, 并不能严格的控制某一个遵守该协议的类必须要实现该方法, 因为即便不是实现也不会报错, 只会报一个警告
@end

• 父类遵守了某个协议，那么子类也会自动遵守这个协议
• 在OC中，一个类可以遵守一个或多个协议。（OC中一个类只能有一个父类，也就是说OC只有单继承）
• OC中的协议又可以遵守其他协议，只要一个协议遵守了其他协议，那么这个协议中就会自动包含其他协议的声明

@protocol CrazySportProtocol <SportProtocol>
// 跳楼
- (void)jumping;
@end

（3）协议和代理
协议：是一套接口，是一个功能方法的集合。本身 不是一个类，不能自己实现协议里的方法，而是委托其他类去实现。通常用来实现委托代理设计模式，实现不同类对象之间的消息通信。
代理：是一种设计模式，在OC中通过协议来实现，可以使一个对象在特定时刻通知其他类的对象去实现任务，不需要获取那些对象的指针，实现不同对象之间的通信。

五、+load和+initialize

1、+load

（1）+load方法是通知dyld，由dyld进行调用。dyld通过load_images中的call_load_methods进行调用。
（2）+load调用原理是找到类和分类中的+load方法的IMP，直接进行调用。
（3）+load调用顺序：+load方法是根据地址直接调用的，并不是通过objc_msgSend函数调用。类、父类、分类的+load是相互独立的。在准备阶段，父类会优先于子类被加载到列表中，所以会先被调用。当调用+load方法是时会先调用本类中的+load方法，在调用分类中的+load方法。
（4）+load方法只运行一次。
（5）+load方法使用过多会导致app在启动时很慢。

2、+ initialize

（1）+initialize方法在收到消息的时候调用。
（2）+initialize在第一次收到消息的时候，确保类和元类都实例化，且没有调用过+initialize方法，通过objc_msgSend发送@selector(initialize)消息，进行调用。
（3）+initialize调用顺序，先调用父类的+initialize方法，在调用子类的+initialize方法。
（4）+initialize只调用一次。