【Java设计模式】Java设计模式之（十五）策略模式（Strategy Pattern）

ゝ一纸荒年。 2022-08-31 15:14 202阅读 0赞

**本文目录**

一、策略模式介绍

1.1 含义

1.2 适用场景

1.3 主要解决

1.4 应用实例

1.5 优缺点

二、策略模式实现

2.1 类图

2.2 代码实现

第一个案例：策略模式代码实现

第二个案例：策略模式代码实现

2.3 角色分析

三、源码分析

--------------------

这种类型的设计模式属于行为型模式。

# 一、策略模式介绍 #

## 1.1 含义 ##

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

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

## 1.2 适用场景 ##

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

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

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

## 1.3 主要解决 ##

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

关键代码：实现同一个接口。

## 1.4 应用实例 ##

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

## 1.5 优缺点 ##

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

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

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

# 二、策略模式实现 #

>     所有设计模式的代码实现例子都可在码云上查看哦，感兴趣的可以查看哈，码云地址：https://gitee.com/no8g/java-design-patterns

## 2.1 类图 ##

*  策略模式的使用就是面向对象的继承和多态机制，其通用类图如下：

![20210726144629369.png][]

## 2.2 代码实现 ##

### 第一个案例：策略模式代码实现 ###

package com.iot.practice.designpattern.strategy.pattern1;
 
 /**
 * IStrategy 此接口用于：
 * @author：hujm
 * @date：2021年03月26日 14:53
 * @remark：首先定一个策略接口，这是诸葛亮老人家给赵云的三个锦囊妙计的接口
 */
 public interface IStrategy {
 
 /**
 * 每个锦囊妙计都是一个可执行的算法
 */
 public void operation();
 }

package com.iot.practice.designpattern.strategy.pattern1;
 
 /**
 * First 此类用于：找乔国老帮忙，使孙权不能杀刘备
 * @author：hujm
 * @date：2021年03月26日 14:54
 * @remark：然后再写三个实现类，有三个妙计嘛
 */
 public class First implements IStrategy {
 
 @Override
 public void operation() {
 System.out.println("找乔国老帮忙，让吴国太给孙权施加压力");
 }
 }

package com.iot.practice.designpattern.strategy.pattern1;
 
 /**
 * Second 此类用于：求吴国太开个绿灯
 * @author：hujm
 * @date：2021年03月26日 14:55
 * @remark：
 */
 public class Second implements IStrategy {
 
 @Override
 public void operation() {
 System.out.println("求吴国太开个绿灯,放行！ ");
 }
 }

package com.iot.practice.designpattern.strategy.pattern1;
 
 /**
 * Third 此类用于：孙夫人断后，挡住追兵
 * @author：hujm
 * @date：2021年03月26日 14:56
 * @remark：
 */
 public class Third implements IStrategy {
 
 @Override
 public void operation() {
 System.out.println("孙夫人断后，挡住追兵");
 }
 }

package com.iot.practice.designpattern.strategy.pattern1;
 
 /**
 * StrategyContext 此类用于：
 * @author：hujm
 * @date：2021年03月26日 14:57
 * @remark：计谋有了，那还要有锦囊
 */
 public class StrategyContext {
 
 private final IStrategy iStrategy;
 
 /**
 * 构造函数，你要使用那个妙计
 *
 * @param iStrategy 妙计接口入参
 */
 public StrategyContext(IStrategy iStrategy) {
 this.iStrategy = iStrategy;
 }
 
 /**
 * 使用计谋了，看我出招了
 */
 public void operation() {
 this.iStrategy.operation();
 }
 }

package com.iot.practice.designpattern.strategy.pattern1;
 
 /**
 * StrategyClient 此类用于：
 * @author：hujm
 * @date：2021年03月26日 14:57
 * @remark：赵云出场了，他根据诸葛亮给他的交代，依次拆开妙计
 */
 public class ZhaoYunClient {
 
 public static void main(String[] args) {
 
 // 刚刚到吴国的时候拆第一个
 System.out.println("-----------刚刚到吴国的时候拆第一个锦囊-------------");
 StrategyContext context = new StrategyContext(new First());
 context.operation();
 System.out.println("\n");
 
 // 刘备乐不思蜀了，拆第二个了
 System.out.println("-----------刘备乐不思蜀了，拆第二个了锦囊-------------");
 context = new StrategyContext(new Second());
 context.operation();
 System.out.println("\n");
 
 // 孙权的小兵追了，咋办？拆第三个
 System.out.println("-----------孙权的小兵追来了，咋办？拆第三个锦囊-------------");
 context = new StrategyContext(new Third());
 context.operation();
 }
 }

