iOS—Effective Objective—C2.0（2）

漓江塔塔主

已于 2023-01-15 19:36:32 修改

阅读量1.3k

点赞数 1

分类专栏：笔记文章标签： ios objective-c xcode

于 2023-01-08 18:31:46 首次发布

本文链接：https://blog.csdn.net/cyberjack/article/details/128426992

版权

笔记专栏收录该内容

32 篇文章 1 订阅

订阅专栏

文章目录

对象，消息，运行期

对象，消息，运行期

对象是“基本构造单元”，开发者通过对象来储存并传递数据，在对象之间传递数据并执行任务的过程就叫做“消息传递”，当程序运行起来的时候，为其提供相关支持的代码，叫做“运行期环境”，它提供了一些使对象之间能够传递消息的重要函数，并且包含创建类实例所用的全部逻辑。

理解“属性”概念

属性是OC的一项特性，用于封装对象中的数据，OC对象通常会把其所需要的数据保存为各种实例变量，实例变量一般通过存取方法来访问，getter方法用于读取变量，setter方法用于写入变量，开发者可以令编译器自动编写与属性相关的存取方法，引入了一种新的“点语法”，使开发者可以更为容易地依照类对象来访问存放于其中的数据。

合成与存取

如果代码使用了编译期计算出来的偏移量，那么在修改类定义之后必须重新编译，否则就会出错。eg：某个代码库中的代码使用了一份旧的类定义。如果和其相链接的代码使用了新的类定义，那么运行时就会出现不兼容现象。OC对此的解决办法是，把实例变量当作一种存储偏移量所用的“特殊变量”，交由“类对象”保管，偏移量会在运行期查找，如果类的定义变了，那么存储的偏移量也就变了，这样的话，无论何时访问实例变量，总能使用正确的偏移量。这就是稳固的 “应用程序二进制接口”(ABI)，有了ABI，不一定要在街口中把全部实例变量都声明好，可以将某些变量从接口的的PUBILC区段里移走，以便保护与类实现有关的内部信息。
这个问题还有一种解决方案，就是尽量不要直接访问实例变量，而是通过存取方法来做，虽说属性还是得通过实例变量来实现，但它却提供了一种简洁的抽象机制，你可以自己编写存取方法,因为存在着较为严格的命名规范，OC可以根据名称自动创建出来存取方法，@property就派上了用场

在对象接口的定义中可以使用属性，这是一种标准的写法，能够封装在对象里的数据，可以把属性当成一种简称，其意思就是说：编译器会自动编写出一套存取方法。
要访问属性，使用“点语法”编译器会把点语法转化为对存取方法的调用，使用“点语法”和直接调用存取方法之间没有丝毫差别。
属性还具有更多优势，如果使用了属性的话，那么编译器就会自动编写访问这些属性所需的方法，此过程叫做“自动合成”这个过程由编译器在编译期执行，所以编辑器里看不到这些合成方法。

@dynamic关键字

若是不想让编译器自动合成存取方法，则可以自己实现，如果你只是实现了其中一个存取方法，那么另一个还是会由编译器来合成，但是当你使用了@dynamic关键字，他会告诉编译器：不要自动创建实现属性所用的实例变量，也不要为其创建存取方法，在编译器编译访问属性的代码时，即使没有发现定义的存取方法，也不会报错，因为这使编译器相信这些方法会在运行期中找到（在运行期动态创建存取放法）

属性特性

使用属性时应有一个问题需要注意，就是其各种“特质”的设定也会影响编译器所产生的存取方法，例如
@property(nonatomic, readwrite, copy) NSString* first;
属性拥有的特质分四类

原子性

默认情况下，有编译器所合成的方法会通过锁定机制确保其原子性。如果属性具备nonatomic特质，则不使用同步锁。如果不具备，那它就是“原子的”，但是仍然可以在属性特质中写明这一点，编译器不会报错。如果是自己定义存取的方法，那么就应该遵从与属性特质相符的原子性。
atomic：默认值，原子性访问，单线程访问，表示如果有多个线程同时调用setter的话，不会出现某一个线程执行setter全部语句之前，另一个线程开始执行setter情况，安全性高于nonatomic，性能低于nonatomic，但atomic 并不代表线程安全，只是说对同一对象的set和get的操作是顺序执行的。值得我们注意的一点是atomic是默认值，假如属性不具备nonatomic特质，那么它就默认具备atomic。
nonatomic：非原子性访问，可以多线程并发访问，oc中大多数都申明nonatomic属性。

