知名企业logo,高要seo整站优化,搜房网站要怎么 做,网站建设考察试卷理解“属性”这一概念
“属性”#xff08;property#xff09;是 Objective-C 的一项特性#xff0c;用于封装对象中的数据。Objective-C 对象通常会把其所需的数据保存为各种实例变量。实例变量一般通过“存取方法”来访问。其中#xff0c;“获取方法”#xff08;get…理解“属性”这一概念
“属性”property是 Objective-C 的一项特性用于封装对象中的数据。Objective-C 对象通常会把其所需的数据保存为各种实例变量。实例变量一般通过“存取方法”来访问。其中“获取方法”getter用于读取变量值而“设置方法”setter用于写入变量值。开发者可以令编译器自动编写与属性相关的存取方法。此特性引入了一种新的“点语法”使开发者可以更为容易地依照类对象来访问存放与其中的数据。 在类接口的 public 区段中声明一些实例变量:
interface EOCPerson : NSObject {publicNSString* _firstName;NSString* _lastName;privateNSString* _someInternalData;
}
end但是上面这种写法的问题是:对象布局在编译期就已经固定了。只要碰到访问 _firstName 变量的代码编译器就把其替换为“偏移量”这个偏移量是“硬解码”表示该变量距离存放对象的内存区域的起始地址有多远。这样做目前来看没问题但是如果在 _firstName 之前又多了一个实例变量
interface EOCPerson : NSObject {publicNSDate* _dateOfBirth;NSString* _firstName;NSString* _lastName;privateNSString* _someInternalData;
}
end原来表示 _firstName 的偏移量现在却指向_dateOfBirth 了。把偏移量硬解码于其中的那些代码都会读取到错误的值。
对比在类中加入 _dateOfBirth 这一实例变量之前与之后的内存布局其中假设指针为 4 个字节:
如果代码使用了编译期计算出来的偏移量那么在修改类定义之后必须重新编译否则就会出错。 Objective-C 的做法是把实例变量当做一种存储偏移量所用的“特殊变量”交由“类对象”保管。偏移量会在运行期查找如果类的定义变了那么存储的偏移量也就变了这样的话无论何时访问实例变量总能使用正确的偏移量。甚至可以在运行期向类中新增实例变量这就是稳固的“应用程序二进制接口”ABI。ABI 定义了许多内容其中一项就是生成代码时所应遵循的规范。有了这种“稳固的”的ABI我们就可以在 “class-continuation 分类” 或实现文件中定义实例变量了。所以说不一定要在接口中把全部实例变量都声明好可以将某些变量从接口的 public 区段移走以便保护与类实现有关的内部信息。 这个问题还有一种解决办法就是尽量不要直接访问实例变量而应该通过存取方法来做。这种就是使用属性了例如
interface EOCPerson : NSObjectproperty NSString *firstName;property NSString *lastName;
end上面使用属性的语法其实相当于下面这样的语法
interface EOCPerson : NSObject
- (NSString *)firstName;
- (void)setFirstName:(NSString *)firstName;
- (NSString *)lastName;
- (void)setLastName:(NSString *)lastName;
end访问属性使用“点语法”和直接调用存取方法之间没有丝毫差别
EOCPerson *aPerson [Person new];
aPerson.firstName Bob;
[aPerson setFirstName:Bob];如果使用了属性的话那么编译器就会自动编写访问这些属性所需的方法此过程叫做“自动合成”。但是这个过程由编译器在编译期执行所以编辑器里面看不到这些“合成方法”的源代码。编译器还要自动向类中添加适当类型的实例变量并且在属性名前面加下划线以此作为实例变量的名字。用synthesize 语法可以指定实例变量的名字之前博客写过这里不赘述了。 存取方法也可以自己实现如果你只实现了其中一个存取方法那么另外一个还是会由编译器来合成。还有一种办法能阻止编译器自动合成存取方法就是使用 dynamic 关键字它可以让编译器不自动创建实现属性所用的实例变量也不为其创建存取方法。 在编译访问属性的代码时即使编译器发现没有定义存取方法也不会报错它相信这些方法能在运行期找到。
属性的特质
在之前的博客里也写到过属性的特质这里再完善一些 属性特质有
原子性 在默认情况下由编译器所合成的方法会通过锁定机制确保其原子性atomicity。如果属性具有nonatomic特质则不使用同步锁。尽管没有名为atomic的特质如果某属性不具备nonatomic特质那它就是atomic。 读/写权限 readwrite读写特质属性拥有getter和setter方法 readonly只读特质仅拥有getter方法且只有当属性由synthesize实现时编译器才会为其合成getter方法内存管理 assignsetter方法只会执行针对“纯量类型”的简单赋值操作 strong为这种属性设置新值时setter方法会先保留新值并释放旧值然后再将新值设置上去。 weak为这种属性设置新值的时候设置方法既不保留新值也不释放旧值但是在属性所指的对象摧毁时属性值也会清空。 unsafe_unretained语义和assign相同但是适用于“对象类型”。当对象被摧毁时属性值不会自动清空 copy所属关系和strong类似但是setter方法不保留新值而是将其拷贝。当属性类型是NSString*时经常用此特质来保护其封装性。方法名 可通过如下特质来指定存取方法的方法名: getter 指定“获取方法”的方法名。如果某属性是 Boolean 型而你想为其获取方法加上 “is” 前缀那么就可以用这个方法来来指定。比如说在 UISwitch 类中表示“开关”switch是否打开的属性就是这样定义的: setter 指定“设置方法”的方法名。
通过上述特质可以微调由编译器所合成的存取方法。不过需要注意: 若是自己来实现这些存取方法那么应该保证其具备相关属性所声明的特质。
如果想在其他方法里设置属性值那么同样要遵守属性定义中所宣称的语义。例如
interface EOCPerson : NSManagedObject
property (copy) NSString *firstName;
property (copy) NSString *lastName;
- (instancetype)initWithFirstName:(NSString *)firstName lastName:(NSString *)lastName;
end在实现这个自定义的初始化方法时一定要遵循属性定义中宣称的 “copy”语义因为“属性定义”就相当于“类”和“待设置的属性值”之间所达成的契约。初始化方法的实现代码可以这样写:
implementation EOCPerson
- (instancetype)initWithFirstName:(NSString *)firstName lastName:(NSString *)lastName {if (self [super init]) {firstName [firstName copy];lastName [lastName copy];}return self;
}
end如果将这一套用到 EOCPerson 类上那就等于说其两个属性应该设为“只读”。用初始化方法设置好属性值之后就不能再改变了。于是可以把属性的定义改成这样:
property (copy, readonly) NSString *firstName;
property (copy, readonly) NSString *lastName;atomic 与 nonatomic 的区别是什么呢前面说过具备 atomic 特质的获取方法会通过锁定机制来确保其操作的原子性。这就是说如果两个线程读写同一属性那么不论何时总能看到有效的属性值。若是不加锁的话或者说使用 nonatomic 语义那么当其中一个线程正在改写某属性值时另外一个线程也许会突然闯入把尚未修改好的属性值读取出来。发生这种情况时线程读到的属性值可能不对。开发 iOS 程序会发现其中所有的属性都声明为 nonatomic。这样做的历史原因是:在 iOS 中使用同步锁的开销较大就会带来性能问题。一般情况下并不要求属性必须是“原子的”因为这并不能保证“线程安全”thread safety若要实现“线程安全”的操作还需要采用更为深层的锁定机制才行。例如一个线程在连续多次读取某属性值的过程中有别的线程在同时改写该值那么即便将属性声明为 atomic也还是会读取不同属性值。因此开发 iOS 程序时一般都是会使用 nonatomic 属性。
在对象内部尽量直接访问实例变量
使用 “点语法”通过存取方法来访问相关实例变量:
NSArray *components [fullName componentsSeparatedByString: ];
self.firstName [components objectAtIndex:0];
self.lastName [components objectAtIndex:1];不经由存取方法而是直接访问实例变量:
NSArray *components [fullName componentsSeparatedByString: ];
_firstName [components objectAtIndex:0];
_lastName [components objectAtIndex:1];这两种写法有几个区别: 由于不经过 Objective-C 的 “方法派发”步骤所以直接访问实例变量的速度当然比较快。在这种情况下编译器所生成的代码会直接访问保存对象实例变量的那块内存。 直接访问实例变量时不会调用其“设置方法”这就绕过了为相关属性所定义的“内存管理语义”。比方说如果在 ARC 下直接访问一个声明为 copy 的属性那么并不会拷贝该属性只会保留新值并释放旧值。 如果直接访问实例变量那么不会触发“键值观察”(KVO通知。这样做是否会产生问题还取决于具体的对象行为。 通过属性来访问有助于排查与之相关的错误因为可以给“获取方法”和或“设置方法”中新增“断点”监控该属性的调用者及其访问机。 有一种合理的折中方案那就是在写入实例变量时通过其“设置方法”来做而在读取实例变量时则直接访问之。此方法既能提高读取操作的速度又能控制对属性的写入操作。之所以要通过“设置方法”来写入实例变量其首要原因在于这样做能够确保相关属性的“内存管理语义”得以贯彻。 但是第一个要注意的地方是在初始化方法中应该如何设置属性值。这中情况下总是应该直接访问实例变量因为子类可能会“覆写”override设置方法。 另外一个需要注意的问题是 “惰性初始化”lazy initialization。在这种情况下必须通过“获取方法”来访问属性否则实例变量就永远不会初始化。 比如说EOCPerson 类也许会用一个属性来表示人脑中的信息这个属性所指代的对象相当复杂。由于此属性不常用而且创建该属性的成本较高所以我们可能会在“获取方法”中对其执行惰性初始化:
- (EOCBrain *)brain {if (!_brain) {_brain [Brain new];}return _brain;
}若没有调用 “获取方法”就直接访问实例变量则会看到尚未设置好的 brain所以说如果使用了 “惰性初始化”技术那么必须通过存取方法来访问 brain 属性。
在对象内部读取数据时应该直接通过实例变量来读而写入数据时则应该通过属性来写。在初始化方法及 dealloc 方法中总是应该直接通过实例变量来读写数据。有时会使用懒加载初始化技术配置某份数据这中情况下需要通过属性来读取数据。
理解“对象等同性”这一概念
以前的博客提过
当用 方法时若️_①两个变量是基本类型的变量️②两个变量都是数值型的变量不一定要求数据类型严格相等️③两个变量的值相等_。则判断返回真否则返回假。 而对于指针类型的变量则要两个指针指向同一个对象则返回真否则返回假。 当使用的两个类没有继承关系时编译器会提示警告。 而isEqual方法不严格要求两个指针变量指向同一个对象。所有指针变量都可以调用该方法来判断是否与其他指针变量相等。它要求两个指针变量指向同一个对象才返回真。
一般来说两个类型不同的对象总是不相等的unequal。某些对象提供了特殊的 “等同性判定方法”equality-checking method如果已经知道两个受测对象都属于同一个类那么就可以使用这种方法。以下述代码为例:
NSString *foo Badger 123;
NSString *bar [NSString stringWithFormat:Badger %i, 123];
BOOL equalA (foo bar);
BOOL equalB [foo isEqual:bar];
BOOL equalC [foo isEqualToString:bar];大家可以看到 与等同性判断方法之间的差别。 NSString 类实现了一个自己独有的等同性判断方法名叫 “isEqualToString:”。传递给该方法的对象必须是 NSString 否则结果未定义。调用该方法比调用 “isEqual:”方法快后者还要执行额外的步骤因为它不知道受测对象的类型。 NSObject 协议中有两个用于判断等同性的关键方法。
- (BOOL)isEqual:(id)object;(NSUInteger)hash;NSObject 类对这两个方法的默认实现是:当且仅当其“指针值”(可理解为内存地址) 完全相等时这两个对象才相等。若想在自定义的对象中正确覆写这些方法就必须先理解其约定。如果 “isEqual:”方法判定两个对象相等那么其hash 方法也必须返回同一个值但是如果两个对象的 hash 方法返回同一值那么 “isEqual:”方法未必会认为两者相等。 意思是如果两个对象通过isEqual:方法被认为相等它们的hash值必须相等。但是两个对象的hash相等并不意味着它们通过isEqual:也相等。 我们认为如果两个 EOCPerson 的所有字段均相等那么这两个对象就相等。于是 “isEqual:”方法可以完成
- (BOOL)isEqual:(id)object {//直接判断两个指针是否相等if (self object) {return YES;}//比较两个对象所属的类若不属于同一个类则两个对象不相等if ([self class] ! [object class]) {return NO;}//检测每个属性是否相等。只要其中有不相等的属性就判定两对象不等否则两对象相等EOCPerson *otherPerson (EOCPerson*)object;if (![_firstName isEqualToString:otherPerson.firstName]) {return NO;}if (![_lastName isEqualToString:otherPerson.lastName]) {return NO;}if (_age ! otherPerson.age) {return NO;}return YES;
}实现 hash 方法了。回想一下根据等同性约定若两对象相等则其哈希码hash“hash”一词也叫做“杂凑”、“散列”也相等但是两个哈希码相同的对象却未必相等。这是能否正确覆写 “isEqual:” 方法的关键所在。下面这种写法完全可行:
- (NSUInteger)hash {return 1337;
}不过若是这么写的话在 collection 中使用这种对象将产生性能问题。 hash 方法也可以这样来实现:
- (NSUInteger)hash {NSString *stringToHash [NSString stringWithFormat:%:%:%lu, _firstName, _lastName, (unsigned long)_age];return [stringToHash hash];
}这次所用的办法是将 NSString 对象中的属性都塞入另一个字符串中然后令 hash 方法返回该字符串的哈希码。还需要负担创建字符串的开销所以比返回单一值要慢。把这中对象添加到collection 中时也会产生性能问题。 最后一种计算哈希码的办法:
- (NSUInteger)hash {NSUInteger firstNameHash [_firstName hash];NSUInteger lastNameHash [_lastName hash];NSUInteger ageHash _age;return firstNameHash ^ lastNameHash ^ ageHash;
}这种做法既能保持较高效率又能使生成的哈希码至少位于一定范围之内而不会过于频繁的重复。
特定类的等同性判定方法
NSArray 与 NSDictionary 类也具有特殊的等同性判定方法前者名为“isEqualToArray:”后者名为“isEqualToDictionary:”。如果和其比较的对象不是数组或字典那么这两个方法会各自抛出异常。 如果经常需要判断等同性那么可能会自己来创建等同性判定方法在编写判定方法时也应一并覆写“isEqual:”方法。后者的常见实现方式为:如果受测的参数与接收该消息的对象都属于同一类那么久调用自己编写的判定方法否则就交由超类来判断。例
- (BOOL)isEqualToPerson:(EOCPerson *)otherPerson {if (self otherPerson) {return YES;}if (![_firstName isEqualToString:otherPerson.firstName]) {return NO;}if (![_lastName isEqualToString:otherPerson.lastName]) {return NO;}if (_age ! otherPerson.age) {return NO;}return YES;
}
- (BOOL)isEqual:(id)object {if ([self class] [object class]) {return [self isEqualToPerson:(EOCPerson *)object];} else {return [super isEqual:object];}
}等同性判定的执行深度
NSArray的检测方式是先看两个数组所含对象个数是否相同若相同则在每个对应位置的两个对象上调用其“isEqual:”方法如果对应位置上的对象均相等那么两个数组相等这叫做“深度等同性判定”。
容器中可变类的等同性
在容器中放入可变类对象的时候把某个对象放入 collection 之后就不应该再改变其哈希码了。因为collection 会把各个对象按照其哈希码分装到不同的 “箱子数组”中。如果某对象在放入“箱子”之后哈希码又变了那么其现在所处的这个箱子对它来说是“错误”的。要想解决这个问题需要确保_哈希码不是根据对象的 “可变部分”计算出来的_或是保证放入 collection 之后就不再改变对象内容了。
若想检测对象的等同性请提供 “isEqual:” 与 hash 方法。相同的对象必须具有相同的哈希码但是这两个哈希码相同的对象却未必相同。不要盲目地逐个检测每条属性而是应该依照具体需求来制定检测方案。编写 hash 方法时应该使用计算速度快而且哈希码碰撞几率低的算法。
以“类族模式”隐藏实现细节
“类族”(类簇)是一种很有用的模式可以隐藏 “抽象基类”。Objective-C 的系统框架中普遍使用此模式。该模式可以灵活应对多个类将它们的实现细节隐藏在抽象基类后面以保持接口简洁。用户无须自己创建子类实例只需调用基类方法来创建即可。
创建类族
现在举例来演示如何创建类族首先要定义抽象基类:
typedef NS_ENUM(NSUInteger, EOCEmployeeType) {EOCEmployeeTypeDeveloper,EOCEmployeeTypeDesigner,EOCEmployeeTypeFinance
};
interface EOCEmployee : NSObject
property (copy) NSString *name;
property NSUInteger salary;(EOCEmployee *)employeeWithType:(EOCEmployeeType)type;
- (void)doADayWork;
end (EOCEmployee *)employeeWithType:(EOCEmployeeType)type {switch (type) {case EOCEmployeeTypeDeveloper:return [EOCEmployeeDeveloper new];break;case EOCEmployeeTypeDesigner:return [EOCEmployeeTypeDesigner new];break;case EOCEmployeeTypeFinance:return [EOCEmployeeTypeFinance new];break;}
}
- (void)doADayWork {}
end每个“实体子类”都从基类继承而来:
interface EOCEmployeeDeveloper : EOCEmployee
endimplementation EOCEmployeeDeveloper
- (void)doADayWork {[self writeCode];
}
end基类实现了一个“类方法”该方法根据待创建的类别分配好对应的类实例。这种“工厂模式”是创建类族的办法之一。 如果对象所属的类位于某个类族中那么在查询其类型信息时你可能觉得自己创建了某个类的实例然而实际上创建的却是其子类的实例。在 Employee 这个例子中[employee isMemberOfClass:[EOCEmployee class]] 似乎会返回 YES但实际上返回的却是NO因为 employee 并非 Employee 类的实例而是其某个子类的实例。
cocoa 里的类族
大部分 collection 类都是某个类族中的抽象基类例如 NSArray 与其可变版本 NSMutableArray。实际上有两个抽象基类一个用于不变数组另一个用于可变数组。尽管具备公共接口的类有两个但仍然可以合起来算作一个类族。不可变的类定义了对所有数组都通用的方法而可变的类型则定义了那些只适用于可变数组的方法。两个类共属同一类族这意味着二者在实现各自类型的数组时可以共用实现代码此外还能够把可变数组复制为不可变数组反之亦然。 在使用 NSArray 的 alloc 方法来获取实例时该方法首先会分配一个属于某类的实例此实例充当“占位数组”placeholder array。该数组稍后会转为另一个类的实例而那个类则是 NSArray 的实体子类。 若想判断某对象是否位于类族中不要直接检测两个“类对象”是否等同而应该采用下列代码:
id maybeAnArray ... ;
if ([maybeAnArray isKindOfClass:[NSArray class]]) {...
}在 Employee 这个例子中若是没有 “工厂方法”的源代码那就无法向其中新增雇员类别了。然而对于 Cocoa 中 NSArray 这样的类族来说还是有办法新增子类的但是需要遵守几条规则: 子类应该继承自类族中的抽象基类。 若要编写 NSArray 类族的子类则需令其继承自不可变数组的基类或者可变数组的基类。 子类应该定义自己的数据存储方式。 开发者编写 NSArray 子类时经常在这个问题上受阻。子类必须用一个实例变量来存放数组中对象。这似乎与大家预想的不同我们以为 NSArray 自己肯定会保存那些对象所以在子类中就无须再存一份了。但是大家要记住 NSArray 本身只不过是包在其他隐藏对象外面的壳它仅仅定义了所有数组都需要具备的一些接口。对于这个自定义的数组子类来说可以用 NSArray 来保存其实例。 子类应当覆写超类文档中指明需要覆写的方法。 在每个抽象基类中都有一些子类必须覆写的方法。比如说想要编写 NSArray 的子类就需要实现 count 及 “objectAtIndex:”方法。像 lastObject 这种方法则无须实现因为基类可以根据前两个方法实现出这个方法。在类族中实现子类时所需要遵循的规范一般都会定义于基类的文档之中编码前应该先看看。 类族模式可以把实现细节隐藏在一套简单的公共接口后面。系统框架中经常使用 类族。从类族的公共抽象基类中继承子类时要当心若有开发文档则应首先阅读。
在既有类中使用关联对象存放自定义数据
有时需要在对象中存放相关信息。这时我们通常从对象所属的类中继承一个子类然后改用这个子类对象。然而并非所有情况下都能这么做有时候类的实例可能是由某种机制所创建的而开发者无法令这种机制创建出自己所写的子类实例。Objective-C 中有一项强大的特性可以解决此问题这就是“关联对象”。
理解objc_msgSend的作用
在对象上调用方法OC上叫“消息传递”。消息有“名称”name或“选择子”selector可以接受参数而且可能还有返回值。 C 语言使用“静态绑定”也就是说在编译期就能决定运行时所调用的函数。例如
#import stdio.h
void printA(void) {printf(A);
}
void printB (void){printf(B);
}
void doTing(int type) {if (type 0) {printA();} else {printB();}
}但是如果这样写
#import stdio.h
void printA(void) {printf(A);
}
void printB (void){printf(B);
}
void doTing(int type) {void(*func)(void);if (type 0) {func printA;} else {func printB;}
}这时就得使用“动态绑定”了因为所要调用的函数直到运行期才能确定。编译器在这种情况下生成的指令与刚才那个例子不同在第一个例子中if 与 else 语句里面都有函数调用指令。而在第二个例子中只有一个函数调用指令不过待调用的函数地址无法硬编码在指令之中而是要在运行期读取出来。 在 Objective-C 中如果向某对象传递消息那就会使用动态绑定机制来决定需要调用的方法。在底层所有方法都是普通的 C 语言函数然而对象收到消息之后究竟该调用哪个方法则完全于运行期决定甚至可以在程序运行时改变这些特性使得 Objective-C 成为一门真正的动态语言。 给对象发送消息可以这样来写
id returnValue [someObject messageName:parameter];在本例中someObject 叫做“接收者”messageName 叫做“选择子”。选择子与参数合起来称为“消息”。编译器看到此消息后将其转换为一条标准的 C 语言函数调用所调用的函数乃是消息传递机制中的核心函数叫做 objc_msgSend其原型是:
void objc_msgSend(id self, SEL cmd, ...)这是个可变参数函数第一个参数代表接收者第二个参数代表选择子后续参数就是消息中的那些参数编译器会把刚才那个例子中的消息转换为如下函数:
id returnValue objc_msgSend(someObject, selectro(messageName:), parameter);objc_msgSend 函数会依据接收者与选择子的类型来调用适当的方法。为了完成此操作该方法需要在接收者所属的类中搜寻其“方法列表”如果能找到与选择子名称相符的方法就跳至其实现代码。若是找不到那就沿着继承体系继续向上查找等找到合适的方法之后再跳转。如果最终还是找不到相符的方法那就执行“消息转发”操作。 objc_msgSend 会将匹配结果缓存在“快速映射表”里面每个类都有这样一块缓存若是稍后还向该类发送与选择子相同的消息那么执行起来就很快了
其他特殊情况则需要交由 Objective-C 运行环境中的另一个函数来处理 objc_msgSend_stret如果待发送的消息要返回结构体那么可交由此函数处理。只有当 CPU 的寄存器能够容纳得下消息返回类型时这个函数才能处理此消息。若是返回值无法容纳于 CPU 寄存器中比如说返回的结构体太大了那么就由另一个函数执行派发。此时那个函数会通过分配在栈上的某个变量来处理消息所返回的结构体。 objc_msgSend_fpret如果消息返回的是浮点数那么可交由此函数处理。在某些架构的 CPU 中调用函数时需要对 “浮点数寄存器”floating-point register做特殊处理也就是说通常所用的 objc_msgSend 在这种情况下并不合适。这个函数是为了处理 x86 等架构 CPU 中某些令人稍觉惊讶的奇怪状况。 objc_msgSendSuper如果要给超类发消息例如super message:parameter那么就交由此函数处理。也有另外两个与 objc_msgSend 和 objc_msgSend_fpret 等效的函数用于处理发给 super 的相应消息。 消息由接收者、选择子及参数构成。给某对象“发送消息”invoke a message(invoke 也是“调用”的意思此处为了与“call”相区隔将其临时译为“发送”也可能理解为“激发”“触发”) 也就相当于在该对象上“调用方法”call a method。 发给某对象的全部消息都要由“动态消息派发系统”dynamic message dispatch system来处理该系统会查出对应的方法并执行其代码。
理解消息转发机制
在编译期向类发送了其无法解读的消息并不会报错因为在运行期可以继续向类中添加方法所以编译器在编译时还无法确知类中到底会不会有某个方法实现。当对象接收到无法解读的消息后就会启动“消息转发”机制程序员可经由此过程告诉对象应该如何处理未知消息。 开发者在编写自己的类时可于转发过程中设置挂钩用以执行预定的逻辑而不使应用程序崩溃。 消息转发分为两大阶段。 第一阶段先看接收者所属的类能否动态添加方法以处理当前“未知的选择子”这叫做“动态方法解析”。 第二阶段涉及“完整的消息转发机制”。如果运行期系统已经把第一阶段执行完了那么接收者自己就无法再以动态新增方法的手段来响应包含该选择子的消息了。此时运行期系统会请求接收者以其他手段来处理与消息相关的方法调用。这又细分为两小步。首先请接收者看看有没有其他对象能处理这条消息。若有则运行期系统会把消息转给那个对象于是消息转发过程结束一切如常。若没有“备援的接收者”则启动完整的消息转发机制运行期系统会把与消息有关的全部细节都封装到NSInvocation对象中再给接收者最后一次机会令其设法解决当前还未处理的这条消息。 动态方法解析
对象在收到无法解读的消息后首先将调用其所属类的下列类方法 (BOOL)resolveInstanceMethod:(SEL)selector 该方法的参数就是那个未知的选择子其返回值为Boolean类型表示这个类是否能新增一个实例方法用以处理此选择子。 使用这种办法的前提是相关方法的实现代码已经写好只等着运行的时候动态插在类里面就可以了。
备援接收者
当前接收者还有第二次机会能处理未知的选择子在这一步中运行期系统会问它能不能把这条消息转给其他接收者来处理。与该步骤对应的处理方法如下
- (id)forwardingTargetForSelector:(SEL)selector 方法参数代表未知的选择子若当前接收者能找到备援对象则将其返回若找不到就返回nil。通过此方案我们可以用“组合”来模拟出“多重继承”的某些特性。 请注意我们无法操作经由这一步所转发的消息。若是想在发送给备援接收者之前先修改消息内容那就得通过完整的消息转发机制来做了。
完整的消息转发
如果转发算法已经来到这一步的话那么唯一能做的就是启用完整的消息转发机制了。首先创建NSInvocation对象把与尚未处理的那条消息有关的全部细节都封于其中。此对象包含选择子、目标target及参数。在触发NSInvocation对象时“消息派发系统”把消息指派给目标对象。 此步骤会调用下列方法来转发消息
- (void)forwardInvocation:(NSInvocation*)invocation 这个方法可以实现得很简单只需改变调用目标使消息在新目标上得以调用即可。然而这样实现出来的方法与“备援接收者”方案所实现的方法等效所以很少有人采用这么简单的实现方式。比较有用的实现方式为在触发消息前先以某种方式改变消息内容比如追加另外一个参数或是改换选择子等等。 实现此方法时若发现某调用操作不应由本类处理则需调用超类的同名方法。这样的话继承体系中的每个类都有机会处理此调用请求直至NSObject。如果最后调用了NSObject类的方法那么该方法还会继而调用“doesNotRecognizeSelector:”以抛出异常此异常表明选择子最终未能得到处理。
消息转发全流程
若对象无法响应某个选择子则进入消息转发流程。通过运行期的动态方法解析功能我们可以在需要用到某个方法时再将其加入类中。对象可以把其无法解读的某些选择子转交给其他对象来处理。经过上述两步之后如果还是没办法处理选择子那就启动完整的消息转发机制。
用“方法调配技术”调试“黑盒方法”
在运行期改变与给定的选择子名称相对应的方法此方案经常称为 “方法调配”。 类的方法列表会把选择子的名称映射到相关的方法实现之上使得“动态消息派发系统”能够据此找到应该调用的方法。这些方法均以函数指针的形式来表示这种指针叫做 IMP其原型如下
id (*IMP)(id, SEL, ...)在运行期可以向类中新增或替换选择子所对应的方法实现。使用另一份实现来替换原有的方法实现这道工序叫做“方法调配”开发者常用此技术向原有实现中添加新功能。一般来说只有调试程序的时候才需要在运行期修改方法实现这种做法不宜滥用。
理解“类对象”的用意
“在运行期检视对象类型”这一操作也叫做“类型信息查询”这个强大而有用的特性内置于Foundation框架的NSObject协议里凡是由公共根类继承而来的对象都要遵从此协议。在程序中不要直接比较对象所属的类明智的做法是调用“类型信息查询方法”。 每个Objective-C对象实例都是指向某块内存数据的指针。所以在声明变量时类型后面要跟一个“*”字符
NSString *pointerVariable Some string; 对于通用的对象类型id由于其本身已经是指针了所以我们能够这样写
id genericTypedString Some string; 上面这种定义方式与用NSString*来定义相比其语法意义相同。唯一区别在于如果声明时指定了具体类型那么在该类实例上调用其所没有的方法时编译器会探知此情况并发出警告信息。 id类型本身定义在这里
typedef struct objc_object { Class isa;
} *id; 由此可见每个对象结构体的首个成员是Class类的变量。该变量定义了对象所属的类通常称为“isa”指针。 Class对象也定义在运行期程序库的头文件中
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指针这说明Class本身亦为Objective-C对象。 结构体里还有个变量叫做super_class它定义了本类的超类。类对象所属的类型也就是isa指针所指向的类型是另外一个类叫做“元类”metaclass用来表述类对象本身所具备的元数据。 “类方法”就定义于此处因为这些方法可以理解成类对象的实例方法。每个类仅有一个“类对象”而每个“类对象”仅有一个与之相关的“元类”。
在类继承体系中查询类型信息
可以用类型信息查询方法来检视类继承体系。 “isMemberOfClass:”能够判断出对象是否为某个特定类的实例。 “isKindOfClass:”能够判断出对象是否为某类或其派生类的实例。
由于Objective-C使用“动态类型系统”所以用于查询对象所属类的类型信息查询功能非常有用。从collection中获取对象时通常会查询类型信息这些对象不是“强类型的”把它们从collection中取出来时其类型通常是id。如果想知道具体类型那就可以使用类型信息查询方法。 也可以用比较类对象是否等同的办法来做。若是如此那就要使用操作符。应该尽量使用类型信息查询方法。
每个实例都有一个指向Class对象的指针用以表明其类型而这些Class对象则构成了类的继承体系。如果对象类型无法在编译期确定那么就应该使用类型信息查询方法来探知。尽量使用类型信息查询方法来确定对象类型而不要直接比较类对象因为某些对象可能实现了消息转发功能。
