策略模式：解耦代码，提升系统灵活性

闲谈

2023-12-26 03:18:24

在软件设计中，策略模式是一种非常有用的设计模式，它可以让你将一个类的行为或算法封装成一个独立的对象，以便可以轻松地切换或配置不同的行为或算法。这种模式可以帮助你提高代码的解耦性和系统灵活性。

策略模式的结构非常简单，它主要由三个角色组成：

抽象策略角色： 策略类，通常由一个接口或者抽象类实现。
具体策略角色： 包装了相关的算法和行为。
环境角色： 持有一个策略类的引用，最终给客户端调用的。通过环境角色指定策略。

鸭子模拟游戏：SimUDuck

为了更好地理解策略模式，我们可以来看一个经典的例子：鸭子模拟游戏 SimUDuck。游戏中会出现各种鸭子，一边游泳戏水，一边呱呱叫。不同的鸭子有不同的行为和习性，比如：

绿头鸭（MallardDuck）： 会呱呱叫，也会飞。
红头鸭（RedheadDuck）： 会呱呱叫，不会飞。
橡皮鸭（RubberDuck）： 不会呱呱叫，也不会飞。

如果我们使用传统的编程方法来实现这个游戏，我们会为每种鸭子创建一个单独的类，并在每个类中定义呱呱叫和飞行的行为。这样一来，代码会变得非常冗长和重复，而且难以维护。

策略模式的应用

策略模式可以帮助我们解决这个问题。我们可以将呱呱叫和飞行的行为封装成独立的策略类，然后让每种鸭子引用不同的策略类。这样一来，代码就会变得更加简洁和易于维护，而且我们可以轻松地添加新的鸭子类型，而无需修改现有的代码。

public abstract class Duck {
    private QuackBehavior quackBehavior;
    private FlyBehavior flyBehavior;

    public Duck() {}

    public void setQuackBehavior(QuackBehavior quackBehavior) {
        this.quackBehavior = quackBehavior;
    }

    public void setFlyBehavior(FlyBehavior flyBehavior) {
        this.flyBehavior = flyBehavior;
    }

    public void quack() {
        quackBehavior.quack();
    }

    public void fly() {
        flyBehavior.fly();
    }

    public abstract void display();
}

public interface QuackBehavior {
    void quack();
}

public interface FlyBehavior {
    void fly();
}

public class MallardDuck extends Duck {
    public MallardDuck() {
        quackBehavior = new Quack();
        flyBehavior = new FlyWithWings();
    }

    @Override
    public void display() {
        System.out.println("I'm a Mallard Duck!");
    }
}

public class RedheadDuck extends Duck {
    public RedheadDuck() {
        quackBehavior = new Quack();
        flyBehavior = new FlyWithWings();
    }

    @Override
    public void display() {
        System.out.println("I'm a Redhead Duck!");
    }
}

public class RubberDuck extends Duck {
    public RubberDuck() {
        quackBehavior = new Squeak();
        flyBehavior = new FlyNoWay();
    }

    @Override
    public void display() {
        System.out.println("I'm a Rubber Duck!");
    }
}