读/写权限

具备readwrite（读写）特质的属性拥有“获取方法”与“设置方法”。若该属性由@synthesize实现，则编译器会自动生成这两个方法。
具备readonly（只读）特质的属性仅拥有获取方法，只有当该属性由@synthesize实现时，编译器才会为其合成获取方法。你可以用此特质把某个属性对外公开为只读属性，然后在分类中将其重新定义为读写属性。

内存管理语义

assign：默认值，直接赋值，主要是对基本数据类型使用：NSInteger，CGFloat 和C语言的 int double float char …
retain：先release旧的对象，新对象的计数加1，并返回地址给引用者，主要对NSObject与其子类中使用。
strong：强引用，ARC模式下与retain同作用。此特质表明该属性定义了一种**“拥有关系”。为这种属性设置新值时，设置方法会先保留新值，并释放旧值，然后再将新值设置上去。
weak：弱引用，ARC模式下与assign同作用。此特质表明该属性定义了一种“非拥有关系”。为这种属性设置新值时，设置方法既不保留新值，也不释放旧值。然后在属性所指对象遭到摧毁时，属性值也会清空（nil out）。
unsafe_unretained：此特质的语义和assign相同，但是它适用于“对象类型”（object type），该特质表达一种“非拥有关系”**（“不保留”，unretained），当目标对象遭到摧毁时，属性值不会自动清空（“不安全”，unsafe），这一点与weak不同。
copy：创建一个新对象，将旧对象的值赋值给新对象，release旧对象。 copy与retain的区别为：retain是指针拷贝，copy是内容拷贝，其主要对字符串NSString使用。

方法名

就是可以自己设定一个属性的setter、getter方法的名字。
可通过如下特质来指定存取方法的方法名:

■gtter=指定 “获取方法”的方法名。如果某属性是Boolean型，而你想为其获取方法加上“is”前缀，那么就可以用这个办法来指定。比如说，在UISwich类中，表示“开关"(swich)是否打开的属性就是这样定义的:

@property (nonatomic, getter=isOn) BOOL on;

■setter= 指定“设置方法”的方法名。这种用法不太常见。

通过上述特质，可以微调由编译器所合成的存取方法。不过需要注意:若是自己来实现这些存取方法，那么应该保证其具备相关属性所声明的特质。比方说，如果将某个属性声明为copy,那么就应该在“设置方法”中拷贝相关对象，否则会误导该属性的使用者，而且，若是不遵从这一约定，还会令程序产生bug。

为什么几乎所有的属性都可以使用nonatomic：

在iOS中使用同步锁的开销较大，这会带来性能问题。一般情况下并不要求属性必须是“原子的”，因为这并不能保证“线程安全”，若要实现“线程安全”的操作，还需采用更为深层的锁定机制才行。

要点

可以用@property语法来定义对象中封装的数据。
通过“特质”来指定存储数据所需的正确语义。
在设置属性所对应的实例变量时，一定要遵从该属性所声明的语义。
开发iOS程序时应该使用nonatomic属性，因为atomic属性会严重影响性能。

在对象的内部尽量直接访问实例变量

在对象之外访问实例变量时，总是应该通过属性来做，然而在对象内部访问实例变量时又该如何？这边建议在读取实例变量的时候采用直接访问的形式，在设置实例变量的时候通过属性来做
在这里插入图片描述

我们使用点语法通过存取方法来访问相关实例变量，现在重写方法，直接访问实例变量。
在这里插入图片描述

这两种写法有几个区别。

■由于不经过ObjectiveC的“方法派发”步骤，所以真接访问实例变量的速度当然比较快。在这种情况下，编译器所生成的代码会直接访问保存对象实例变量的那块内存。

■直接访问实例变量时，不会调用其“设置方法”，这就绕过了为相关属性所定义的“内存管理语义”。比方说，如果在ARC下直接访问一个声明为copy的属性，那么并不会拷贝该属性，只会保留新值并释放旧值。

