策略模式（设计模式）

使用策略模式重构 if/else
策略设计模式是一种允许在运行时选择算法的行为。这种模式
● 定义了一系列算法
● 封装每种算法
● 使算法在该系列内可互换。
下面是策略设计模式的架构，客户端将在其中与上下文进行通信。上下文将包含对策略对象的引用，这反映了另一个设计原则 “针对接口而非实现编程”。
策略模式是指有一定行动内容的相对稳定的策略名称，策略模式作为一种软件设计模式，指对象有某个行为，但是在不同的场景中，该行为有不同的实现算法。
策略模式是一种行为设计模式，定义一系列算法，将每一个算法封装起来，并让它们可以相互替换。目的是实现方法的使用和实现分开
日常开发中，对于需要考虑各类场景、各类分支通用逻辑时，就需要考虑是否可以将if-else switch 逻辑替换成不同策略算法进行单独处理，提高代码的可读性、可维护性，避免代码混乱熵增。
这里简单介绍一下lambda替换策略模式的方式：
对于Collections#sort() 的排序方法，使用何种排序策略来自于java.util.Comparator#compare() 中定义。
javax.servlet.http.HttpServlet#ser­vice­()方法， 还有所有接受 Http­Servlet­Request和 Http­Servlet­Response对象作为参数的 do­XXX()方法。根据HttpServletRequest.getMethod 获取请求方式(GET、POST、PUT …)，用以路由处理各类请求策略。
如何识别是否是策略模式：通常策略模式可以通过允许嵌套对象完成实际工作的方法，允许将该对象替换为不同对象的设置器来识别

策略模式（Strategy Pattern）详解

策略模式（Strategy Pattern）是设计模式中的一种行为型模式。它定义了一系列算法，将每个算法封装起来，并使它们可以互相替换。这种模式使得算法可以在不影响客户端的情况下发生变化。策略模式通过消除条件语句来实现算法的动态选择。

结构
策略模式有三个主要部分：

1. Context（环境类）：
   维护一个对策略对象的引用。
   接受客户端请求，并委托给当前的策略对象处理。
2. Strategy（抽象策略类）：
   定义所有支持的算法的公共接口。
3. ConcreteStrategy（具体策略类）：
   实现了具体的算法。
   UML 类图
   ±--------------+ ±-------------------+
   | Context |<–uses— | Strategy |
   |---------------| ±-------------------+
   | - strategy | | + algorithmInterface() |
   | + contextInterface() | |
   ±--------------+ ±–^----------------+
   | |
   | |
   v v
   ±----------------+ ±----------------+
   | ConcreteStrategyA | | ConcreteStrategyB |
   | + algorithmInterface() | + algorithmInterface() |
   ±----------------+ ±----------------+

// Strategy Interface
public interface Strategy {
    public int doOperation(int num1, int num2);
}

// Concrete Strategy A
public class OperationAdd implements Strategy {
    @Override
    public int doOperation(int num1, int num2) {
        return num1 + num2;
    }
}

// Concrete Strategy B
public class OperationSubstract implements Strategy {
    @Override
    public int doOperation(int num1, int num2) {
        return num1 - num2;
    }
}

// Concrete Strategy C
public class OperationMultiply implements Strategy {
    @Override
    public int doOperation(int num1, int num2) {
        return num1 * num2;
    }
}

// Context Class
public class Context {
    private Strategy strategy;

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

    public void setStrategy(Strategy strategy) {
        this.strategy = strategy;
    }

    public int executeStrategy(int num1, int num2) {
        return strategy.doOperation(num1, num2);
    }
}

// Client Code
public class StrategyPatternDemo {
    public static void main(String[] args) {
        Context context = new Context(new OperationAdd());
        System.out.println("10 + 5 = " + context.executeStrategy(10, 5));

        context.setStrategy(new OperationSubstract());
        System.out.println("10 - 5 = " + context.executeStrategy(10, 5));

        context.setStrategy(new OperationMultiply());
        System.out.println("10 * 5 = " + context.executeStrategy(10, 5));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

优点

1. 易于扩展：可以方便地增加新的策略，而不会影响到已有的策略和上下文。
2. 避免使用多重条件转移语句：将条件语句的每个分支提取到独立的策略类中，使代码更加清晰、易读。
3. 提高代码的灵活性和可维护性：客户端可以在运行时选择策略，便于应对不断变化的需求。
4. 添加新策略不会干扰之前的任何代码。
5. 移除/重构之前的任何策略都是灵活的。
6. 易于单一测试。
   缺点
7. 增加对象数量：每一个具体策略都是一个类，会增加类的数量，增加系统复杂度。
8. 客户端必须了解所有策略：客户端需要知道所有的策略，并且自行决定使用哪一个策略。
   策略模式是一种非常常见且实用的设计模式，广泛应用于各种需要在运行时选择算法或者行为的场景中，例如支付方式选择、排序算法选择、路径规划算法选择等。