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