设计模式教程：策略模式（Strategy Pattern）

一、概述

策略模式（Strategy Pattern） 是一种行为型设计模式，旨在定义一系列算法（或行为），并将它们封装到独立的类中，使得它们可以互相替换。策略模式让算法的变化独立于使用算法的客户端，从而解决了传统代码中将不同算法嵌入到同一个类中的问题。通过策略模式，我们可以灵活地选择不同的策略，而不需要修改具体的业务代码。

二、策略模式的结构

策略模式主要包括以下几个角色：

Context（上下文类）
- 作用：维护一个对策略对象的引用，并根据需要执行策略。上下文类并不关心具体使用哪一种策略，它只负责将策略委托给具体的策略类。
- 职责：使用策略并与策略交互。
Strategy（策略接口）
- 作用：定义一个公共接口，所有具体的策略都必须实现这个接口。
- 职责：声明执行某个操作的算法或行为。
ConcreteStrategy（具体策略类）
- 作用：实现策略接口中的具体行为。
- 职责：封装具体的算法或业务逻辑，提供不同的实现方式。

三、策略模式的优缺点

优点：

避免了大量的条件判断：使用策略模式将不同的算法或行为封装到不同的策略类中，避免了在代码中出现大量的 if-else 或 switch-case 判断。
增加可扩展性：当需要增加新的策略时，只需要新增一个策略类，不需要修改现有的代码，符合开闭原则（对扩展开放，对修改关闭）。
减少了类的耦合度：策略模式让算法独立于客户端，减少了不同算法之间的依赖性，使得代码更加灵活、易于测试。

缺点：

增加了类的数量：每增加一个策略就需要增加一个新的策略类，因此在策略较多时，可能会导致类的数量较多，增加代码复杂度。
客户端必须知道所有策略：虽然策略的使用是灵活的，但客户端必须知道可以使用哪些策略，可能会使得客户端代码变得稍显复杂。

四、策略模式的应用场景

策略模式适用于以下几种情况：

算法的选择：如果某个类的行为表现为多种不同的算法，且这些算法之间可以互换，策略模式非常适合。
避免条件语句：当一个类的行为依赖于多个条件语句来选择不同的算法时，使用策略模式可以清晰地组织代码，避免过多的条件判断。
系统中的策略经常变化：当系统中的策略在运行时发生变化，且希望能够灵活切换这些策略时，策略模式可以很好地提供解决方案。

五、策略模式的实现

下面我们通过一个例子来展示如何使用策略模式。

1. 定义策略接口

首先，我们需要定义一个 Strategy 接口，它包含一个 execute() 方法，所有的具体策略类都需要实现这个接口。

public interface Strategy {
    void execute();
}

2. 定义具体策略类

然后，我们定义几种具体的策略类，每种策略实现 Strategy 接口，并提供不同的行为。

// 具体策略1：加法策略
public class AddStrategy implements Strategy {
    @Override
    public void execute() {
        System.out.println("执行加法策略");
    }
}

// 具体策略2：减法策略
public class SubtractStrategy implements Strategy {
    @Override
    public void execute() {
        System.out.println("执行减法策略");
    }
}

// 具体策略3：乘法策略
public class MultiplyStrategy implements Strategy {
    @Override
    public void execute() {
        System.out.println("执行乘法策略");
    }
}

3. 定义上下文类

接下来，我们定义一个 Context 类，它包含一个 Strategy 类型的成员变量，并提供一个 setStrategy() 方法来设置策略，最后通过 executeStrategy() 方法来执行策略。

public class Context {
    private Strategy strategy;

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

    // 执行策略
    public void executeStrategy() {
        strategy.execute();
    }
}

4. 使用策略模式

在 Main 方法中，我们创建一个 Context 对象，并在运行时动态地切换不同的策略。

public class Main {
    public static void main(String[] args) {
        // 创建上下文对象
        Context context = new Context();
        
        // 设置加法策略
        context.setStrategy(new AddStrategy());
        context.executeStrategy();  // 输出：执行加法策略
        
        // 设置减法策略
        context.setStrategy(new SubtractStrategy());
        context.executeStrategy();  // 输出：执行减法策略
        
        // 设置乘法策略
        context.setStrategy(new MultiplyStrategy());
        context.executeStrategy();  // 输出：执行乘法策略
    }
}

六、深入分析

在这个例子中，Strategy 接口定义了策略的标准方法，具体的策略类（AddStrategy、SubtractStrategy 和 MultiplyStrategy）实现了不同的行为。Context 类则是策略模式的核心，它持有一个 Strategy 对象，并提供 setStrategy() 方法来动态切换策略。

为什么使用策略模式？

避免了条件语句：如果没有使用策略模式，我们可能会在 Context 类中使用一系列的 if-else 或 switch-case 语句来判断当前选择的策略，而策略模式通过将每种策略封装到独立的类中，避免了这种情况。
提高了可扩展性：当需要新增一种策略时，只需要创建一个新的策略类，并将其传入 Context 类中，无需修改已有的代码。
符合开闭原则：增加新的策略不会影响现有代码的运行，符合对扩展开放，对修改关闭的原则。