Swift 3 协议(protocol)

协议，可以理解为一个类型，协议跟继承有点像
协议，就是规定一个东西应该有那些属性，有哪些方法
我们可以先定义一个协议

protocol Pet{//协议里边不能用let
    var name:String {set get}//可读可写的属性
    var age:Int {get}
     func playWith()//协议里边，只写方法定义
     func init(name:String)//构造方法
    func fed(food:String)//不能默认值
}

再来定义一个类(或者结构体等类型)来遵循这个协议

class Cat:Pet{
    private var myName:String?//这个私有变量，是为了写协议里边的计算属性的set，get方法
    required init(name: String) {
        self.name = name
    }
    //这里，我们用一个计算型属性来实现协议里的name属性，如果是可读可写的，我么可以简单的写上 var name:String，就和下边的是等价的了，如果是get-only的属性，我们可以let age:Int，就可以了，但是，我们也可以直接用var age:Int，这样age就是一个可读可写的属性了，这样是允许的，协议只规定了要有一个age，并且包含get方法就行。这一点很重要
    var name: String{
        set{
            myName = newValue
        }
        get{
        return myName ?? "meiyou"
        }
    }
    func playWith() {
        
    }
    func fed(food: String) {
        
    }
}

这里，协议里边的方法，默认都是required
如果想有可选方法，可以这样写

@objc protocol Pet{//协议里边不能用let
    var name:String { set get }
    @objc optional func playWith()//可选方法
    func fed(food:String)//不能默认值
 }

可以看到在protocol里边，有一个构造方法，那么，遵循这个协议的类或者结构体等，都需要重写这个构造方法
在Cat这个类里边，要这样

//这里，required表示必须实现，如果Cat还有子类，那么子类也必须写init方法
required init(name: String) {
    }

如果Cat这样写

final class Cat:Pet{

那么init方法就不需要required了，因为我们已经声明了这个类不可以被继承

我们来提一下泛型
试想一下我们有这么一个方法，交换两个对象，可以是整型，可以是字符串，可以是Double等等，当然我们可以写三个函数，函数名是一样的，只是参数不一样，也就是用到函数的重载，这样就会有很多重复的逻辑，我们可以写一个这样的函数

func exchange<R>(a:inout R, b: inout R){//这里，R是一个自己定义的，一般我们写的是T，系统也是用的T
    (a,b) = (b,a)//这里利用元组来实现交换
}

其实系统的很多都是泛型类型的，典型的有Array， Dictionary，Set等容器类型的都是泛型类型
我们再来说一下协议里边别名的用法(associatedtype, typealias)

protocol Weight{
    associatedtype weightType//关联一个类型，这里，就相当于是定义了一个类型，可以理解为是一个泛型
    var weight:weightType{ get }
}

用的时候，可以自定义weightType的类型，比如这样

class iPhone6s:Weight{
    typealias weightType = Double//给协议里的泛型指定一个具体类型
    var weight: weightType{
        return 123.123
    }
}
let iphone = iPhone6s()
iphone.weight