动态类型和多方法
Swift 中我们虽然可以通过 typeof(of:) 来获取一个对象的动态类型 (也就是运行时的实际类型，而非代码指定或编译器看到的类型)。但是在使用中，Swift 现在却是不支持多方法的，也就是说，不能根据对象在动态时的类型进行合适的重载方法调用。
举个例子来说，在 Swift 里我们可以重载同样名字的方法，而只需要保证参数类型不同:
class Pet {}
class Cat: Pet {}
class Dog: Pet {}
func printPet(_ pet: Pet) {
print("Pet")
}
func printPet(_ cat: Cat) {
print("Cat")
}
func printPet(_ dog: Dog) {
print("Dog")
}
printPet(Cat()) // Cat
printPet(Dog()) // Dog
printPet(Pet()) // Pet
对于 Cat 或者 Dog 的实例，总是会寻找最合适的方法，而不会去调用一个通用的父类 Pet 的方法。这一切的行为都是发生在编译时的，如果我们写了下面这样的代码:
func printThem(_ pet: Pet, _ cat: Cat) {
printPet(pet)
printPet(cat)
}
printThem(Dog(), Cat()) // Pet Cat
打印时的 Dog 的类型信息并没有被用来在运行时选择合适的 printPet(_ dog: Dog) 版本的方法， 而是被忽略掉，并采用了编译期间决定的 Pet 版本的方法。
因为Swift 默认情况下是不采用动态派发的，因此方法的调用只能在编译时决定。
想要绕过这个限制，我们可能需要进行通过对输入类型做判断和转换：
func printThem(_ pet: Pet, _ cat: Cat) {
if let aCat = pet as? Cat {
printPet(aCat)
} else if let aDog = pet as? Dog {
printPet(aDog)
}
printPet(cat)
}
printThem(Dog(), Cat()) // Dog Cat
属性观察
属性观察 (Property Observers) 是 Swift 中一个很特殊的特性，利用属性观察我们可以在当前类型内监视对于属性的设定，并作出一些响应。Swift 中为我们提供了两个属性观察的方法，它们分别 是 willSet 和 didSet 。
在 willSet 和 didSet 中我们分别可以使用 newValue 和 oldValue 来获取将要设定的和已经设定的值。
属性观察的一个重要用处是作为设置值的验证。初始化方法对属性的设定，以及在 willSet 和 didSet 中对属性的再次设定都不会再次触发属性观察的调用，一般来说这会是你所需要的行为，可以放心使用能够。
在 Swift 中所声明的属性包括存储属性和计算属性两种。其中存储属性将会在内存中实际分配地址对属性进行存储，而计算属性则不包括背后的存储，只是提供 set 和 get 两种方法。
在同一个类型中，属性观察和计算属性是不能同时共存的。也就是说，想在一个属性定义中同时出现set 和 willSet 或 didSet 是一件办不到的事情。
计算属性中我们可以通过改写 set 中的内容来达到和 willSet 及 didSet 同样的属性观察的目的。
如果我们无法改动这个类，又想要通过属性观察做一些事情的话，可能就需要子类化这个类，并且重写它的属性了。重写的属性并不知道父类属性的具体实现情况，而只从父类属性中继承名字和类型，因此在子类的重载属性中我们是可以对父类的属性任意地添加属性观察的，而不用在意父类中到底是存储属性还是计算属性:
class A {
var number: Int {
get {
print("get")
return 1
}
set {
print("set")
}
}
}
class B: A {
override var number: Int {
willSet {
print("willSet")
}
didSet {
print("didSet")
}
}
}
let b = B()
b.number = 0
// 输出
// get
// willSet
// set
// didSet
set 和对应的属性观察的调用都在我们的预想之中。这里要注意的是 get 首先被调用了一次。 这是因为我们实现了 didSet ， didSet 中会用到 oldValue ，而这个值需要在整个 set 动作之前进行获取并存储待用，否则将无法确保正确性。如果我们不实现 didSet 的话，这次 get 操作也将不存在。
final
final 关键字可以用在 class， func 或者 var 前面进行修饰，表示不允许对该内容进行继承或重写操作。
Swift 中使用 final 的情况：
一、权限控制：
给一段代码加上 final 就意味着编译器向你作出保证，这段代码不会再被修改；同时，这也意味着你认为这段代码已经完备并且没有再被进行继承或重写的必要，因此这往往会是一个需要深思熟虑的决定。在 Cocoa 开发中 app 开发是一块很大的内容，对于大多数我们自己完成的面向 app 开发代码，其实不太会提供给别人使用，这种情况下即使是将所有自己写的代码标记为 final 都是一件无可厚非的事情 (但我并不是在鼓励这么做) -- 因为在需要的任何时候你都可以将这个关键字去掉以恢复其可继承性。而在开发给其他开发者使用的库时，就必须更深入地考虑各种使用场景和需求了。
一般来说，不希望被继承和重写会有这几种情况:
- 类或者方法的功能确实已经完备了
对于很多的辅助性质的工具类或者方法，可能我们会考虑加上 final。这样的类有一个比较大的特点，是很可能只包含类方法而没有实例方法。比如我们很难想到一种情况需要继承或重写一个负责计算一段字符串的 MD5 或者 AES 加密解密的工具类。这种工具类和方法的算法是经过完备验证和固定的，使用者只需要调用，而相对来说不可能有继承和重写的需求。
- 子类继承和修改是一件危险的事情
在子类继承或重写某些方法后可能做一些破坏性的事情，导致子类或者父类部分也无法正常工作 的情况。举个例子，在某个公司管理的系统中我们对员工按照一定规则进行编号，这样通过编号 我们能迅速找到任一员工。而假如我们在子类中重写了这个编号方法，很可能就导致基类中的依赖员工编号的方法失效。在这类情况下，将编号方法标记为 final 以确保稳定，可能是一种更好的做法。
二、 为了父类中某些代码一定会被执行
有时候父类中有一些关键代码是在被继承重写后必须执行的 (比如状态配置，认证等等)，否则将导致运行时候的错误。而在一般的方法中，如果子类重写了父类方法，是没有办法强制子类方法一定去调用相同的父类方法的。在 Objective-C 的时候我们可以通过指定 __attribute__((objc_requires_super)) 这样的属性来让编译器在子类没有调用父类方法时抛出警告。 在Swift 中对原来的很多attribute 的支持现在还缺失中，为了达到类似的目的，我们可以使用一 个 final 的方法，在其中进行一些必要的配置，然后再调用某个需要子类实现的方法，以确保正常运行:
class Parent {
final func method() {
print("开始配置")
//...必要的代码
methodImpl()
//...必要的代码
print("结束配置")
}
func methodImpl() {
fatalError("子类必须实现这个方法")
// 或者也可以给出默认实现
}
}
class Child: Parent {
override func methodImpl() {
print("子类的业务逻辑。。。")
}
}
let child = Child()
child.method()
//开始配置
//子类的业务逻辑。。。
//结束配置
这样，无论如何我们如何使用 method ，都可以保证需要的代码一定被运行过，而同时有给了子类继承和重写自定义具体实现的机会。
三、性能考虑
使用 final 的另一个重要理由是可能带来的性能改善。因为编译器能够从 final 中获取额外的信息，因此可以对类或者方法调用进行额外的优化处理。但是这个优势在实际表现中可能带来的好处其实就算与 Objective-C 的动态派发相比也十分有限，因此在项目还有其他方面可以优化 (一般来说会是算法或者图形相关的内容导致性能瓶颈) 的情况下，并不建议使用将类或者方法转为 final 的方式来追求性能的提升。