2.策略模式

1.需求：

一个部队要出兵作战，部队有3个小队。A小队用a武器，B小队用b武器，C小队用c武器。

• 实现方式1：

A、B、C都是角色，继承于一个基类
a、b、c都是武器，可以提供一个协议WeaponBehavior，武器使用方法useWeapon()
A、B、C分别在自己的类中实现各自的useWeapon()

以上实现存在问题：

1.useWeapon()的代码可能存在重复代码

• 实现方式2：

A、B、C都是角色，继承于一个基类
a、b、c都是武器，可以提供一个协议WeaponBehavior，基于该协议实现不同的武器使用行为
A、B、C调用不同的武器行为

以上遵循的原则：

设计原则1：找出应用中可能需要变化之处，把它们独立出来，不要和那些不变的代码混在一起。
设计原则2：针对接口编程，而不是针对实现编程
设计原则3：多用组合，少用继承

二：策略模式

定义了算法族（就是上面鸭子的各种飞行行为），分别封装了起来，让他们之间可以相互替换，此模式让算法的变化独立于使用算法的客户

//实现角色可以使用的不同的攻击行为，也就是不同的攻击策略
//武器策略
protocol WeaponBehavior {
    func useWeapon();
}

class AWPBehavior: WeaponBehavior {
    func useWeapon() {
        print("大狙---biu~biu~")
    }
}

class HK48Behavior: WeaponBehavior {
    func useWeapon() {
        print("HK48---tu~tu~tu~")
    }
}

class PistolBehavior: WeaponBehavior {
    func useWeapon() {
        print("手枪--pa~pa~pa~")
    }
}

//上面定义了一系列的武器策略
//下面是用户=================
class Character {
    //默认是配备的是手枪
    private var weapon: WeaponBehavior! = PistolBehavior()
    
    func setWeapon(weapon: WeaponBehavior) {
        self.weapon = weapon
    }
    
    //换手枪
    func changePistol() {
        self.setWeapon(PistolBehavior());
    }
    
    func fire() {
        guard self.weapon != nil else {
            return
        }
        self.weapon.useWeapon()
    }
}

//中尉只配备了手枪和HK48
class Lieutenant: Character {
    
    override init() {
        super.init();
    }
    
    //切换武器（策略）：换HK
    func changeHK() {
        self.setWeapon(HK48Behavior());
    }
}

//上尉尉只配备了手枪和大狙
class Captain: Character {
    
    override init() {
        super.init();
    }
    //切换武器（策略）：换大狙
    func changeAWP() {
        self.setWeapon(AWPBehavior());
    }
}



//中尉
let lieutenant: Lieutenant = Lieutenant()
lieutenant.fire()

print("\n手枪火力不行，得换HK48\n")

lieutenant.changeHK()
lieutenant.fire()

参考资料：
1）《Header First设计模式》
2）青玉伏案
http://www.cnblogs.com/ludashi/