运行结果如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDI5OTAyNw_size_16_color_FFFFFF_t_70][]

### 第二个案例：策略模式代码实现 ###

package com.iot.practice.designpattern.strategy.pattern2;
 
 /**
 * IStrategy 此接口用于：策略接口
 * @author：hujm
 * @date：2021年07月26日 10:38
 * @remark：定义一个策略接口
 */
 public interface IStrategy {
 
 /**
 * 运算操作
 *
 * @param num1 数字1
 * @param num2 数字2
 * @return 运算结果
 */
 public int doOperation(int num1, int num2);
 }

package com.iot.practice.designpattern.strategy.pattern2;
 
 /**
 * AddOperation 此类用于：加法运算
 * @author：hujm
 * @date：2021年07月26日 10:40
 * @remark：实现策略的运算操作方法，在这里定义加法运算
 */
 public class AddOperation implements IStrategy {
 
 @Override
 public int doOperation(int num1, int num2) {
 return num1 + num2;
 }
 }

package com.iot.practice.designpattern.strategy.pattern2;
 
 /**
 * MinusOperation 此类用于：减法运算
 * @author：hujm
 * @date：2021年07月26日 10:43
 * @remark：实现策略的运算操作方法，在这里定义减法运算
 */
 public class MinusOperation implements IStrategy {
 
 @Override
 public int doOperation(int num1, int num2) {
 return num1 - num2;
 }
 }

package com.iot.practice.designpattern.strategy.pattern2;
 
 /**
 * MultiplyOperation 此类用于：乘法运算
 * @author：hujm
 * @date：2021年07月26日 10:44
 * @remark：实现策略的运算操作方法，在这里定义乘法运算
 */
 public class MultiplyOperation implements IStrategy {
 
 @Override
 public int doOperation(int num1, int num2) {
 return num1 * num2;
 }
 }

package com.iot.practice.designpattern.strategy.pattern2;
 
 /**
 * Context 此类用于：
 * @author：hujm
 * @date：2021年07月26日 10:46
 * @remark：创建Context类，它是一个使用了某种策略的类
 */
 public class Context {
 
 private final IStrategy iStrategy;
 
 public Context(IStrategy iStrategy) {
 this.iStrategy = iStrategy;
 }
 
 public int executeOperation(int num1, int num2) {
 return iStrategy.doOperation(num1, num2);
 }
 }

package com.iot.practice.designpattern.strategy.pattern2;
 
 /**
 * StrategyPatternDemo 此类用于：
 * @author：hujm
 * @date：2021年07月26日 10:50
 * @remark：使用 Context 来查看当它改变策略 Strategy 时的行为变化。
 */
 public class StrategyPatternDemo {
 
 public static void main(String[] args) {
 
 // 第一种策略，加法运算
 Context context = new Context(new AddOperation());
 System.out.println("20 + 5 = " + context.executeOperation(20, 5));
 
 // 第二种策略，减法运算
 context = new Context(new MinusOperation());
 System.out.println("20 - 5 = " + context.executeOperation(20, 5));
 
 // 第三种策略，乘法运算
 context = new Context(new MultiplyOperation());
 System.out.println("20 * 5 = " + context.executeOperation(20, 5));
 }
 }

运行结果如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDI5OTAyNw_size_16_color_FFFFFF_t_70 1][]

## 2.3 角色分析 ##

**① 抽象策略角色**：负责定义通常由一个接口或抽象类实现。此角色给出所有的具体策略类所需的接口。即示例代码中的IStrategy接口。

**② 策略实现类**：不同的类实现具体不同的算法。即示例代码中的First\\Second\\Third和AddOperation\\MinusOperation\\MultiplyOperation实现类。

**③ 环境角色类**：里面持有抽象策略角色的引用，然后客户端可以由具体的方法传不同参数或实现类进去得到不同算法。即示例代码中的StrategyContext和Context两个类。

# 三、源码分析 #

完结！

[20210726144629369.png]: /images/20220829/872dd75447c947e8b7b54f1cbfce9f10.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDI5OTAyNw_size_16_color_FFFFFF_t_70]: /images/20220829/37687108535545a9b2ea07c4747433db.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDI5OTAyNw_size_16_color_FFFFFF_t_70 1]: /images/20220829/26c28cc7359246e08a229ac5be44e327.png