Swift中的协议类似于Java中的接口，不过在Swift中，结构体，枚举，类都能使用协议。

基本用法

import Foundation
//声明协议
protocol XYData{
    var height:Int{get set}
    var color:String{get}
    func self2Str()->String
}
//实现协议
struct Person:XYData{
    var height=170
    var color:String="black"
    func self2Str() -> String {
        return "hello"
    }
}

//使用协议
func printXYData(data:XYData){
    print(data.color)
    print(data.height)
    print(data.self2Str())
}

var person1=Person(height:180,color:"blue")
printXYData(data: person1)

符合多个协议

一个类型可以符合多个协议，用逗号分隔。如果类有父类，则父类名在前，协议名在后。

struct Person:XYData,CustomStringConvertible{
    var height=170
    var color:String="black"
    func self2Str() -> String {
        return "hello"
    }
    var description: String{
        return "person"
    } 
}

协议继承

协议的继承只是简单的需求相加，如果一个类型要符合一个继承后的协议，则子协议和父协议的内容都需要实现

protocol XYData:CustomStringConvertible{
    var height:Int{get set}
    var color:String{get}
    func self2Str()->String
}

协议组合

声明类型时，可以使用&来连接多个协议，表示实例符合多种协议

func printXYData(data :XYData & CustomStringConvertible & CustomNSError){
    print(data.color)
    print(data.height)
    print(data.self2Str())
}

可选方法

扩展协议时，可以对方法进行默认实现，实现该协议的对象就可以不用实现该方法。

protocol MyProtocol{
    func necessaryMethod()
    func optionalMethod()
    func anotherOptionalMethod()
}


extension MyProtocol{
    func optionalMethod(){
       print("optionalMethod in extension")
    }
    
    func anotherOptionalMethod(){
        print("anotherOptionalMethod in extension")
    }
}

struct MyClass:MyProtocol{
    func necessaryMethod(){
        print("necessaryMethod in MyClass")
    }
    
    func anotherOptionalMethod(){
        print("anotherOptionalMethod in MyClass")
    }
}



let obj=MyClass()
obj.necessaryMethod()//necessaryMethod in MyClass
obj.optionalMethod()//optionalMethod in extension
obj.anotherOptionalMethod()//anotherOptionalMethod in MyClass

也可以使用OC的方式实现可选方法。

@objc protocol MyProtocol{
    func necessaryMethod()
    @objc optional func optionalMethod()
}

class MyClass:MyProtocol{
    func necessaryMethod(){
        print("necessaryMethod in MyClass")
    }
}

let obj=MyClass()
let protocolObj:MyProtocol=obj
protocolObj.necessaryMethod()
protocolObj.optionalMethod?()
if (protocolObj.optionalMethod != nil){
    protocolObj.optionalMethod!()
}else{
    print("optionalMethod not implemented")
}

mutating方法

结构体，枚举实现协议中的mutating方法时需要标记mutating，而类不需要，因为类方法总是可以改变self的属性。