一、声明

• 内容仅作为博主个人学习的一个总结输出，仅供参考，若对你产生了一丝帮助，荣幸之至。

二、定义

协议定义了适合特定任务或功能的方法，属性。协议可以由类，结构或枚举实现，任何类型实现协议的要求方法称为遵守协议。

三、语法

protocol myProtocol {
    
}

1.自定义类型遵守协议的语法

协议名称放在类型名称之后，并用冒号分隔，多个协议时，协议之间使用逗号。当类类型有父类时则父类类型名称放在协议之前并用逗号隔开。

• 值类型

struct myStruct: myProtocol,myProtocol1 {
    var width = 10
    var height = 20
}

• 类类型

class myClass: myProtocol,myProtocol1 {
    var st = myStruct()
    var haveCar = true
    var point = 10.0
    var name :String?
}

2.协议中定义属性的要求

协议中定义属性必须始终声明为变量属性，并以var关键字为前缀。通过在类型声明后写{ get set }来表示属性可读写，通过写{get}来表示可读的属性。

protocol myProtocol1 {
    var kind: String {get set}
}
class protocol_Class: myProtocol1 {
    var apple = "苹果"
    
    var kind: String {
        get{
           apple + "香"
        }
        set{
           apple = newValue + apple
        }
    }
}
let test = protocol_Class()
test.kind = "吃"
print(test.kind) //: 吃苹果香
//: 注意： 协议中属性为{get set}使用计算属性时必须get{}和set{}不能为get{}；协议中属性为{get}时则可以使用get{}或者get{}和set{}

协议中定义类属性时，必须始终在前面使用static关键字。即使该协议的类属性在被类实现时，以class或static为前缀都是符合协议的。

protocol myProtocol2 {
    static var kind: String {get set}
}
class protocol_Class: myProtocol2 {
    static var apple = "苹果"
    static var kind: String {
        get{
           apple + "香"
        }
        set{
           apple = newValue + apple
        }
    }
}
 protocol_Class.kind = "吃"
print(protocol_Class.kind) //: 吃苹果香

结构体实现

struct protocol_Struct: myProtocol1 {
    var kind: String
}
let test = protocol_Struct(kind: "苹果")
print(test.kind) //: 苹果

3.协议中定义方法的要求

协议中定义类方法时，必须始终在前面使用static关键字。即使该协议的类方法在被类实现时，以class或static为前缀都是符合协议的。

//: 定义方法协议
protocol MethodProtocol {
    func instanceMethod(para:String) -> String
    static func classMethod(para:String)->String
    func hasVariableParameter(somePara:String...) -> String
}

//: 实现协议方法
class MethodProtocolClass : MethodProtocol {
    func hasVariableParameter(somePara: String...) -> String {
        var result : String = ""
        for item in somePara {
            result += item
        }
        return result
    }
    
    func instanceMethod(para: String) -> String {
        para + "实例方法协议实现"
    }
    class func classMethod(para: String) -> String {//!< static也可以
        para + "类方法协议实现"
    }
}
//调用
let instance = MethodProtocolClass()
print(instance.instanceMethod(para: "hello!"))//: hello!实例方法协议实现
print(MethodProtocolClass.classMethod(para: "Hi!"))//: Hi!类方法协议实现
print(instance.hasVariableParameter(somePara: "Gomu"," ","Come On","!"))//: Gomu Come On!

4.可变方法要求

值类型实现协议方法，修改值类型实例本身，则此协议方法需要使用mutating关键字作为前缀。

protocol Togglable {
    mutating func switchOperate()
}

extension Bool : Togglable {
    mutating func switchOperate() {
        self = !self
    }  
}
//: 调用
var value = false
value.switchOperate()
print(value) //: true