Swift4.0复习协议

1.协议的定义:

/// 定义一个协议MyProt
protocol MyProt {
     
    /// 声明了一个实例方法foo，
    /// 其类型为：() -> Void
    func foo()
     
    /// 声明了一个实例方法doSomething，
    /// 其类型为(Int) -> Int?
    /// 它可用于结构体与枚举类型中的可修改存储式实例属性的方法
    mutating func doSomething(a: Int) -> Int?
     
    /// 声明了一个类型方法typeMethod，
    /// 其类型为() -> Void
    class func typeMethod()
     
    /// 声明了一个初始化器方法
    init(a: Int)
     
    /// 声明了一个下标
    subscript(index: Int) -> Int { get set }
     
    /// 声明了一个计算式实例属性
    var property: Int { get set }
     
    /// 声明了一个计算式类型属性，
    /// 并且是只读的
    static var typeProperty: Double { get }
}

2.协议的遵循：

struct Test: MyProt {
   var a: Int
   init(a: Int) {
      self.a = a
   }
}

3.协议的继承：

protocol ProtA {
    func foo()
    func method()
     
    var property: Int { get set }
}
 
/// 定义一个协议ProtB
protocol ProtB {
    mutating func method(a: Int)
     
    var property: Double { get set }
}
 
/// 定义了一个协议ProtC，
/// 它继承了ProtA与ProtB
protocol ProtC: ProtA, ProtB {
     
    func foo()
}

4.class协议：

“在一个协议后面使用 : class 即可将该协议声明为类协议，这样只有类类型才能遵循该协议，而结构体与枚举类型则不能遵循该协议。”

摘录来自: “大话Swift 4.0”。 iBooks.

5.协议组合：

/// 定义了一个协议ProtA
protocol ProtA {
    func foo()
    func method()
}
 
/// 定义一个协议ProtB
protocol ProtB {
    mutating func method(a: Int)
     
    var property: Int { get set }
}
 
/// 定义结构体Test，
/// 它遵循了ProtA与ProtB协议
struct Test: ProtA, ProtB {
     
    var a =
     
    /// 实现ProtA中的foo方法
    func foo() {
        print("This is a foo")
    }
     
    /// 实现ProtA中的method方法
    func method() {
        print("This is a method")
    }
     
    /// 实现ProtB中的method(a:)方法
    mutating func method(a: Int) {
        self.a += a
    }
     
    /// 实现ProtB中的property计算式实例属性
    var property: Int {
        get {
            return self.a
        }

// 声明了一个prot对象，
// 它同时遵循了ProtA与ProtB协议，
// 这里就使用了协议组合语法特性。
// 然后用Test结构体的对象实例为它初始化
var prot: ProtA & ProtB = Test()
 
prot.foo()
prot.method()
prot.property =
prot.method(a: )
 
// 打印：value = 15
print("value = \(prot.property)")

6.关联类型：

使用 associatedtype 关键字来声明关联类型。

typealias 关键字来指定关联类型的具体类型。

protocol ProtA {
    /// 这里声明了一个关联类型DataType
    associatedtype DataType
     
    /// 声明了实例方法method，
    /// 它具有一个DataType类型的形参value
    func method(value: DataType)
}
 
/// 定义了一个结构体MyStruct，
/// 并遵循了协议ProtA
struct MyStruct: ProtA {
     
    /// 这里通过typealias指定协议关联类型的具体类型，
    /// 在MyStruct类型中，
    /// DataType的具体类型为Int
    typealias DataType = Int
  }

7.关于协议中Self类型：表示遵循该协议的具体类型

/// 定义协议MyProt
protocol MyProt {
     
    /// 这里所声明的method方法含有一个Self类型的形参
    mutating func method(obj: Self)
}
 
/// 定义结构体类型MyStruct，
/// 遵循了协议MyProt
struct MyStruct: MyProt {
     
    /// 定义了一个存储式实例属性data，
    /// 它的类型为Int
    var data =
     
    /// 实现了MyProt中的method(obj:)方法
    mutating func method(obj: MyStruct) {
        data += obj.data
    }
}