【Java】策略模式（Strategy Pattern）：封装变化，灵活应对需求变更

• Z时代
• 2024-01-10
• 分类：技术分享

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("不会飞行");
}
}

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("不会叫");
}
}

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("外观是诱饵鸭");
}
}

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();
}
}

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

GitHub源码分享

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

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

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

下面是这些鸭子的外观：

需求明确，开搞！

1.1 是时候展示OO技术了~

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

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

下面是UML类图：

1.2 Change！！！

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

现在要求增加一种鸭子行为：飞行（Fly），该怎么做呢？

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

那如果再增加一种鸭子：诱饵鸭（Decoy Duck），这是只木头鸭子，它即不会叫，也不会飞行......

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

1.3 使用接口怎么样？

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

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

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

1.4 封装变化

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

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

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

2. 策略模式

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

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

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

策略模式由三部分组成：

• Strategy（策略）

定义了所有策略的公共接口。上下文（Context）使用这个接口来调用某个具体策略（ConcreteStrategy）。

• ConcreteStrategy（具体策略）

Strategy接口的实现，定义了一个具体的策略实现。

• Context（上下文）

定义了Strategy对象如何来使用，是策略算法的调用者。

3. 代码实现

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

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/gozhuyingl...

5. 参考

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

推荐阅读

• 单例模式

以上是 【Java】策略模式（Strategy Pattern）：封装变化，灵活应对需求变更 的全部内容， 来源链接： utcz.com/a/111306.html