Swift之--面向协议编程

2018-12-11 本文已影响12人纯情_小火鸡

1. Swift - the First POP Language

在WWDC15上，苹果宣布Swift是世界上第一门面向协议编程(POP)语言。

2. 何为POP

实际上，POP就是通过协议扩展，协议继承和协议组合的方式来设计需要编写的代码。

在Swift中，值类型优先于类。然而，面向对象的概念不能很好地与结构体和枚举一起工作: 因为结构体和枚举不能够被继承。因此，作为面向对象的一大特征—继承就不能够应用于值类型了。

Sequences and collections in the standard library use value semantics, which makes it easy to reason about your code. Every variable has an independent value, and references to that value aren’t shared. For example, when you pass an array to a function, that function can’t accidentally modify the caller’s copy of the array.

值类型可以从协议继承，设置支持从多个协议继承，因此，使用POP让值类型成为了Swift中的一等公民。

3. Protocol 一元复始，万象更新

假设现在需要定义公共行为，如果使用类一般来说会在父类中定义功能，子类依赖继承可以得到父类的特性，或者自己重写该方法添加其他行为。这其实是一个好的选择，但是当方法越来越多或是需要实现在不同的类的功能，这个时候又需要给父类重新添加方法，或者是干脆重新创建类。

举个🌰：
假设：B、C 继承自 A，B1、B2继承自 B，C1、C2继承自 C
如果你发现 B1 和 C2 具有某些共同特性，
在OC中如果完全使用继承的做法是找到 B1 和 C2 的最近祖先，也就是 A，然后在 A 中添加一段代码。于是还得重写 B2 和 C1，禁用这个方法。

而协议通过描述实现类型应该实现什么来抽象建模。因为可以实现多协议，一种类型可以被拆分为若干个抽象，这样的话就可以将大的功能细化。

4. 分守要津

1. Protocol Extensions

提供协议方法的默认实现和协议属性的默认值，从而使它们成为可选；符合协议的类型可以提供自己的实现，也可以使用默认的实现。
添加协议中未声明的附加方法实现，并且实现协议的任何类型都可以使用到这些附加方法。这样就可以给遵循协议的类型添加特定的方法。

protocol Entity {
    var name: String {get set}
    static func uid() -> String
}

extension Entity {
    static func uid() -> String {
        return UUID().uuidString
    }
}

struct Order: Entity {
    var name: String
    let uid: String = Order.uid()
}
let order = Order(name: "My Order")
print(order.uid)

2. Protocol Inheritance

协议可以从其他协议继承，然后在它继承的需求之上添加功能，因此可以提供更细粒度和更灵活的设计。

protocol Persistable: Entity {
    func write(instance: Entity, to filePath: String)
    init?(by uid: String)
}

struct InMemoryEntity: Entity {
    var name: String
}

struct PersistableEntity: Persistable {
    var name: String
    func write(instance: Entity, to filePath: String) { // ...
    }  
    init?(by uid: String) {
        // try to load from the filesystem based on id
    }
}

3. Protocol Composition

类、结构体和枚举可以符合多个协议，它们可以采用多个协议的默认实现。这在概念上类似于多继承。这种组合的方式不仅比将所有需要的功能压缩到一个基类中更灵活，而且也适用于值类型。

struct MyEntity: Entity, Equatable, CustomStringConvertible {
    var name: String
    // Equatable
    public static func ==(lhs: MyEntity, rhs: MyEntity) -> Bool {
        return lhs.name == rhs.name
    }
    // CustomStringConvertible
    public var description: String {
        return "MyEntity: \(name)"
    }
}
let entity1 = MyEntity(name: "42")
print(entity1)
let entity2 = MyEntity(name: "42")
assert(entity1 == entity2, "Entities shall be equal")

5. 浮想联翩

以下代码会输出什么🤔❓

protocol TheProtocol {
    func method1()
}

extension TheProtocol {
    func method1() {
        print("Called method1 from TheProtocol")
    }
    func method2() {
        print("Called method2 from TheProtocol")
    }
}

struct Struct1: TheProtocol {
    func method1() {
        print("called method1 from Struct1")
    }
    
    func method2() {
        print("called method2 from Struct1")
    }
}

let s1 = Struct1()
s1.method1()
s1.method2()

print("\n-----------------\n")

let s2:TheProtocol = Struct1()
s2.method1()
s2.method2()

print("\n-----------------\n")

结果参考流程图：

flow_diagram.png

参考文献：
Protocol Oriented Programming in Swift
Swift protocol extension method dispatch
Protocol Oriented Programming in Swift