Swift 類掏湾，結(jié)構(gòu)體或枚舉類型都可以遵循協(xié)議蓬坡，并提供具體實現(xiàn)來完成協(xié)議定義的方法和功能。

protocol SomeProtocol {
    // 協(xié)議內(nèi)容
}

要使類遵循某個協(xié)議，需要在類型名稱后加上協(xié)議名稱捣作，中間以冒號:分隔，作為類型定義的一部分江场。遵循多個協(xié)議時甩牺，各協(xié)議之間用逗號,分隔。

struct SomeStructure: FirstProtocol, AnotherProtocol {
    // 結(jié)構(gòu)體內(nèi)容
}

如果類在遵循協(xié)議的同時擁有父類煌茬，應(yīng)該將父類名放在協(xié)議名之前斥铺，以逗號分隔。

class SomeClass: SomeSuperClass, FirstProtocol, AnotherProtocol {
    // 類的內(nèi)容
}

1. 對屬性的規(guī)定

協(xié)議用于指定特定的實例屬性或類屬性坛善，而不用指定是存儲型屬性或計算型屬性晾蜘。此外還必須指明是只讀的還是可讀可寫的邻眷。

協(xié)議中的通常用var來聲明變量屬性，在類型聲明后加上set get來表示屬性是可讀可寫的剔交，只讀屬性則用get來表示耗溜。

protocol classa {
    var marks: Int { get set }
    var result: Bool { get }
    
    func attendance() -> String
    func markssecured() -> String
    
}

protocol classb: classa {
    var present: Bool { get set }
    var subject: String { get set }
    var stname: String { get set }
}

class classc: classb {
    var marks = 96
    let result = true
    var present = false
    var subject = "Swift 協(xié)議"
    var stname = "Protocols"
    
    func attendance() -> String {
        return "The \(stname) has secured 99% attendance"
    }
    
    func markssecured() -> String {
        return "\(stname) has scored \(marks)"
    }
}

let studdet = classc()
studdet.stname = "Swift"
studdet.marks = 98
studdet.markssecured()

print(studdet.marks)
print(studdet.result)
print(studdet.present)
print(studdet.subject)
print(studdet.stname)

// 98
// true
// false

2. 結(jié)構(gòu)體、枚舉的可變方法的規(guī)定

Swift對mutating方法的規(guī)定,有時需要在方法中改變它的實例省容。

例如抖拴，值類型(結(jié)構(gòu)體，枚舉)的實例方法中腥椒，將mutating關(guān)鍵字作為函數(shù)的前綴阿宅，寫在func之前，表示可以在該方法中修改它所屬的實例及其實例屬性的值笼蛛。

protocol daysofaweek {
    mutating func show()
}

enum days: daysofaweek {
    case sun, mon, tue, wed, thurs, fri, sat
    mutating func show() {
        switch self {
        case .sun:
            self = .sun
            print("Sunday")
        case .mon:
            self = .mon
            print("Monday")
        case .tue:
            self = .tue
            print("Tuesday")
        case .wed:
            self = .wed
            print("Wednesday")
        case .thurs:
            self = .thurs
            print("Wednesday")
        case .fri:
            self = .fri
            print("Wednesday")
        case .sat:
            self = .sat
            print("Saturday")
        default:
            print("NO Such Day")
        }
    }
}

var res = days.wed
res.show()

// Wednesday

3. 對構(gòu)造器的規(guī)定

協(xié)議可以要求它的遵循者實現(xiàn)指定的構(gòu)造器洒放。

你可以像書寫普通的構(gòu)造器那樣，在協(xié)議的定義里寫下構(gòu)造器的聲明滨砍，但不需要寫花括號和構(gòu)造器的實體往湿，語法如下：

protocol SomeProtocol {
   init(someParameter: Int)
}

protocol tcpprotocol {
   init(aprot: Int)
}
協(xié)議構(gòu)造器規(guī)定在類中的實現(xiàn)
你可以在遵循該協(xié)議的類中實現(xiàn)構(gòu)造器，并指定其為類的指定構(gòu)造器或者便利構(gòu)造器惋戏。在這兩種情況下领追，你都必須給構(gòu)造器實現(xiàn)標(biāo)上"required"修飾符：

class SomeClass: SomeProtocol {
   required init(someParameter: Int) {
      // 構(gòu)造器實現(xiàn)
   }
}

protocol tcpprotocol {
   init(aprot: Int)
}