■如果真接访问实例变量，那么不会触发键值观测(KVO)通知。这样做是否会产生问题，还取决于具体的对象行为。

■通过属性来访问有助于排查与之相关的错误，因为可以给“获取方法”和/或“设置方法”中新增“断点”(breakpoint)，监控该属性的调用者及其访问时机。

有一种合理的折中方案，那就是:在写人实例变量时，通过其“设置方法”来做，而在读取实例变量时，则直接访问之。此办法既能提高读取操作的速度，又能控制对属性的写入操作。之所以要通过“设置方法”来写人实例变量，其首要原因在于，这样做能够确保相关属性的“内存管理语义”得以贯彻。

惰性初始化：

也叫做“延迟初始化”。在惰性初始化的情况下，必须通过“获取方法”来访问属性，否则，实例变量就永远不会初始化。
一般用于：一个属性不常用，而且创建该属性的成本较高的情况。

要点

在对象内部读取数据时，应该直接通过实例变量来读，而写入数据时，则应通过属性来写
在初始化方法及dealloc方法中，总是应该直接通过实例变量来读写数据。
有时会使用惰性初始化技术配置某粉数据，这种情况下，需要通过属性来读取数据

理解“对象同等性”这一概念

== 和 isEqual

判断相等通常“==”来判断，当然OC里也可以用这个方法，不过有时候比较出来的结果不一定是我们想要的，==的比较仅仅是比较指针本身，并不会对其所指代的对象进行比较.

对于使用NSObject协议的，应该使用协议里的 “isEqual”方法来判断两个对象的等同性，这个方法针对的是两个不同的类型的对象，一般来说这两个类型不同的对象总是不相等的，某些对象提供了特殊的“等同性半丁方法”，
对于相同的对象，OC提供了更快的方法，比如对于NSString类型 OC提供了"isEqualToString"方法来判断其是否相等

	NSString *foo = @"Badger 123";
    NSString *bar = [NSString stringWithFormat:@"Badger %d", 123];
    BOOL equalA = (foo == bar);
    BOOL equalB = [foo isEqual:bar];
    BOOL equalC = [foo isEqualToString:bar];

名叫isEqualToString的方法是NSString类实现了一个自己独有的等同性判断方法。传递给该方法的对象必须是NSString，否则结果未定义，调用此方法比isEqual快，后者还要执行额外的步骤，因为其不知道受测对象的类型
NSObject协议中有两个用于判断等同性的关键方法：

- (bool)isEqual:(id)object;
- (NSUInteger)hash;

NSObject类对这两个方法的默认实现是：当且仅当“指针值”完全相同时，两个对象才相等。如果 isEqual:方法判定两个对象相等，那么其hash 方法也必须返回同一个值。但是，如果两个对象的hash 方法返回同一个值，那么 isEqual:方法末必会认为两者相等。

特定类所具有的等同性判定方法：

除了自定义类之外，每个类几乎都有其特定的等同性判定方法，NSArray类为“isEqualToArray:”，NSDictionary类为“isEqualToDictionary:”，若不是同一个类型的话，它就会直接抛出异常，是同一个类型才会开始一一处理。
在编写判定方法时，也应一并覆写“isEqual：”方法。后者的常见实现方式为：如果受测的参数与接收该消息的对象都属于同一个类，那么就调用自己编写的判定方法，否则就交由超类来判断。

等同性判定的执行深度：

就用NSArray来说，NSArray的检测方式为：先看两个数组所含的对象个数是否相同，若相同，则在每个对应位置的两个对象身上调用其“isEqual：”方法。如果对应位置上的对象均相等，那么这两个数组就相等，这叫做“深度等同性判定”。
是否需要在等同性判定方法中检测全部字段取决于受测对象。只有类的编写者才可以确定两个对象实例在何种情况下应判定为相等。

容器中可变类的等同性：

当你创建了一个对象，它的地址就相当于一个“箱子”，但是如果某对象在放入“箱子”之后哈希码又变了，那么其现在所处的这个箱子对他来说就是“错误”的。因为它可变了，说不定改变之后的哈希码或者地址就被改变了，所以它就是“错误”的。
要想解决这个问题，需要确保哈希码不是根据对象的“可变部分”计算出来的，或是保证放入collection之后就不再改变对象内容了，读者可以从此为出发点，对自己的等同性判断进行相应的完整。

