行为类型11-2：策略模式(Strategy Pattern)

1. 概述

在策略模式（Strategy Pattern）中，一个类的行为或其算法可以在运行时更改。

在策略模式中，我们创建表示各种策略的对象和一个行为随着策略对象改变而改变的 context 对象。策略对象改变 context 对象的执行算法。

定义一系列的算法,把它们一个个封装起来,并且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化。

2. 介绍

2.1 意图

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

2.2 主要解决

在有多种算法相似的情况下，使用 if…else 所带来的复杂和难以维护。

2.3 何时使用

一个系统有许多许多类，而区分它们的只是他们直接的行为。

2.4 如何解决

将这些算法封装成一个一个的类，任意地替换。

2.5 关键代码

实现同一个接口。

2.6 应用实例

1、诸葛亮的锦囊妙计，每一个锦囊就是一个策略。 2、旅行的出游方式，选择骑自行车、坐汽车，每一种旅行方式都是一个策略。 3、JAVA AWT 中的 LayoutManager。

2.7 优点

1、算法可以自由切换。 2、避免使用多重条件判断。 3、扩展性良好。

2.8 缺点

1、策略类会增多。 2、所有策略类都需要对外暴露。

2.9 使用场景

1、如果在一个系统里面有许多类，它们之间的区别仅在于它们的行为，那么使用策略模式可以动态地让一个对象在许多行为中选择一种行为。

2、一个系统需要动态地在几种算法中选择一种。

3、如果一个对象有很多的行为，如果不用恰当的模式，这些行为就只好使用多重的条件选择语句来实现。

4.许多相关的类仅仅是行为有异。“策略”提供了一种用多个行为中的一个行为来配置一个类的方法。

5.需要使用一个算法的不同变体。

6.算法使用客户不应该知道的数据。可使用策略模式以避免暴露复杂的、与算法相关的数据结构。

7.一个类定义了多种行为,并且这些行为在这个类的操作中以多个条件语句的形式出现。
将相关的条件分支移入它们各自的Strategy类中以代替这些条件语句。

2.10 注意事项

如果一个系统的策略多于四个，就需要考虑使用混合模式，解决策略类膨胀的问题。

3. 参与者

1.Strategy
	定义所有支持的算法的公共接口。Context使用这个接口来调用某ConcreteStrategy定义的算法。

2.ConcreteStrategy
	以Strategy接口实现某具体算法。

3.Context
	用一个ConcreteStrategy对象来配置。
	维护一个对Strategy对象的引用。
	可定义一个接口来让Stategy访问它的数据。

4. 类图

在这里插入图片描述

5. 例子

5.1 Strategy

public abstract class Strategy {
    public abstract void method();
}

5.2 ConcreteStrategy

public class StrategyImplA extends Strategy {
    public void method() {
        System.out.println("这是第一个实现");
    }
}

public class StrategyImplB extends Strategy {
    public void method() {
        System.out.println("这是第二个实现");
    }
}

public class StrategyImplC extends Strategy {
    public void method() {
        System.out.println("这是第三个实现");
    }
}

5.3 Context

public class Context {
    Strategy stra;
    
    public Context(Strategy stra) {
        this.stra = stra;
    }
    
    public void doMethod() {
        stra.method();
    }
}

Test

public class Test {
    
    public static void main(String[] args) {
        Context ctx = new Context(new StrategyImplA());
        ctx.doMethod();
        
        ctx = new Context(new StrategyImplB());
        ctx.doMethod();
        
        ctx = new Context(new StrategyImplC());
        ctx.doMethod();
    }
}

result

这是第一个实现
这是第二个实现
这是第三个实现

6. 示例2

我们将创建一个定义活动的 Strategy 接口和实现了 Strategy 接口的实体策略类。Context 是一个使用了某种策略的类。

StrategyPatternDemo，我们的演示类使用 Context 和策略对象来演示 Context 在它所配置或使用的策略改变时的行为变化。
在这里插入图片描述

6.1

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

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

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

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

public class Context {
    private Strategy strategy;

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

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

test

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 = new Context(new OperationSubstract());
        System.out.println("10 - 5 = " + context.executeStrategy(10, 5));

        context = new Context(new OperationMultiply());
        System.out.println("10 * 5 = " + context.executeStrategy(10, 5));
    }
}