class tcpClass: tcpprotocol {
   required init(aprot: Int) {
   }
}

使用required修飾符可以保證：所有的遵循該協(xié)議的子類，同樣能為構(gòu)造器規(guī)定提供一個顯式的實現(xiàn)或繼承實現(xiàn)响逢。

如果一個子類重寫了父類的指定構(gòu)造器绒窑，并且該構(gòu)造器遵循了某個協(xié)議的規(guī)定，那么該構(gòu)造器的實現(xiàn)需要被同時標(biāo)示required和override修飾符：

protocol tcpprotocol {
    init(no1: Int)
}

class mainClass {
    var no1: Int // 局部變量
    init(no1: Int) {
        self.no1 = no1 // 初始化
    }
}

class subClass: mainClass, tcpprotocol {
    var no2: Int
    init(no1: Int, no2 : Int) {
        self.no2 = no2
        super.init(no1:no1)
    }
    // 因為遵循協(xié)議舔亭，需要加上"required"; 因為繼承自父類些膨，需要加上"override"
    required override convenience init(no1: Int)  {
        self.init(no1:no1, no2:0)
    }
}
let res = mainClass(no1: 20)
let show = subClass(no1: 30, no2: 50)

print("res is: \(res.no1)")
print("res is: \(show.no1)")
print("res is: \(show.no2)")

res is: 20
res is: 30
res is: 50

4. 協(xié)議類型

盡管協(xié)議本身并不實現(xiàn)任何功能，但是協(xié)議可以被當(dāng)做類型來使用钦铺。

協(xié)議可以像其他普通類型一樣使用订雾，使用場景:

• 作為函數(shù)、方法或構(gòu)造器中的參數(shù)類型或返回值類型
• 作為常量矛洞、變量或?qū)傩缘念愋?/li>
• 作為數(shù)組洼哎、字典或其他容器中的元素類型

protocol Generator {
    associatedtype members
    func next() -> members?
}

var items = [10,20,30].makeIterator()
while let x = items.next() {
    print(x)
}

for lists in [1,2,3].map( {i in i*5}) {
    print(lists)
}

print([100,200,300])
print([1,2,3].map({i in i*10}))


/*
10
20
30
5
10
15
[100, 200, 300]
[10, 20, 30]
*/

5. 在擴展中添加協(xié)議成員

我們可以可以通過擴展來擴充已存在類型( 類，結(jié)構(gòu)體缚甩，枚舉等), 擴展可以為已存在的類型添加屬性谱净，方法，下標(biāo)腳本擅威，協(xié)議等成員壕探。

protocol AgeClasificationProtocol {
   var age: Int { get }
   func agetype() -> String
}

class Person {
   let firstname: String
   let lastname: String
   var age: Int
   init(firstname: String, lastname: String) {
      self.firstname = firstname
      self.lastname = lastname
      self.age = 10
   }
}

extension Person : AgeClasificationProtocol {
   func fullname() -> String {
      var c: String
      c = firstname + " " + lastname
      return c
   }
   
   func agetype() -> String {
      switch age {
      case 0...2:
         return "Baby"
      case 2...12:
         return "Child"
      case 13...19:
         return "Teenager"
      case let x where x > 65:
         return "Elderly"
      default:
         return "Normal"
      }
   }
}

6. 協(xié)議的繼承

協(xié)議能夠繼承一個或多個其他協(xié)議，可以在繼承的協(xié)議基礎(chǔ)上增加新的內(nèi)容要求郊丛。

協(xié)議的繼承語法與類的繼承相似李请，多個被繼承的協(xié)議間用逗號分隔：
protocol InheritingProtocol: SomeProtocol, AnotherProtocol {
    // 協(xié)議定義
}

protocol Classa {
    var no1: Int { get set }
    func calc(sum: Int)
}

protocol Result {
    func print(target: Classa)
}

class Student2: Result {
    func print(target: Classa) {
        target.calc(1)
    }
}

class Classb: Result {
    func print(target: Classa) {
        target.calc(5)
    }
}

class Student: Classa {
    var no1: Int = 10
    
    func calc(sum: Int) {
        no1 -= sum
        print("學(xué)生嘗試 \(sum) 次通過")
        
        if no1 <= 0 {
            print("學(xué)生缺席考試")
        }
    }
}

class Player {
    var stmark: Result!
    
    init(stmark: Result) {
        self.stmark = stmark
    }
    
    func print(target: Classa) {
        stmark.print(target)
    }
}

