深入剖析策略模式（Strategy Pattern）_策略模式的类图和作用-优快云博客

本文链接：https://blog.youkuaiyun.com/sjdgehi/article/details/145875315

深入剖析策略模式（Strategy Pattern）

在软件设计中，策略模式（Strategy Pattern）是一种非常重要的行为型设计模式。它的核心思想是将算法或行为封装在不同的策略类中，使得它们可以互换，从而使得算法的选择和变更变得更加灵活和可扩展。本文将详细讲解策略模式的原理，结合代码示例、对比分析，帮助你深入理解策略模式的应用。

1. 策略模式概述

策略模式定义了一个算法家族，分别封装起来，让它们可以互相替换。此模式让算法的变化独立于使用算法的客户。

主要角色：

Context（上下文）：持有一个策略对象的引用，用于调用具体的策略。
Strategy（策略接口）：定义所有支持的算法的公共接口。
ConcreteStrategy（具体策略）：实现了策略接口的具体类，每个类封装了不同的算法或行为。

策略模式的类图：

          +-------------+
          |   Context  |
          +-------------+
          | - strategy |
          +-------------+
          | + setStrategy(Strategy) |
          | + execute()  |
          +-------------+
                ^
                |
       +------------------+
       |      Strategy    |
       +------------------+
       | + algorithm()    |
       +------------------+
          ^          ^ 
          |          |
 +------------------+   +-------------------+
 | ConcreteStrategyA|   | ConcreteStrategyB |
 +------------------+   +-------------------+
 | + algorithm()    |   | + algorithm()     |
 +------------------+   +-------------------+

2. 策略模式的核心思想

策略模式的核心思想是将算法封装到一个个策略类中，并通过上下文对象动态决定使用哪个策略类，从而实现了算法的灵活切换和扩展。当需要改变某个具体行为时，只需修改策略类，而不必修改客户端代码。这样做能有效减少条件语句（如 if-else 或 switch-case），提高代码的可维护性和可扩展性。

3. 策略模式的实现

下面我们通过一个实际的 Java 示例来深入理解策略模式。

3.1 定义策略接口

首先，定义一个 Strategy 接口，它包含所有策略类的公共方法。

public interface Strategy {
    void executeAlgorithm();
}

3.2 实现具体策略类

接着，我们实现两个具体的策略类，它们分别代表不同的算法。

public class ConcreteStrategyA implements Strategy {
    @Override
    public void executeAlgorithm() {
        System.out.println("Executing strategy A.");
    }
}

public class ConcreteStrategyB implements Strategy {
    @Override
    public void executeAlgorithm() {
        System.out.println("Executing strategy B.");
    }
}

3.3 定义上下文类

然后，我们定义一个 Context 类，它持有一个策略对象，并通过该策略对象调用算法。

public class Context {
    private Strategy strategy;

    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    // 设置不同的策略
    public void setStrategy(Strategy strategy) {
        this.strategy = strategy;
    }

    // 执行当前策略
    public void execute() {
        strategy.executeAlgorithm();
    }
}

3.4 测试策略模式

现在我们通过测试代码来演示策略模式的使用：

public class StrategyPatternDemo {
    public static void main(String[] args) {
        // 创建不同的策略
        Strategy strategyA = new ConcreteStrategyA();
        Strategy strategyB = new ConcreteStrategyB();

        // 创建上下文，使用策略A
        Context context = new Context(strategyA);
        context.execute();  // 输出: Executing strategy A.

        // 切换策略为B
        context.setStrategy(strategyB);
        context.execute();  // 输出: Executing strategy B.
    }
}

3.5 策略模式的输出

Executing strategy A.
Executing strategy B.

4. 策略模式的优缺点

4.1 优点

灵活的算法选择：通过上下文类可以动态选择不同的策略，而无需修改客户端代码。这样，我们能够在运行时决定具体使用哪种策略，增强了代码的灵活性。
避免大量条件语句：策略模式避免了使用大量的 if-else 或 switch-case 语句来选择算法，使得代码更加清晰和简洁。
易于扩展：由于策略类都是独立的，如果要增加新算法，直接添加一个新的策略类即可，无需修改现有代码，符合开闭原则。
高内聚低耦合：每个策略类都封装了独立的行为，与其他策略类没有直接关系，提高了系统的内聚性，同时也增强了系统的可维护性。

4.2 缺点

增加类的数量：每种不同的算法或行为都需要一个具体策略类，这可能导致类的数量过多，尤其是在策略算法比较多时。
客户端必须了解所有策略：在一些情况下，客户端需要知道所有可能的策略，才能正确地选择并使用合适的策略。这可能导致一定的复杂度。

5. 策略模式与其他设计模式的对比

5.1 策略模式 vs 状态模式

策略模式和状态模式都涉及到动态改变对象行为，但两者的应用场景有所不同。

特性	策略模式	状态模式
用途	主要用于封装不同的算法	主要用于封装对象在不同状态下的行为
对象的行为改变	通过切换策略来改变对象行为	通过切换状态来改变对象行为
算法的切换	客户端明确选择策略	状态对象自行决定行为
实现方式	上下文持有策略实例，外部决定使用哪种策略	上下文持有状态实例，状态决定行为

策略模式更注重算法的选择与切换，而状态模式则关注对象的状态转换和行为表现。

5.2 策略模式 vs 工厂模式

策略模式和工厂模式常常一起使用，但它们的目的有所不同。

特性	策略模式	工厂模式
目的	封装不同的算法和行为	创建对象，尤其是创建复杂对象
关注点	运行时根据不同策略决定行为	提供一种创建对象的统一接口
实现方式	通过上下文对象在运行时选择策略	通过工厂方法创建对象并返回
适用场景	动态行为切换，避免条件语句	创建复杂对象，特别是当对象创建过程复杂时