1.协议的继承

protocol Animal{
    
    // 腿和翅膀属性，包括get和set方法
    var leg:String{get set}
    var wing:String{get set}
    // 描述方法，返回的是字符串
    func description() -> String
}

protocol Fish:Animal {
    
    // 习惯属性，带有get和set
    var habit:String{get set}
}

// Goldfish类采纳Fish协议
class Goldfish:Fish{
    
    var name:String
    // 实现Fish的协议
    var habit: String
    
    // 实现Animal协议
    var leg: String
    var wing: String
    func description() -> String {
        
        return "name:\(name),wing:\(wing),leg:\(leg),habit:\(habit)"
    }
    
    // 构造函数
    init(name:String,habit:String,leg:String,wing:String){
        
        self.name = name
        self.habit = habit
        self.leg = leg
        self.wing = wing
    }
}

var goldfish = Goldfish(name:"fish",habit:"喜欢水",leg:"没有腿",wing:"没有翅膀")
print(goldfish.description())

2.检查协议的一致性

使用is操作符检查实现实例是否采纳了某个协议
使用as操作符把实例类型转换到指定协议类型

protocol Area{
    
    var area:Double{get}
}

// 定义采纳Area协议的类Rectangle
class Rectangle:Area{
    
    let long:Double
    var area: Double{return long * long}
    init(long:Double) {
        
        self.long = long
    }
}

// 定义采纳了Area协议的类Circle
class Circle:Area{
    
    let pi = 3.1415926
    var radius:Double
    var area: Double{return pi * radius * radius}
    
    init(radius:Double){
        self.radius = radius;
    }
}

// 定义了没有采纳Area协议的类Bird
class Bird{
    
    var wing:Int
    init(wing:Int){
        self.wing = wing
    }
}

// 定义AnyObject类型的数组
let objects:[AnyObject] = [Circle(radius:2.0),Rectangle(long:2.0),Bird(wing:2)]

for object in objects {
    
    if let objectWithArea = object as? Area{
        
        print("面积是：\(objectWithArea.area)")
    }else{
        
        print("没有面积")
    }
}

3.代理模式

代理是一种设计模式，它允许类或者结构体将自身负责的功能委托给其他类型的实例去实现。

// 定义一个协议GetFile
protocol GetFileDelegate{
    
    func take() -> String           // 协议方法
}

// 定义Assistant类，采用GetFile协议
class Assistant:GetFileDelegate{
    
    func take() -> String {
        
        return "助理给老板拿文件"
    }
}

// 定义一个Boss类，它有一个代理属性
class Boss{
    
    var delegate:GetFileDelegate?        // 声明代理属性，用来响应代理方法
    init(man:GetFileDelegate) {
        
        delegate = man
    }
    func take() -> String {
        
        return delegate!.take()  // 实现代理的方法
    }
}

let assistant = Assistant()
let boss = Boss(man:assistant)
print(boss.take())