策略模式（Strategy Pattern）也被称为政策模式（Policy Pattern），是在 GoF 23 种设计模式中定义了的行为型模式。

策略模式 是针对一组算法，将每一个算法封装到具有共同接口的独立的类中，使得它们可以互换，被封装起来的算法具有独立性外部不可改变其特性。

～

本片文章内容包括：关于策略模式、策略模式 Demo（伪代码）、策略模式的应用（Comparator 中的策略模式）

文章目录

• • 一、关于策略模式
  • • • 1、关于策略模式
      • 2、关于策略模式的构成
      • 3、关于策略模式的XML
      • 4、关于策略模式的使用场景
      • 5、关于策略模式的优缺点
  • 二、策略模式 Demo（伪代码）
  • • • 1、伪代码 Demo 实现
      • 2、Demo 测试
  • 三、策略模式的应用（Comparator 中的策略模式）

一、关于策略模式

1、关于策略模式

策略模式（Strategy Pattern）也被称为政策模式（Policy Pattern），是在 GoF 23 种设计模式中定义了的行为型模式。

策略模式 是针对一组算法，将每一个算法封装到具有共同接口的独立的类中，使得它们可以互换，被封装起来的算法具有独立性外部不可改变其特性。

策略模式 在实际的项目开发中，这个模式也比较常用。最常见的应用场景是，利用它来避免冗长的 if-else 或 switch 分支判断。不过，它的作用还不止如此。它也可以像模板模式那样，提供框架的扩展点等等。

2、关于策略模式的构成

策略模式主要由 3 种角色构成：

• 环境类（StrategyContext）：策略上下文对象，维护指向具体策略的引用，通过策略接口 Strategy 与对象进行沟通。
• 抽象策略类（Strategy）：策略接口，定义统一的策略入口方法，留给具体策略类实现，且供 StrategyContext 调用。
• 具体策略类（ConcreteStrategy）：具体的策略类，实现 Strategy，提供各种不同的算法。

3、关于策略模式的XML

4、关于策略模式的使用场景

• 一个系统需要动态地在几种算法中选择一种时，可将每个算法封装到策略类中。
• 一个类定义了多种行为，并且这些行为在这个类的操作中以多个条件语句的形式出现，可将每个条件分支移入它们各自的策略类中以代替这些条件语句。
• 系统中各算法彼此完全独立，且要求对客户隐藏具体算法的实现细节时。
• 系统要求使用算法的客户不应该知道其操作的数据时，可使用策略模式来隐藏与算法相关的数据结构。
• 多个类只区别在表现行为不同，可以使用策略模式，在运行时动态选择具体要执行的行为。

5、关于策略模式的优缺点

# 策略模式优点

• 策略模式符合开闭原则；
• 避免了使用多重条件语句。如 if…else…语句、switch语句；
• 使用策略模式可以提高算法的保密性和安全性。

# 策略模式缺点

• 客户端必须知道所有策略，并自行决定使用那种策略；
• 代码中会产生非常多的策略，增加维护难度；
• 如果业务逻辑不是很复杂，强行使用策略模式会增加程序的复杂度。

二、策略模式 Demo（伪代码）

1、伪代码 Demo 实现

# Context 环境类

public class Context {/*** 持有一个具体策略的对象*/private final Strategy strategy;/*** 构造函数，传入一个具体策略对象** @param strategy 具体策略对象*/public Context(Strategy strategy) {this.strategy = strategy;}/*** 策略方法*/public void contextInterface() {strategy.interfaceStrategy();}}

# Strategy 抽象策略类

public interface Strategy {/*** 策略方法*/public void interfaceStrategy();
}

# ConcreteStrategy 具体策略类

public class ConcreteStrategyA implements Strategy {@Overridepublic void interfaceStrategy() {//相关的业务}}
public class ConcreteStrategyB implements Strategy {@Overridepublic void interfaceStrategy() {//相关的业务}}
public class ConcreteStrategyC implements Strategy {@Overridepublic void interfaceStrategy() {//相关的业务}}

2、Demo 测试

public class Client {public static void main(String[] args) {// 模拟业务参数String parameter = "A";public static void main(String[] args) {// 模拟业务参数String parameter = "A";// 执行使用A策略Context context1 = new Context(new ConcreteStrategyA());context1.contextInterface();// 执行使用B策略Context context2 = new Context(new ConcreteStrategyB());context2.contextInterface();// 执行使用C策略Context context3 = new Context(new ConcreteStrategyB());context3.contextInterface();}  }
}

三、策略模式的应用（Comparator 中的策略模式）

JDK 中最常见的策略模式，就是 Comparator 中的策略模式。在 Arrays 类中有一个 sort() 方法：

public class Arrays{public static  void sort(T[] a, Comparator c) {if (c == null) {sort(a);} else {if (LegacyMergeSort.userRequested)legacyMergeSort(a, c);elseTimSort.sort(a, 0, a.length, c, null, 0, 0);}}
}

Arrays 就是一个环境角色类，这个 sort 方法可以传一个新策略让 Arrays 根据这个策略来进行排序。如下测试类：

public class demo {public static void main(String[] args) {Integer[] data = {12, 2, 3, 2, 4, 5, 1};// 实现降序排序Arrays.sort(data, new Comparator() {public int compare(Integer o1, Integer o2) {return o2 - o1;}});System.out.println(Arrays.toString(data)); //[12, 5, 4, 3, 2, 2, 1]}
}

这里我们在调用 Arrays 的 sort 方法时，第二个参数传递的是 Comparator 接口的子实现类对象。所以 Comparator 充当的是抽象策略角色，而具体的子实现类充当的是具体策略角色。环境角色类（Arrays）应该持有抽象策略的引用来调用。那么，Arrays 类的 sort 方法到底有没有使用 Comparator 子实现类中的 compare() 方法吗？让我们继续查看 TimSort 类的 sort() 方法，代码如下：

class TimSort {static  void sort(T[] a, int lo, int hi, Comparator c,T[] work, int workBase, int workLen) {assert c != null && a != null && lo >= 0 && lo <= hi && hi <= a.length;int nRemaining  = hi - lo;if (nRemaining < 2)return;  // Arrays of size 0 and 1 are always sorted// If array is small, do a "mini-TimSort" with no mergesif (nRemaining < MIN_MERGE) {int initRunLen = countRunAndMakeAscending(a, lo, hi, c);binarySort(a, lo, hi, lo + initRunLen, c);return;}...}   private static  int countRunAndMakeAscending(T[] a, int lo, int hi,Comparator c) {assert lo < hi;int runHi = lo + 1;if (runHi == hi)return 1;// Find end of run, and reverse range if descendingif (c.compare(a[runHi++], a[lo]) < 0) { // Descendingwhile (runHi < hi && c.compare(a[runHi], a[runHi - 1]) < 0)runHi++;reverseRange(a, lo, runHi);} else {                              // Ascendingwhile (runHi < hi && c.compare(a[runHi], a[runHi - 1]) >= 0)runHi++;}return runHi - lo;}
}

上面的代码中最终会跑到 countRunAndMakeAscending() 这个方法中。我们可以看见，只用了 compare 方法，所以在调用 Arrays.sort 方法只传具体 compare 重写方法的类对象就行，这也是 Comparator 接口中必须要子类实现的一个方法。