1. Swift
2. Objective-C
3. Swift VS Objective-C
4. Xcode 使用
3. Swift VS Objective-C
本节从数据结构、编程思路和语言特性三个角度来对比 Swift 和 Objective-C 这两种语言的异同。
数据结构
Swift 为什么将 String、Array 和 Dictionary 设计成值类型
关键词： #引用类型 #值类型 #多线程 #协议
要回答 Swift 为什么将 String、Array 和 Dictionary 设计成值类型，就要和 Objective-C 中相同的数据类型作对比。Objective-C 中 String、Array 和 Dictionary 皆被设计成引用类型。
-
值类型相比于引用类型，最大的优势在于可以更高效的使用内存。值类型在栈上操作，引用类型在堆上操作。栈上的操作仅仅是单个指针的上下移动，而堆上的操作则牵涉合并、移位、重新链接等，也就是说，Swift 这样设计大幅减少了堆上内存的分配和回收的次数。同时，copy-on-write 又将值传递和复制的开销降到最低。
-
Swift 将 String、Array 和 Dictionary 设计成值类型也是为了线程安全。通过 Swift 的 let 设置，使得这些数据达到真正意义上的“不变”，也从根本上解决了多线程的内存访问和操作的顺序问题。
-
Swift 将 String、Array 和 Dictionary 设计成值类型还能提升 API 的灵活度。例如，通过实现 Collection 这样的协议，可以遍历 String，使得整个开发更加灵活高效。
如何用 Swift 将协议（protocol）中的部分方法设计成可选（optional）
关键词： #协议 #协议扩展
@optional 和 @required 是 Objective-C 中特有的关键字。
在 Swift 中，默认协议中的所有方法都是必须实现的。而且在协议中，方法不能直接被设置为 optional。下面给出两种解决方案：
-
在协议和方法前都加上 @objc 关键字，然后在方法前加上 optional 关键字。该方法实际上是把协议转化为 Objective-C 方法，然后进行可选定义。示例如下：
@objc protocol SomeProtocol { func requiredMethod() @objc optional func optionalMethod() } -
用扩展（extension）来规定可选方法。在 Swift 中，协议扩展可以定义部分方法的默认实现。这样，这些方法在实际调用中就是可选实现了。示例如下：
protocol SomeProtocol { func requiredMethod() func optionalMethod() } extension SomeProtocol { func optionalMethod() { print("已经默认实现了") } }
协议的代码实战
关键词： #协议
下面代码有什么问题？
protocol SomeProtocolDelegate {
func doSomething()
}
class SomeClss {
weak var delegate: SomeProtocolDelegate?
}
在上面代码中，协议属性定义会报错。
Swift 中的协议不仅能被 class 这样的引用类型实现，也能被 struct、enum 这样的值类型实现（这是和 Objective-C 最大的不同）。weak 关键字用于 ARC 环境下，为引用类型提供引用计数这样的内存管理，他是不能被用来修饰值类型的。
上面的代码有两种修正方法。
-
在 protocol 前面加上 @objc。在 Objective-C 中，协议只能由 class 来实现，这样一来，weak 修饰的对象就与 Objective-C 一样，只不过是 class 类型，修正如下:
@objc protocol SomeProtocolDelegate { func doSomething() } -
在 SomeProtocolDelegate 后添加关键词 class。如此一来，就声明了该协议只能由 class 来实现，代码修正如下：
protocol SomeProtocolDelegate: class { func doSomething() }
需要注意的是，以上两种修改后，该协议不能再被 struct、enum 等引用类型实现。
编程思路
在 Swift 和 Objective-C 的混编项目中，如何在 Swift 文件中调用 Objective-C 文件中定义的方法？如何在 Objective-C 文件中调用 Swift 文件中定义的方法
关键词： #头文件 #@objc
-
在 Swift 中， 若要使用 Objective-C 代码，则可以再桥接文件（通常明明 ProjectName-Bridging-Header.h）文件中添加 Objective-C 的头文件名称，这样即可以在 Swift 文件中调用 Objective-C 代码。一般情况下，Xcode 会在 Swift 项目中第一次创建 Objective-C 文件时，提示用户是否创建 ProjectName-Bridging-Header.h 文件。
-
在 Objective-C 中，若要调用 Swift 代码，则可以导入 Swift 生成的头文件 ProjectName-Swift.h 来实现。
加分回答：
- 在 Swift 文件中，若要将规定的固定的属性或者方法暴露给 Objective-C 使用，则可以在方法或者属性前加上 @objc 来声明。如果该类是 NSObject 的子类，那么 Swift 会在非 private 的方法或属性前自动加上 @objc。
比较 Swift 和 Objective-C 中的初始化方法（init）有什么异同
关键词： #初始化
一言以蔽之，Swift 中的初始化方法更加严格和准确。
-
在 Objective-C 中，初始化无法保证全部成员变量都初始化；编译器会对属性设置而无警告，但是在实际操作中会出现初始化不完全的问题。初始化方法与普通方法并无实际差别，可以多次调用。
-
在 Swift 中，初始化方法必须保证所有非 optional 的成员变量都完成初始化；同时，新增 convenience 和 required 两个修饰初始化方法的关键词 -- convenience 只是提供一种方便的初始化方法，必须通过调用同一个类中的 designated 初始化方法来完成。required 是强制子类重写父类中所修饰的初始化方法。
比较 Swift 和 Objective-C 中的协议（protocol）有什么异同
关键词： #协议
Swift 和 Objective-C 中协议的相同点在于：两者都可以被用作代理。Objective-C 中的 protocol 类似 Java 中的 Interface，在实际开发中用于用于适配器模式（Adapter Pattern）。
Swift 和 Objective-C 中协议的不同点在于：Swift 中的 protocol 还可以对接口进行抽象，例如 Sequence，配合扩展（extension）、泛型、关联类型等可以实现面向协议编程，从而大大提高这个代码的灵活性。同时，Swift 中的 protocol 还可以用于值类型，如结构体和枚举。
语言特性
谈谈对 Objective-C 和 Swift 动态性的理解
关键词： #动态特性 #runtime #面向协议编程
runtime 其实就是 Objective-C 的动态机制。runtime 执行的是编译后的代码，这时它可以动态加载对象，添加方法、修改属性、传递信息等。具体过程是：在 Objective-C 中，对象调用方法时，如 [self.tableView reload]，经历了两个阶段：
-
编译阶段： 编译器（compiler）会把这句话翻译成 objc_msgSend(self.tableView, @selector(reload))，把消息发送给 self.tableView。
-
运行阶段：接受者 self.tableView 会响应这个消息，其间可能会直接执行、转发消息，也可能会找不到这方法而导致程序崩溃。
所以，整个流程是：编译器翻译 -> 给接收者发送消息 -> 接收者响应消息。
例如，在 [self.tableView reload] 中，self.tableView 就是接收者，reload 就是消息，所以，方法调用的的格式在编译器看来是 [receiver message]。
其中，接受者如何响应消代码，就发生在运行时（runtime）。runtime 执行的是编译后的代码，这时，它可以动态加载对象、添加方法、修改属性、传递信息等。runtime 的运行机制，就是 Objective-C 的动态特性。
Swift 目前被公认是一门静态语言。它的动态特性都是通过桥接 OC 来实现的。如果要把其动态性写的更 “Swift” 一点，则可以用 protocol 来处理，比如，可以将 OC 中的 reflection 这样写：
if ([someImage respondsToSelector: @selector(shake)]) {
[someImage performSelector: shake];
}
在 Swift 中可以这样写：
if let shakeableImage = someImage as? Shakable {
shakeableImage.shake()
}
语言特性的代码实战
关键词： #动态特性 #协议 #扩展
看看下面代码会输出什么？
protocol Chef {
func makeFood()
}
extension Chef {
func makeFood() {
print("Make Food")
}
}
struct SeafoodChef: Chef {
func makeFood() {
print("Cook Seafood")
}
}
let chefOne: Chef = SeafoodChef()
let chefTwo: SeafoodChef = SeafoodChef()
chefOne.makeFood()
chefTwo.makeFood()
上面代码会打印出两行 "Cook Seafood"。
在 Swift 中，协议中的是动态派发，扩展中是静态派发。也就是说，协议中如果有方法声明，那么方法会根据对象的实际类型进行调用。
此题中的 makeFood() 方法在 Chef 协议中已经声明了，而 chefOne 虽然声明为 Chef，但实际实现为 SeafoodChef。所以，根据实际情况，makeFood() 会调用 SeafoodChef 中的实现，chefTwo 也是同样的道理。
追问：如果 Protocol 中没有声明 makeFood() 方法，代码又会输出什么？
代码会答应出两行结果：第一行是 “Make food”，第二行是 “Cook Seafood”。
因为协议中没有声明 makeFood() 方法，所以此时会按照扩展中的声明类型进行静态派发。也就是说，会根据对象的声明类型进行调用。chefOne 被声明为 Chef，所以调用扩展中的实现。chefTwo 被声明为 SeafoodChef，所以调用 SeafoodChef 的实现。
message send 如果找不到对象，则会如何进行后续处理
关键词： #动态特性
Message send 找不到对象分两种情况：对象为空（nil）；对象不为空，却找不到对应的方法、
-
对象为空时，Objective-C 向 nil 发送消息时有效的，在 runtime 中不会产生任何效果。如果消息中的方法返回值是对象，那么给 nil 发送消息返回 nil。如果消息中的方法返回值是结构体，那么给 nil 发送消息返回0。
-
对象不为空，却找不到对应的方法，时，程序有异常，引发 unrecognized selector。
什么事 method swizzling
关键词： #动态特性
每个类都会维护一个方法列表，其中方法名与其实现一一对应。即 SEL（方法名）和 IMP（指向实现的指针）的对应关系。method swizzling 可以在 runtime 时将 SEL 和 IMP 进行更换。比如， SELa 原来对应 IMPa，SELb 原来对应 IMPb，而在 method swizzling 之后，SELa 就可以对应 IMPb，SELb 可以对应 IMPa。下面是一个封装好的动态实现：
// 方法一中的 SEL 和 Method SEL
SEL oneSEL = @selector(methodOne:);
Method oneMethod = class_getInstanceMethod(selfClass, oneSEL);
// 方法二中的 SEL 和 Method SEL
SEL twoSEL = @selector(methodTwo:);
Method twoMethod = class_getInstanceMethod(selfClass, twoSEL);
// 给方法一添加实现，可以避免方法一直没实现
BOOL addSucc = class_addMethod(selfClass, oneSEL, method_getImplementation(twoMethod), method_getTypeEncoding(twoMethod));
if (addSucc) {
// 添加成功，将方法一的实现替换到方法二
class_replaceMethod(selfClass, twoSEL, method_getImplementation(oneMethod), method_getTypeEncoding(twoMethod));
} else {
// 添加失败：方法一已经有实现，直接将方法一和方法二的实现交换
method_exchangeImplementations(oneMethod, twoMethod);
}
加分回答：
-
方法交换应该保持唯一性和原子性。唯一性是指应该尽可能在 +load 方法中实现，这样可以保证方法一一定会被调用且不会出现异常。原子性是指使用 dispatch_once 来执行方法交换，这样可以保证只运行一次。
-
不要轻易使用 method swizzling。因为动态交换方法的实现并没有编译器的安全保证，可能会在运行时造成奇怪的问题。
Swift 和 Objective-C 的自省（Introspection）有什么不同
关键词： #动态特性
自省在 Objective-C 中就是：判断某个对象是否属于某个类的操作。它有一下两种形式：
[obj isKindOfClass: [SomeClass class]];
[obj isMemberOfClass: [SomeClass class]];
在上面的代码中，第一行中的代码中的 isKindOfClass 用于判断 obj 是否是 SomeClass 或其子类的实例对象。第二行代码中的 isMemberOfClass 则对 obj 作出判断，当且仅当 obj 是 SomeClass（非子类）的实例对象时，才返回真。这两个方法的使用有一个前提，即 obj 必须是 NSObject 或其子类。
在 Swift 中，由于很多 class 并非继承自 NSObject，故而 Swift 用 is 函数来进行判断，它相当于 isKindOfClass。这样做的优点是 is 函数斌可以用于任何 class 类型上，也可以用来判断 enume 和 struct 类型。
在 Swift 中继承自 NSObject 的类型，依然可以用 isKindOf 和 isMemberOf。这点与 Objective-C 相同。
加分回答：
自省经常与动态类性一起使用。动态类型就是 id 类型，任何类型的对象都可以用 id 来代指，这个时候常常用自省来判断对象的实际所属类型，如下：
id vehicle = SomeCarInstace;
if ([vehicle isKindOfClass: [Car class]]) {
NSLog(@"vehicle is a Car");
if ([vehicle isKindOfClass: [Tesla class]]) {
NSLog(@"vehicle is a Tesla");
}
} else if ([vehicle isKindOfClass: [Truck class]]) {
NSLog(@"vehicle is a Truck");
}
能否通过 Category 给已有的类添加属性（property）
关键词： #动态特性
可以通过 Category 给已有的类添加属性（property），无论是对 Objective-C 还是 Swift 而言。
在 Objective-C 中，正常情况下，给 Category 中添加属性会报错，提示找不到 setter 和 getter 方法，这是因为在 Category 中不会自动生成这两个方法。解决的方法就是引入运行时头文件，并配合关联对象的方法来实现。其中主要涉及的两个函数是 objc_getAssocicatedObject 和 objc_setAssociatedObject。在 Swift 中，解决方法与在 Objective-C 中相同，只是在写法上更加 Swift 化。
假如有个 class 叫 User。由于此 App 要打开国际市场，所以，产品经理要去 User 能满足能中间名字的外国人。于是我们回想在它的 Category 里添加 middleName 属性。实例的 Objective-C diamante如下：
// .h
#import "User.h"
@interface User (Foreign)
@property (nonatomic, copy) NSString *middleName;
@end
// .m
#import "User+Foreign.h"
#import <objc/runtime.h>
static void *middleNameKey = &middleNameKey;
@implementation User (Foreign)
- (void)setMiddleName:(NSString *)middleName {
objc_setAssociatedObject(self, &middleNameKey, middleName, OBJC_ASSOCIATION_COPY_NONATOMIC);
}
- (NSString *)middleName {
return objc_getAssociatedObject(self, &middleNameKey);
}
@end
下面解释下这段代码：
-
在 .h 文件中添加属性。
-
在 .m 文件中引入运行时头文件 <objc/runtime.h>，接着设置关联属性的 Key，最后实现 setter 和 getter。
其中，objc_setAssociatedObject 这个方法的四个参数分别为原对象、关联属性 Key、关联属性和关联策略。具体细节可参考苹果官方文档 API。
用 Swift 实现类似功能是这样的：
import Foundation
class User {
}
private var middleNameKey: Void?
extension User {
var middleName: String? {
get {
return objc_getAssociatedObject(self, &middleNameKey) as? String
}
set {
objc_setAssociatedObject(self, &middleNameKey, newValue, .OBJC_ASSOCIATION_COPY_NONATOMIC)
}
}
}
网友评论