要点：

若想检测对象的等同性，请提供“isEqual：”与hash方法。
相同的对象必须具有相同的哈希码，但是两个哈希码相同的对象却未必相同。
不要盲目地逐个检测每条属性，而是应该依照具体需求来制定检测方案。
编写hash方法时，应该使用计算速度快而且哈希码碰撞几率低的算法。

以“类族模式”隐藏实现细节

“类族”是一种很有用的模式，可以隐藏“抽象基类”背后的实现细节，就是说将其变成一个黑匣子，用户看不到里边的实现代码，只能知道输入和输出的值。

创建类族：

首先要定义抽象基类，也就是一个新的类，其中可以包括你的类型选取，使用枚举器和switch语句来完成，并且还的定义你的类的相关方法，再创建一个新的类，继承你之前的类，并且完成之前的定义方法，使用覆盖的原理，完成这些方法。这种“工厂模式”是创建类族的办法之一。
如果你想创建的类中没有init初始化的方法，那么这就是在暗示你该类的实例也许不应该由用户直接创建。总而言之，以后创建对象一定不要被其的表象迷惑住了，你可能觉得自己创建了某个类的实例，然而实际上创建的却是其子类的实例。

//定义员工类型
typedef NS_ENUM(NSUInteger, EOCEmployeeType) {
    EOCEmployeeTypeDeveloper,
    EOCEmployeeTypeDesiner,
    EOCEmployeeTypeFinance
};

@interface EOCEmployee : NSObject
//定义属性
@property (nonatomic, copy) NSString *name;
@property (nonatomic, assign) NSUInteger salary;
//定义方法
+ (EOCEmployee *)employeeWithType:(EOCEmployeeType)type;

- (void)doADaysWork;

@end

实现类的方法

@implementation EOCEmployee

+ (EOCEmployee *)employeeWithType:(EOCEmployeeType)type {
    switch (type) {
        case EOCEmployeeTypeDeveloper:
            return [EOCEmployeeTypeDeveloper new];
            break;
            
        case EOCEmployeeTypeDesiner:
            return [EOCEmployeeTypeDesiner new];
            break;
            
        case EOCEmployeeTypeFinance:
            return [EOCEmployeeTypeFinance new];
            break;
    }
}

- (void)doADaysWork {
    // Subclasses implement this.
}

@end

每个“实体子类”都是基类继承而来

@interface EOCEmployeeTypeDeveloper : EOCEmployee
@end

@@implementation  EOCEmployeeTypeDeveloper

- (void)doADaysWork {
	[self writeCode];
}

@end

Cocoa里的类族：

系统框架中有许多类族，就用我们经常使用的NSArray和NSMutableArray来说，这样来看，它是两个抽象基类，但是他们两个拥有相同的方法，这个方法可能就是他们共同类族中的方法，而可变数组的特殊方法就是只适用于可变数组的方法，其他的共同方法可能就是类族中的方法。
在使用NSArray的alloc方法来获取实例时，该方法首先会分配一个属于某个类的实例，此实例充当一个“占位数组”，也就是说，你把这个位置是先分配给其类族的，后来其类族才将这个位置分配给你创建的具体数据类型的。所以像这些类的背后其实是一个类族，在对一些if条件进行判断的时候一定要注意，例如：

id maybeAnArray = /* ... */;
if ([maybeAnArray class] == [NSArray class]) {
    //Will never be hit
}

像这样的判断条件它就是不可能成立的，因为[maybeAnArray class]所返回的类绝不可能是NSArray本身，因为由NSArray的初始化方法所返回的那个实例其实类型是隐藏在类族公共接口后边的某个内部类型。

判断实例是否位于类族之中

使用类型信息查询方法，若想判断某对象是否位于类族之中，不要检测两个类对象是否相等，应该采用下列代码

id maybeAnArray = /* ... */
if ([maybeAnArray isKindOfClass: [NSArray class]]) {
//will be hit
}

增加子类

