swift 协议（protocol）

swift中的协议用于定义方法和属性，但是协议本身并不进行实现，而是由采纳该协议的类进行实现。

一、协议里边可以定义属性、方法、构造函数等。

1.对于可读可写的属性，则实现属性不能使常量存储属性或只读的计算型属性
2.对于只读的属性，则实现属性可以是任意类型的属性
3.允许为只读属性实现有效的setter方法

protocol PersonProtocol{
    var age:Int{get set} //声明为可读可写属性
    var name:String{get} //声明为只读属性
    static var sex:String{get set} //声明为类型属性
}


protocol Person{
    var fullName:String {get}
    func description()
    //可变方法
    //结构体和枚举能够通过采纳协议，对协议的可变方法进行实现，从而改变本身的值。而类在实现可变方法时，要省略mutation关键字
    mutating func descriptionM()
    init(name:String, fullName:String)
}

class Teacher : Person{
    var name:String
    init(name:String) {
        self.name = name
    }
    var fullName: String{
        return self.name+"全"
    }
    func description() { //普通方法，类方法一样
        print("I am description")
    }
    func descriptionM(){
        self.name = "王"
        print(self.name,"全")
    }
    //如果需要实现协议里边的构造方法必须加上required关键字，是为了保证该类的所有子类要满足协议的要求
    //如果该类有final修饰 则不用加required关键字，因为final修饰的类不能被继承
     required init(name: String, fullName: String) {
        self.name = name
    }
}

let tea = Teacher(name:"小李子")
print(tea.fullName)
tea.description()
tea.descriptionM()

let tea2 = Teacher(name:"小陈", fullName:"小袁")
print(tea2.name)

//可选协议，  只能被类采纳
import UIKit
@objc protocol Animal{
    //定义可选方法 类可自动选择是否实现该方法
    @objc optional func run()
}

class Cat : Animal{
    @objc func run() {
        print("run")
    }
}
let cat = Cat()
cat.run()

控制台：

小李子全
I am description
王 全
小陈
run

二、协议作为类型使用

下边列举一个例子，把协议当做参数来使用，其实就是该参数需要传入一个采纳了该协议的类或结构体或枚举的实例

//协议作为类型使用
protocol Name{
    var name:String{get}
}

class Person:Name{
    var name: String{
        return "name"
    }
}

func A(param:Name){
    print(param.name)
}

A(param:Person())

控制台：

name

协议的合成，如果多个协议当做类型使用时，方法如下

protocol A(){}
protocol B(){}
func C(param:protocol<A,B>){}
//这时候调用C方法就需要传入一个同时采纳了AB两个协议的实例

三、协议的继承

协议之间也可以继承，跟类的继承相似，但是协议允许多继承。用逗号分隔

protocol A : B,C(){}//A协议继承了B、C两个协议

四、检查协议的一致性

• 使用is操作符检查实例是否采纳了某个协议
• 使用as操作符把实例类型转换到指定的协议类型
  这里简直跟类里边的使用方法一模一样，不再赘述
  is操作符
  as操作符

五、代理模式

讲到代理模式就厉害了，我很喜欢这个，也比较容易学。
看下边的代码 简直是通俗易懂，高大上

protocol Take{
    func take()
}

class Student:Take{
    func take(){
        print("student去借粉笔")
    }
}

class Teacher{
    var delegate:Take
    init(delegate:Take){
        self.delegate = delegate
    }
    func talk(){
        delegate.take()
    }
}

let stu = Student()
let Tea = Teacher(delegate:stu)
Tea.talk()

控制台：

student去借粉笔