设计模式学习--策略模式

Go 语言实现策略模式 

package main

type FlyBehavior interface { // 飞行行为接口
    fly()
}

type QuackBehavior interface { // 鸣叫行为接口
    quack()
}

type Duck struct { // 鸭子类
    flyBehavior   FlyBehavior   // 飞行行为
    quackBehavior QuackBehavior // 鸣叫行为
}

func (d *Duck) performFly() { // 具体的飞行行为委托给飞行行为接口
    d.flyBehavior.fly()
}

func (d *Duck) performQuack() { // 具体的鸣叫行为委托给鸣叫行为接口
    d.quackBehavior.quack()
}

func (d *Duck) swim() {
    println("All ducks float, even decoys!")
}

func (d *Duck) setFlyBehavior(fb FlyBehavior) { // 动态设定飞行行为
    d.flyBehavior = fb
}

type FlyWithWings struct{} // 常见的飞行行为

func (f *FlyWithWings) fly() {
    println("I'm flying!")
}

type FlyNoWay struct{} // 支持不会飞的鸭子 玩具鸭子 诱饵鸭子

func (f *FlyNoWay) fly() {
    println("I can't fly")
}

type FlyRocketPowered struct{} // 支持火箭动力飞行的鸭子，比如诱饵鸭子坐上了火箭

func (f *FlyRocketPowered) fly() {
    println("I'm flying with a rocket!")
}

type Quack struct{} // 常见的鸣叫行为

func (q *Quack) quack() {
    println("Quack")
}

type MuteQuack struct{} // 支持不会鸣叫的鸭子，比如诱饵鸭子

func (q *MuteQuack) quack() {
    println("<< Silence >>")
}

type Squeak struct{} // 支持吱吱叫的鸭子，比如橡皮鸭子

func (q *Squeak) quack() {
    println("Squeak")
}

type MallardDuck struct { // 绿头鸭
    Duck
}

func NewMallardDuck() *MallardDuck {
    d := &MallardDuck{}
    d.flyBehavior = &FlyWithWings{} // 绿头鸭会飞
    d.quackBehavior = &Quack{}      // 绿头鸭会鸣叫
    return d
}

type ModelDuck struct { // 模型鸭
    Duck
}

func NewModelDuck() *ModelDuck {
    d := &ModelDuck{}
    d.flyBehavior = &FlyNoWay{} // 模型鸭不会飞
    d.quackBehavior = &Quack{}  // 模型鸭会鸣叫
    return d
}

type RubberDuck struct { // 橡皮鸭
    Duck
}

func NewRubberDuck() *RubberDuck {
    d := &RubberDuck{}
    d.flyBehavior = &FlyNoWay{} // 橡皮鸭不会飞
    d.quackBehavior = &Squeak{} // 橡皮鸭会吱吱叫
    return d
}

type DecoyDuck struct { // 诱饵鸭
    Duck
}

func NewDecoyDuck() *DecoyDuck {
    d := &DecoyDuck{}
    d.flyBehavior = &FlyNoWay{}    // 诱饵鸭不会飞
    d.quackBehavior = &MuteQuack{} // 诱饵鸭不会鸣叫
    return d
}

func main() {
    mallard := NewMallardDuck()
    mallard.performQuack()
    mallard.performFly()

    model := NewModelDuck()
    model.performFly()
    model.setFlyBehavior(&FlyRocketPowered{})
    model.performFly()

    rubber := NewRubberDuck()
    rubber.performQuack()
    rubber.performFly()

    decoy := NewDecoyDuck()
    decoy.performQuack()
    decoy.performFly()
}

Python 实现策略模式，莫得接口，借助类和继承来实现。

# 策略模式

# 鸭子类
class Duck:
    def __init__(self, fly_strategy, quack_strategy):
        self.fly_strategy = fly_strategy
        self.quack_strategy = quack_strategy

    def perform_fly(self):
        self.fly_strategy.fly()

    def perform_quack(self):
        self.quack_strategy.quack()

# 飞行类
class FlyBehavior:
    def fly(self):
        pass

# 飞行类的实现
class FlyWithWings(FlyBehavior):
    def fly(self):
        print('fly with wings')

class FlyNoWay(FlyBehavior):
    def fly(self):
        print('fly no way')

# 叫声类
class QuackBehavior:
    def quack(self):
        pass

# 叫声类的实现
class QuackWithQuack(QuackBehavior):
    def quack(self):
        print('quack with quack')

class QuackNoWay(QuackBehavior):
    def quack(self):
        print('quack no way')

# 鸭子的实现
class MallardDuck(Duck):
    def __init__(self):
        super().__init__(FlyWithWings(), QuackWithQuack())

class RubberDuck(Duck):
    def __init__(self):
        super().__init__(FlyNoWay(), QuackNoWay())

if __name__ == '__main__':
    mallard_duck = MallardDuck()
    mallard_duck.perform_fly()
    mallard_duck.perform_quack()

    rubber_duck = RubberDuck()
    rubber_duck.perform_fly()
    rubber_duck.perform_quack()

    rubber_duck.fly_strategy = FlyWithWings()
    rubber_duck.perform_fly()
    rubber_duck.perform_quack()

    mallard_duck.quack_strategy = QuackNoWay()
    mallard_duck.perform_fly()
    mallard_duck.perform_quack()

    rubber_duck.fly_strategy = FlyNoWay()
    rubber_duck.perform_fly()
    rubber_duck.perform_quack()

    mallard_duck.quack_strategy = QuackWithQuack()
    mallard_duck.perform_fly()
    mallard_duck.perform_quack()