设计模式——策略模式

在 策略模式( Strategy Pattern) 中，一个类的行为或其算法可以在运行时更改。这种类型的设计模式属于行为型模式。

• 意图：定义一系列的算法，把它们一个个封装起来，并且使它们可相互替换。

• 主要解决：if-else带来的复杂度和难以维护。

• 如何解决：将这些算法封装成一个个类，在调用的时候可以任意地替换。

• 核心代码：①所有策略实现同一个接口或抽象类；②存储不同策略的容器

• 代码实现

将行为或算法提出来放在策略的接口中；

public interface CalculateStrategy {
    int doOperation(int num1, int num2);
}
1
2
3

实现不同的行为或算法；

public class OperationAdd implements CalculateStrategy {

    @Override
    public int doOperation(int num1, int num2) {
        return num1 + num2;
    }
}

public class OperationMinus implements CalculateStrategy {
    @Override
    public int doOperation(int num1, int num2) {
        return num1 - num2;
    }
}

public class OperationMultiply implements CalculateStrategy {
    @Override
    public int doOperation(int num1, int num2) {
        return num1 * num2;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

设计一个容器，通过容器来获取不同的策略；我这里是使用反射实现的，也可以用多态、Map、IOC等方式实现；

public class OperationsContext {
    private CalculateStrategy calculateStrategy;

    public CalculateStrategy getCalculateStrategy(String strategyName) {
        CalculateStrategy strategyInstance = null;
        try {
            strategyInstance = (CalculateStrategy)
                    Class.forName("com.neu.dp.strategy3." + strategyName)
                            .newInstance();
        } catch (Exception e) {
            System.err.println(e);
        }
        return strategyInstance;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

测试

@SpringBootTest
@RunWith(SpringRunner.class)
public class CalculateStrategyTest {

    private OperationsContext operationsContext = new OperationsContext();

    @org.junit.Test
    public void testStrategy(){
        String add = "OperationAdd";
        String minus = "OperationMinus";
        String multiply = "OperationMultiply";
        CalculateStrategy calculateStrategy = operationsContext.getCalculateStrategy(add);
        int result = calculateStrategy.doOperation(3, 5);
        System.out.println(result);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

• 优点： ①算法可以自由切换。②避免使用多重条件判断。③扩展性良好。

• 缺点：①策略类会增多。②所有策略类都需要对外暴露。

• 使用场景:
  ①如果在一个系统里面有许多类，它们之间的区别仅在于它们的行为，那么使用策略模式可以动态地让一个对象在许多行为中选择一种行为。
  ②一个系统需要动态地在几种算法中选择一种。
  ③如果一个对象有很多的行为，如果不用恰当的模式，这些行为就只好使用多重的条件选择语句来实现。