协议定义和遵从
类、结构体和枚举都可以声明遵从一个或者是多个协议，并提供该协议所要求属性和方法的实现。
协议语法定义如下：
protocol 协议名 {
//协议内容
}
遵从协议，语法如下：
//多个协议用（，）隔开
类型 类型名：协议1，协议2 {
//遵从协议内容
}
如果一个类，继承父类的同时也要遵从协议，应当把父类放在所有协议之前。
//多个协议用（，）隔开
class 类型名：父类，协议1，协议2 {
//遵从协议内容
}
协议方法
协议可以要求其遵从者实现某些制定方法，包括实例方法和静态方法。这些方法在协议中被定义，协议方法与普通方法类似，但不支持变长参数和默认值，也不需要大括号和方法体。
- 协议实例方法
protocol Figure {
func onDraw()
}
class Rectangle: Figure {
func onDraw() {
print("绘制矩形")
}
}
class Circle: Figure {
func onDraw() {
print("绘制圆形")
}
}
let rect: Figure = Rectangle()
rect.onDraw()
let circle: Figure = Rectangle()
circle.onDraw()
- 协议静态方法
在协议中定义静态方法的时候，前面要加上static关键字。遵从该协议的时候，遵从着静态方法前的关键字是class还是static与遵从者的类型有关系。如果遵从者是枚举或者是结构体，关键字就是static。如果遵从者是类，关键字可以使用class或者是static，使用class时遵从者的子类中可以重写该静态方法，使用static时，遵从者的子类中不可以重写该静态方法。
protocol Figure {
static func onDraw()
}
class Rectangle: Figure {
class func onDraw() {
print("绘制矩形")
}
}
struct circle: Figure {
static func onDraw() {
print("绘制圆形")
}
}
- 协议可变方法
在结构体和枚举中可以定义可变方法，而在类中没有这种方法。原因是结构体和枚举中的属性是不可以修改的，通过定义可变方法可以修改这些属性。而类是引用类型，方法本身就是可变的，能修改自己的属性。
在定义可变方法时，前面要加上mutating关键字。结构体和枚举都可以遵从可变方法，方法前面需要加上mutating关键字。类也可以遵从可变方法，前面不需要家关键字。
protocol Editable {
mutating func edit(name: String)
}
struct stru: Editable {
var name: String
mutating func edit(name: String) {
self.name = name
}
}
enum enu: Editable {
case first
case second
case three
mutating func edit(name: String) {
self = .three
}
}
class cla: Editable {
lazy var name = String()
func edit(name: String) {
self.name = name
}
}
协议属性
协议可以要求其遵从者实现某些指定属性，包括实例属性和静态属性。在具体定义的时候，每一种属性都可以有只读和读写区别。
对于遵从者而言，实现属性是非常灵活的。无论是存储属性还是计算属性，只要能满足协议属性的要求，就可以通过编译。甚至是协议综合功能只规定了只读属性，而遵从者提供了该属性的读写实现，这也是被允许的。因为遵从者满足了协议的只读属性的要求。协议只规定了遵从者必须要做的事，但是没有规定不能做的事情。
- 协议实例属性
protocol Person {
var firstName: String {get set}
var laseName: String {get set}
var fullName: String {get}
}
class Children: Person {
//定义存储属性
var firstName: String = "tom"
//定义存储属性
var laseName: String = "haha"
//定义计算属性
var fullName: String {
get {
return self.firstName + self.laseName
}
set { //协议没有规定set方法，我们可以自己实现
var name = newValue.components(separatedBy: ".")
self.firstName = name[0]
self.laseName = name[1]
}
}
}
- 协议静态属性
定义协议静态属性与定义协议静态方法类似，前面需要键static关键字。如果遵从者是结构体或者是枚举，关键字就是static。遵从者是类，关键字就是class（可以继承）或者static。
protocol Account {
static var interestRate: Double {get}
static func interestBy(amount: Double) -> Double
}
class firstClass: Account {
static var interestRate: Double {
return 0.668
}
class func interestBy(amount: Double) -> Double {
return firstClass.interestRate * amount
}
}
struct secondStruct: Account {
static var interestRate: Double {
return 0.668
}
static func interestBy(amount: Double) -> Double {
return firstClass.interestRate * amount
}
}
enum threeEnum: Account {
static var interestRate: Double {
return 0.668
}
static func interestBy(amount: Double) -> Double {
return firstClass.interestRate * amount
}
}
面向协议编程
- 协议类型
在swift中，协议是作为数据类型使用的，这是面向协议编程具体实现的一个方面，协议可以出现在任意允许其他数据类型出现的地方，如下
- 协议类型可以作为函数、方法或者构造函数中的参数类型或者是返回值类型。
- 协议类型可以作为常量、变量或属性的类型。
- 协议类型可以作为数组、字典和set等集合的元素类型。
注意：协议作为类型使用与其他类型没有区别，不仅可以使用as、as？和as！操作符进行类型转换，还可以使用is操作符判断类型是否遵从了某个协议。除了不能实例化，协议可以向其他类型一样使用。
- 协议继承
协议的继承和类型继承一样，这里不做详细描述 - 协议扩展
协议扩展本质上还是协议，只不过增加了一些属性和方法，在使用的时候还是要遵从者实现该协议，这样遵从者就新增加了一些属性和方法。 - 协议的合成
多个协议可以临时组合成一个整体，作为一个类型使用。示例如下：
//定义两个协议
protocol firstProtocol {
var name: String {get set}
}
protocol secondProtocol {
var age: Int {get}
}
//定义一个类遵从这两个协议
class Person: firstProtocol, secondProtocol {
var name: String = "test"
var age: Int = 18
}
//定义一个方法，参数为firstProtocol&secondProtocol类型。这种类型参数要求同时遵从这两个协议。这就是协议的合成。
//它是一种临时的协议，当作用于结束时，这个类型就不存在了。
func showPerson(resource: firstProtocol&secondProtocol) {
print("name is \(resource.name), age is \(resource.age)")
}
let person = Person()
showPerson(resource: person)
//name is test, age is 18
- 扩展中遵从协议
在扩展中也可以遵从某个协议，语法如下：
extension 类型名：协议1， 协议2 {
//协议内容
}
使用示例如下：
protocol firstProtocol {
mutating func edit()
}
struct Account {
var amount = 100
}
extension Account: firstProtocol {
mutating func edit() {
self.amount = 200
}
}