对于Cocoa中NSArray这样的类族来说，还是有办法新增子类的，但是需要遵守几条规则。这几条规则如下。
■子类应该继承自类族中的抽象基类。
若要编写NSArray类族的子类，则需令其继承自不可变数组的基类或可变数组的基类。
■子类应该定义自己的数据存储方式。
开发者编写NSArray子类时，经常在这个问题上受阻。子类必须用一个实例变量来存放数组中的对象。这似乎与大家预想的不同，我们以为NSArray自己肯定会保存那些对象，所以在子类中就无须再存一份了。但是要记住，NSArray本身只不过是包在其他隐藏对象外面的壳，它仅仅定义了所有数组都需具备的一些接口。对于这个自定义的数组子类来说，可以用NSArray来保存其实例。

■子类应当覆写超类文档中指明需要覆写的方法。

在每个抽象基类中，都有一些子类必须覆写的方法。比如说，想要编写NSArray的子类，就需要实现count及“objectAtIndex:"方法。像lastObject这种方法则无须实现，因为基类可以根据前两个方法实现出这个方法。

在类族中实现子类时所需遵循的规范一般都会定义于基类的文档之中，编码前应该先看看。

要点：

类族模式可以把实现细节隐藏在一套简单的公共接口后面。
系统框架中经常使用类族。
从类族的公共抽象基类中继承子类时要当心，若有开发文档，则应首先阅读。

在既有类中使用关联对象存放自定义数据

有时候需要在对象中存放相关信息。这是我们通常会从对象所属的类中继承一个子类，然后改用这个子类的对象。然而并非所有情况下都能这么做，有时候类的实例可能是由某种机制所创建的，而开发者无法令这种机制创建出自己所写的子类实例。那怎么办呢？那就是关联对象（Associated Object）。
我们可以给某对象关联许多其他对象，这些对象通过“键”来区分。存储对象值的时候，可以指明“存储策略”用以维护相应的“内存管理语义”。策略其实就和我们当时定义属性时的修饰符作用相似，下面就是其相应的关联类型：在这里插入图片描述

我们可以把某对象想象成NSDictionary,把关联到该对象的值理解为字典中的条目，于是，存取关联对象的值就相当于在NSDictionary对象上调用[object setObject:valueforKey:key]与[object objectForKey:key]方法。然而两者之间有个重要差别:设置关联对象时用的键(key)是个“不透明的指针”(opaque pointer)。如果在两个键上调用“isEqual:” 方法的返回值是YES,那么NSDictionary就认为二者相等;然而在设置关联对象值时，若想令两个键匹配到同一个值，则二者必须是完全相同的指针才行。鉴于此，在设置关联对象值时，通常使用静态全局变量做键。

要点

可以通过“关联对象”机制来把两个对象连起来
定义关联对象时可指定内存管理语义，用以模仿定义属性时所采用的“拥有关系” 与 “ 非拥有关系〞。
只有在其他做法不可行时才应选用关联对象，因为这种做法通常会引人难于查找的bug。

理解objc_msgSend的作用

在对象上调用方法是OC中经常使用的功能。用OC的术语来说，这叫做“传递消息”。消息有“名称”或“选择子”，可以接受参数，而且可能还有返回值。我们之前用C语言写出来的函数就是“静态绑定”的函数，就是说，他在编译期就能决定运行时所调用的函数。但是若是我们使用一个函数指针来实现函数调用的话，这时他就成为一个“动态绑定”了，因为所调用的函数直到运行期才能确定。
在OC中，如果向某对象传递消息，那就会使用动态绑定机制来决定需要调用的方法。在底层，所有的方法都是普通的C语言函数，然而对象收到消息之后究竟该调用那个方法则完全取决于运行期决定，甚至可以在程序运行时改变，这些特性使得OC成为一门真正的动态语言。

消息转发过程

来看下面一个对象发送消息：

id returnValue = [someObject messageName:parameter]；

在这个例子中

someObject叫做“接收者”(receiver),messageName叫做 “选择子”(selector)。选择子与参数合起来称为 “消息” (message)。编译器看到此消息后，将其转换为一条标准的 C语言两数调用，所调用的函数乃是消息传递机制中的核心两数，叫做objc_msgSend，其 “ 原型” ( prototype )如下:

