// 协议是方法的集合(计算属性相当于就是方法)
// 可以把看似不相关的对象的公共行为放到一个协议中
// 协议在Swift开发中大致有三种作用: 
// 1. 能力 - 遵循了协议就意味着具备了某种能力
// 2. 约定 - 遵循了协议就一定要实现协议中的方法
// 3. 角色 - 一个类可以遵循多个协议, 一个协议可以被多个类遵循, 遵循协议就意味着扮演了某种角色, 遵循多个协议就意味着可以扮演多种角色
// Swift中的继承是单一继承(一个类只能有一个父类), 如果希望让一个类具备多重能力可以使用协议来实现(C++里面是通过多重继承来实现的, 这是一种非常狗血的做法)
protocol Flyable {
    
    func fly()
}

protocol Fightable {
    
    func fight()
}

// 协议扩展 - 可以在协议扩展中给协议中的方法提供默认实现
// 也就是说如果某个类遵循了协议但是没有实现这个方法就直接使用默认实现
// 那么这个方法也就相当于是一个可选方法(可以实现也可以不实现)
extension Fightable {
    
    func fight() {
        print("正在打架")
    }
}

// 协议的继承
protocol NiuBi: Flyable, Fightable {
    
    func dive()
}

class Boxer: Fightable {
    
    @objc func fight() {
        print("正在进行格斗.")
    }
}

class Superman: NiuBi {
    
    func fly() {
        print("超人使用超能力飞行.")
    }
    
//    func fight() {
//        print("超人正在和邪恶势力干仗.")
//    }
    
    func dive() {
        print("超人正在潜水.")
    }
}

class Bird: Flyable {

    func fly() {
        print("鸟儿扇动翅膀飞行.")
    }
}

class Airplane: Flyable {
    
    func fly() {
        print("飞机依靠空气动力学原理飞行.")
    }
}

class Rocket: Flyable {
    
    func fly() {
        print("火箭靠推进器推动飞行.")
    }
}

// 依赖倒转原则(面向协议编程)
// 1. 声明变量的类型时应该尽可能使用协议类型
// 2. 声明方法参数类型时应该尽可能使用协议类型
// 3. 声明方法返回类型时应该尽可能使用协议类型
let x: protocol<Flyable, Fightable> = Superman()
let y: NiuBi = Superman()

// 协议的组合
let array: [protocol<Flyable, Fightable>] = [
    // Rocket(),
    // Bird(),
    Superman(),
    // Boxer()
    // Airplane()
]

for obj in array {
    obj.fly()
    obj.fight()
}

// 协议中全是抽象概念(只有声明没有实现) 遵循协议的类可以各自对协议中的计算属性和方法给出自己的实现版本 这样当我们面向协议编程时就可以把多态的优势发挥到淋漓尽致 可以写出更通用更灵活的代码(符合开闭原则)

// 实现开闭原则最关键有两点: 
//  1. 抽象是关键(在设计系统的时候一定要设计好的协议);
//  2. 封装可变性(桥梁模式 - 将不同的可变因素封装到不同的继承结构中)

// 接口(协议)隔离原则: 协议的设计要小而专不要大而全
// 协议的设计也要高度内聚