策略模式(Strategy Pattern):封装变化,灵活应对需求变更

策略模式(Strategy Pattern):封装变化,灵活应对需求变更_第1张图片

GitHub源码分享

微信搜索:码农StayUp
主页地址:https://gozhuyinglong.github.io
源码分享:https://github.com/gozhuyinglong/blog-demos

1. 一个简单的模拟鸭子游戏

我们先来看一个模拟鸭子的游戏:游戏中会出现各种鸭子,它们一边游泳戏水,一边呱呱叫。

经过一番调研后:
已知的鸭子种类有:野鸭(Mallard Duck)、红头鸭(Redhead Duck)、橡皮鸭(Rubber Duck)。
已知的鸭子行为有:游泳(Swim)、嘎嘎叫(Quack)、显示鸭子的样子(Display)。

下面是这些鸭子的外观:

策略模式(Strategy Pattern):封装变化,灵活应对需求变更_第2张图片
野鸭
策略模式(Strategy Pattern):封装变化,灵活应对需求变更_第3张图片
红头鸭
策略模式(Strategy Pattern):封装变化,灵活应对需求变更_第4张图片
橡皮鸭

需求明确,开搞!

1.1 是时候展示OO技术了~

为了可复用性,设计了一个鸭子超类Duck,并让各种鸭子继承此超类:

  • 该超类中实现了swim()quack()方法,由于每一种鸭子外观不同,所以display()指定为抽象方法(当然该类也是抽象类)。
  • 各个子类具体实现了display()方法
  • 由于橡皮鸭不会“嗄嗄叫”,所以重写了quack()方法为“吱吱叫”。

下面是UML类图:


策略模式(Strategy Pattern):封装变化,灵活应对需求变更_第5张图片
简版UML类图

1.2 Change!!!

我们知道软件开发的一个不变的真理是:“变化”!

现在要求增加一种鸭子行为:飞行(Fly),该怎么做呢?

如果继续使用继承,那么橡皮鸭是不会飞行的,还是需要重写fly()方法。如下:

策略模式(Strategy Pattern):封装变化,灵活应对需求变更_第6张图片
简版UML类图

那如果再增加一种鸭子:诱饵鸭(Decoy Duck),这是只木头鸭子,它即不会叫,也不会飞行......


策略模式(Strategy Pattern):封装变化,灵活应对需求变更_第7张图片
诱饵鸭

看来继承是不能满足需求了!

1.3 使用接口怎么样?

fly()方法和quack()抽离出来,做成接口,让拥有该行为的鸭子对其进行实现。如下:

策略模式(Strategy Pattern):封装变化,灵活应对需求变更_第8张图片
简版UML类图

这似乎解决了现在的问题!

但如果再增加100只鸭子呢?岂不是所有会飞行或会叫的鸭子,都要实现一遍,没有达到代码的复用性。而且一旦要修改某个行为将是一件痛苦的事(比如将所有“吱吱叫”改成“仿真呱呱叫”)……

1.4 封装变化

有一个设计原则,恰好适用于上面模拟鸭子游戏的状况。

找出应用中可能需要变化之处,把它们独立出来,不要和那些不需要变化的代码混在一起。

换句话说,如果每次来新的需求,都会使某方面的代码发生变化,那么你就可以确定,这部分的代码需要被抽出来,和其他稳定的代码有所区分。

这便是策略模式的精神所在,下面我们来看该模式的详细介绍。

2. 策略模式

策略模式(Strategy Pattern)是一种行为型模式。该模式定义一系列的算法,把它们一个个封装起来,并使它们可以相互替换。该模式让算法的变化独立于使用它的客户。

Define a family of algorithms, encapsulate each one, and make them interchangeable.

该设计模式体现了几个设计原则:

  • 封装变化
  • 针对接口编程,而不是实现类
  • 多用组合,少用继承

策略模式由三部分组成:

  • Strategy(策略)
    定义了所有策略的公共接口。上下文(Context)使用这个接口来调用某个具体策略(ConcreteStrategy)。
  • ConcreteStrategy(具体策略)
    Strategy接口的实现,定义了一个具体的策略实现。
  • Context(上下文)
    定义了Strategy对象如何来使用,是策略算法的调用者。