void objc_msgsend(id self, SEL cmd, ...)

这是个“ 参数个数可变的两数” ( variadic function)。能接受两个或两个以上的参数。第一个参数代表接收者，第二个参数代表选择子(SEL 是选择子的类型)，后续参数就是消息中的那些参数，其顺序不变。选择子指的就是方法的名字。“选择子〞与“方法” 这两个词经常交替使用。编译器会把刚才那个例子中的消息转换为如下函数:

id returnValue = objc msgSend(someobject, @selector (messageName:), parameter);

objc_msgSend 两数会依据接收者与选择子的类型来调用适当的方法。为了完成此操作，该方法需要在接收者所属的类中搜寻其“方法列表” (list of methods)，如果能找到与选择子名称相符的方法，就跳至其实现代码。若是找不到，那就沿着继承体系继续向上查找，等找到合适的方法之后再跳转。如果最终还是找不到相符的方法，那就执行 “消息转发”(mesage forwarding)操作。

边界情况

前面讲的这部分内容只描述了部分消息的调用过程，其他“边界情况” (edge case )则需要交由Objective-C 运行环境中的另一些函数来处理:

objc_msgSend_stret。如果待发送的消息要返回结构体，那么可交由此两数处理。只有当 C P U 的寄存器能够容纳得下消息返回类型时，这个两数才能处理此消息。若是返回值无法容纳于 C P U 奇存器中 ( 比如说返回的结构体太大了 )，那么就由另一个函数执行派发。此时，那个两数会通过分配在栈上的某个变量来处理消息所返回的结构体。
objc _msgSend_fpret。如果消息返回的是浮点数，那么可交由此晒数处理。在某些架构的 C P U 中调用函数时，需要对 " 浮点数寄存器 " (floating - point register)做特殊处理，也就是说，通常所用的objc_msgSend 在这种情况下并不合适。这个两数是为了处理 ×86 等架构CPU 中某些令人稍觉惊讶的奇怪状况。
objc_msgSendSuper。如果要给超类发消息，例如[super message:parameter]，那么就交由此两数处理。也有另外两个与obje_msgSend_stret 和objc_msgSend_foret 等效的函数，用于处理发给super 的相应消息。

要点

消息由接收者、选择子及参数构成。给某对象“发送消息”也就相当于在该对象上“调用方法”。
发给某对象的全部消息都要由“动态消息派发系统”来处理，该系统会查出对应的方法，并执行其代码。

第12条：理解消息转发机制

如果对象所属类和其所有的父类都无法解读收到的消息，就会启动消息转发机制（message forwarding）。

尤其我们在编写自己的类时，可在消息转发过程中设置挂钩，用以执行预定的逻辑，而不应该使应用程序崩溃。

消息转发分为两个阶段:

征询接受者，看它能否动态添加方法，以处理这个未知的选择子，这个过程叫做动态方法解析（dynamic method resolution）。
请接受者看看有没有其他对象能处理这条消息： 2.1 如果有，则运行期系统会把消息转给那个对象。
2.2 如果没有，则启动完整的消息转发机制（full forwarding mechanism），运行期系统会把与消息有关的全部细节都封装到NSInvocation对象中，再给接受者最后一次机会，令其设法解决当前还未处理的这条消息。在这里插入图片描述

类方法+(BOOL)resolveInstanceMethod:(SEL)selector:查看这个类是否能新增一个实例方法用以处理此选择子

实例方法- (id)forwardTargetForSelector:(SEL)selector;:询问是否能找到未知消息的备援接受者，如果能找到备援对象，就将其返回，如果不能，就返回nil。

实例方法- (void)forwardInvocation:(NSInvocation*)invocation:创建NSInvocation对象，将尚未处理的那条消息有关的全部细节都封于其中，在触发NSInvocation对象时，“消息派发系统（message-dispatch system）”就会将消息派给目标对象。

要点总结

若对象无法响应某个选择子，则进入消息转发流程。
通过运行期的动态方法解析功能，我们可以在需要用到某个方法时再将其加入类中。
对象可以吧其无法解读的某些选择子转交给其他对象来处理。
经过上述两步之后，如果还是没办法处理选择子，那就启动完整的消息转发机制。