var marks = Player(stmark: Student2())
var marksec = Student()

marks.print(marksec)
marks.print(marksec)
marks.print(marksec)
marks.stmark = Classb()
marks.print(marksec)
marks.print(marksec)
marks.print(marksec)

/*
學(xué)生嘗試 1 次通過
學(xué)生嘗試 1 次通過
學(xué)生嘗試 1 次通過
學(xué)生嘗試 5 次通過
學(xué)生嘗試 5 次通過
學(xué)生缺席考試
學(xué)生嘗試 5 次通過
學(xué)生缺席考試
*/

7. 類專屬協(xié)議

你可以在協(xié)議的繼承列表中,通過添加class關(guān)鍵字,限制協(xié)議只能適配到類class類型,class關(guān)鍵字必須是第一個出現(xiàn)在協(xié)議的繼承列表中瞧筛，其后，才是其他繼承協(xié)議导盅。格式如下：

protocol SomeClassOnlyProtocol: class, SomeInheritedProtocol {
    // 協(xié)議定義
}

protocol TcpProtocol {
    init(no1: Int)
}

class MainClass {
    var no1: Int // 局部變量
    init(no1: Int) {
        self.no1 = no1 // 初始化
    }
}

class SubClass: MainClass, TcpProtocol {
    var no2: Int
    init(no1: Int, no2 : Int) {
        self.no2 = no2
        super.init(no1:no1)
    }
    // 因為遵循協(xié)議较幌，需要加上"required"; 因為繼承自父類，需要加上"override"
    required override convenience init(no1: Int)  {
        self.init(no1:no1, no2:0)
    }
}

let res = MainClass(no1: 20)
let show = SubClass(no1: 30, no2: 50)

print("res is: \(res.no1)")
print("res is: \(show.no1)")
print("res is: \(show.no2)")

// res is: 20
// res is: 30
// res is: 50

8. 協(xié)議合成

Swift 支持合成多個協(xié)議白翻，這在我們需要同時遵循多個協(xié)議時非常有用乍炉。

protocol Stname {
    var name: String { get }
}

protocol Stage {
    var age: Int { get }
}

struct Person: Stname, Stage {
    var name: String
    var age: Int
}

func show(celebrator: Stname & Stage) {
    print("\(celebrator.name) is \(celebrator.age) years old")
}

let studname = Person(name: "Priya", age: 21)
print(studname)

let stud = Person(name: "Rehan", age: 29)
print(stud)

let student = Person(name: "Roshan", age: 19)
print(student)

// Person(name: "Priya", age: 21)
// Person(name: "Rehan", age: 29)
// Person(name: "Roshan", age: 19)

9. 檢驗協(xié)議的一致性

你可以使用is和as操作符來檢查是否遵循某一協(xié)議或強制轉(zhuǎn)化為某一類型。

protocol HasArea {
    var area: Double { get }
}

// 定義了Circle類困檩，都遵循了HasArea協(xié)議
class Circle: HasArea {
    let pi = 3.1415927
    var radius: Double
    var area: Double { return pi * radius * radius }
    init(radius: Double) { self.radius = radius }
}

// 定義了Country類，都遵循了HasArea協(xié)議
class Country: HasArea {
    var area: Double
    init(area: Double) { self.area = area }
}

// Animal是一個沒有實現(xiàn)HasArea協(xié)議的類
class Animal {
    var legs: Int
    init(legs: Int) { self.legs = legs }
}

let objects: [AnyObject] = [
    Circle(radius: 2.0),
    Country(area: 243_610),
    Animal(legs: 4)
]

for object in objects {
    // 對迭代出的每一個元素進(jìn)行檢查那槽，看它是否遵循了HasArea協(xié)議
    if let objectWithArea = object as? HasArea {
        print("面積為 \(objectWithArea.area)")
    } else {
        print("沒有面積")
    }
}

// 面積為 12.5663708
// 面積為 243610.0
// 沒有面積

10. 可選方法

和OC一樣悼沿，協(xié)議方法默認(rèn)是required,如果需要定義為可選，則需要添加optional關(guān)鍵字

@objc protocol EatingProtol {
    @objc optional func midnightSnack()
}

注意：使用optional前必須先添加@objc

11. 弱引用協(xié)議對象

如果想要使用weak var的方式弱引用一個class對象,則需要讓該協(xié)議遵循NSObjectProtocol協(xié)議

@objc protocol EatingProtol: NSObjectProtocol {
    @objc optional func midnightSnack()
}