策略模式(Strategy Pattern):封装变化,灵活应对需求变更_第9张图片
策略模式原理图

3. 代码实现

我们使用策略模式实现上面模拟鸭子游戏。

策略模式(Strategy Pattern):封装变化,灵活应对需求变更_第10张图片
标准UML类图(使用策略模式实现模拟鸭子游戏)

3.1 飞行行为实现

定义飞行行为接口

public interface Fly {
    void fly();
}

用翅膀飞行实现类

public class FlyWithWings implements Fly {
    @Override
    public void fly() {
        System.out.println("用翅膀飞行");
    }
}

不会飞行实现类

public class FlyNoWay implements Fly {
    @Override
    public void fly() {
        System.out.println("不会飞行");
    }
}

3.2 鸭叫行为实现

定义鸭叫行为接口

public interface Quack {
    void quack();
}

呱呱叫实现类

public class QuackGuaGua implements Quack {
    @Override
    public void quack() {
        System.out.println("呱呱叫");
    }
}

吱吱叫实现类

public class QuackZhiZhi implements Quack {
    @Override
    public void quack() {
        System.out.println("吱吱叫");
    }
}

不会叫实现类

public class QuackNoWay implements Quack {
    @Override
    public void quack() {
        System.out.println("不会叫");
    }
}

3.3 鸭子类的实现

定义鸭子抽象类

public abstract class Duck {

    protected Fly fly;
    protected Quack quack;

    public void swim() {
        System.out.println("正在游泳...");
    }

    public abstract void display();

    public Fly getFly() {
        return fly;
    }

    public Quack getQuack() {
        return quack;
    }
}

野鸭实现类

public class MallardDuck extends Duck {

    // 野鸭用翅膀飞行,呱呱叫
    public MallardDuck() {
        this.fly = new FlyWithWings();
        this.quack = new QuackGuaGua();
    }

    @Override
    public void display() {
        System.out.println("外观是绿头鸭");
    }
}

红头鸭实现类

public class RedheadDuck extends Duck {

    // 红头鸭用翅膀飞行,呱呱叫
    public RedheadDuck() {
        this.fly = new FlyWithWings();
        this.quack = new QuackGuaGua();
    }

    @Override
    public void display() {
        System.out.println("外观是红头鸭");
    }
}

橡皮鸭实现类

public class RubberDuck extends Duck {

    // 橡皮鸭不会飞行,吱吱叫
    public RubberDuck() {
        this.fly = new FlyNoWay();
        this.quack = new QuackZhiZhi();
    }

    @Override
    public void display() {
        System.out.println("外观是橡皮鸭");
    }
}

诱饵鸭实现类

public class DecoyDuck extends Duck {

    // 诱饵鸭不会飞行,也不会叫
    public DecoyDuck() {
        this.fly = new FlyNoWay();
        this.quack = new QuackNoWay();
    }

    @Override
    public void display() {
        System.out.println("外观是诱饵鸭");
    }
}

3.4 测试

编写简单测试类

public class Test {

    public static void main(String[] args) {
        MallardDuck mallardDuck = new MallardDuck();
        mallardDuck.display();
        mallardDuck.swim();
        mallardDuck.getFly().fly();
        mallardDuck.getQuack().quack();

        System.out.println("-------------------");

        DecoyDuck decoyDuck = new DecoyDuck();
        decoyDuck.display();
        decoyDuck.swim();
        decoyDuck.getFly().fly();
        decoyDuck.getQuack().quack();
    }
}

输出结果

外观是绿头鸭
正在游泳...
用翅膀飞行
呱呱叫
-------------------
外观是诱饵鸭
正在游泳...
不会飞行
不会叫

4. 完整代码

完整代码请访问我的Github,若对你有帮助,欢迎给个Star,谢谢!

https://github.com/gozhuyinglong/blog-demos/tree/main/design-patterns/src/main/java/io/github/gozhuyinglong/designpatterns/strategy

5. 参考

  • 《 Head First 设计模式 》
  • 《 设计模式:可复用面向对象软件的基础 》

推荐阅读

  • 单例模式

你可能感兴趣的:(策略模式(Strategy Pattern):封装变化,灵活应对需求变更)