用“方法调配技术”调试“黑盒方法”

与选择子名称相对应的方法是可以在运行期被改变的，所以，我们可以不用通过继承类并覆写方法就能改变这个类本身的功能。

那么如何在运行期改变选择子对应的方法呢？
答：通过操纵类的方法列表的IMP指针
在这里插入图片描述

什么是类方法表？什么是IMP指针呢？

类的方法列表会把选择子的名称映射到相关的方法实现上，使得“动态消息派发系统”能够据此找到应该调用的方法。这些方法均以函数指针的形式来表示，这些指针叫做IMP。例如NSString类的选择子列表

在这里插入图片描述

有了这张表，OC的运行期系统提供的几个方法就能操纵它。开发者可以向其中增加选择子，也可以改变某选择子对应的方法实现，也可以交换两个选择子所映射到的指针以达到交换方法实现的目的。

eg：交换lowercaseString和uppercaseString方法的实现：

Method originalMethod = class_getInstanceMethod([NSString class], @selector(lowercaseString));
Method swappedMethod = class_getInstanceMethod([NSString class],@selector(uppercaseString));

method_exchangeImplementations(originalMethod, swappedMethod);
这样一来，类方法表的映射关系就变成了下图：
在这里插入图片描述

交换两个方法

这时，如果我们调用lowercaseString方法就会实际调用uppercaseString的方法，反之亦然。
然而,在实际应用中，只交换已经存在的两个方法是没有太大意义的。我们应该利用这个特性来给既有的方法添加新功能（听上去吊吊的）：

它的实现原理是：先通过分类增加一个新方法，然后将这个新方法和要增加功能的旧方法替换（旧方法名对应新方法的实现），这样一来，如果我们调用了旧方法，就会实现新方法了。

要点总结

在运行期，可以向类中新增或替换选择子所对应的方法实现。
使用另一份实现来替换原有的方法实现，这道工序叫做“方法调配”，开发者常用此技术向原有实现中添加新功能。
一般来说，只有调试程序的时候才需要在运行期修改方法实现，这种做法不宜滥用。

理解“类对象”的用意

在运行期程序库的头文件里定义了描述OC对象所用的数据结构：

typedef struct objc_class *Class;

    struct objc_class {
         Class isa;
         Class super_class;
         const char *name;
         long version;
         long info;
         long instance_size;
         struct objc_ivar_list *ivars;
         struct objc_method_list **methodLists;
         struct objc_cache *cache;
         struct objc_protocol_list *protocols;
};

在这里，isa指针指向了对象所属的类：元类（metaclass），它是整个结构体的第一个变量。super_class定义了本类的超类。
我们也可以向对象发送特定的方法来检视类的继承体系：自身属于哪一类；自身继承与哪一类。

我们使用isMemberOfClass:能够判断出对象是否为某个特定类的实例；
而isKindOfClass:方法能够判断出对象是否为某类或其派生类的实例。

这两种方法都是利用了isa指针获取对象所属的类，然后通过super_class类在继承体系中查询。在OC语言中，必须使用这种查询类型信息的方法才能完全了解对象的真实类型。因为对象类型无法在编译期决定。

尤其注意在集合类里获取对象时，通常要查询类型信息因为这些对象不是强类型的（strongly typed），将它们从集合类中取出来的类型通常是id，也就是能响应任何消息（编译期）。

所以如果我们对这些对象的类型把握不好，那么就会有可能造成对象无法响应消息的情况。因此，在我们从集合里取出对象后，通常要进行类型判断：

- (NSString*)commaSeparatedStringFromObjects:(NSArray*)array {

         NSMutableString *string = [NSMutableString new];

             for (id object in array) {
                    if ([object isKindOfClass:[NSString class]]) {
                            [string appendFormat:@"%@,", object];
                    } else if ([object isKindOfClass:[NSNumber class]]) {
                            [string appendFormat:@"%d,", [object intValue]];
                    } else if ([object isKindOfClass:[NSData class]]) {
                           NSString *base64Encoded = /* base64 encoded data */;
                            [string appendFormat:@"%@,", base64Encoded];
                    } else {
                            // Type not supported
                    }
              }
             return string;
}