策略模式

定义

所谓策略模式就是定义了算法族，分别封装起来，让他们之前可以互相转换，此模式然该算法的变化独立于使用算法的客户

理解

**策略这个词应该怎么理解，打个比方说，我们出门的时候会选择不同的出行方式，比如骑自行车、坐公交、坐火车、坐飞机、坐火箭等等，这些出行方式，每一种都是一个策略 **

**再比如我们去逛商场，商场现在正在搞活动，有打折的、有满减的、有返利的等等，其实不管商场如何进行促销，说到底都是一些算法，这些算法本身只是一种策略，并且这些算法是随时都可能互相替换的，比如针对同一件商品，今天打八折、明天满100减30，这些策略间是可以互换的 **

UML类图

**其中，Context是上下文，用一个ConcreteStrategy来配置，维护一个对Strategy对象的引用；Strategy是策略类，用于定义所有支持算法的公共接口；ConcreteStrategy是具体策略类，封装了具体的算法或行为，继承于Strategy **

解释

1.Context 上下文

Context上下文角色，也叫Context封装角色，起承上启下的作用，屏蔽高层模块对策略、算法的直接访问，封装可能存在的变化

public class Context { Strategy strategy; public Context(Strategy strategy){ this.strategy = strategy; } /** * 上下文接口 */ public void contextInterface(){ strategy.algorithmInterface(); } }

2.Strategy 策略角色

抽象策略角色，是对策略、算法家族的抽象，通常为接口，定义每个策略或算法必须具有的方法和属性。algorithm是“运算法则”的意思

public interface Strategy { /** * 算法方法 */ public void algorithmInterface(); }

3.具体策略角色

用于实现抽象策略中的操作，即实现具体的算法，下方用print代替。测试类共3个ConcreteStrategy，其它两个类与ConcreteStrategyA同理，就不再赘述了

class ConcreteStrategyA implements Strategy{ @Override public void algorithmInterface() { System.out.println("策略A的具体算法实现"); } }

4.Client 客户端

下面依次更换策略，测试一下策略模式

public class StrategyClient { public static void main(String[] args) { Context context; context = new Context(new ConcreteStrategyA()); context.contextInterface(); context = new Context(new ConcreteStrategyB()); context.contextInterface(); context = new Context(new ConcreteStrategyC()); context.contextInterface(); } }

运行结果如下：

实例一：

​ 我们都知道排序算法有很多种，但是什么时候选择冒泡排序，什么时候选择选择排序，什么时候选择插入排序，所以这里用排序算法来演示策略模式的实现

public void selectSort(String type){ if("type1".equals(type)){ //选择快速排序 } else if("type2".equals(type)){ //选择插入排序 } else if("type3".equals(type)){ //选择冒泡排序 } else if("type4".equals(type)){ //选择选择排序 } ...... }

对于这样的代码实现，除了代码中充斥着大量的if…else if…else,导致程序可维护性很差，而且系统的可扩展性不好，如果某个排序模块进行更改了，有可能需要修改源代码。所以在对于这样的情景是非常合适使用策略模式的。

那么如何使用策略模式呢？首先我们需要定义一个接口，该接口提供排序算法，然后定义想要的排序算法，实现给接口即可。如下：

首先是Sort接口，该接口定义了排序算法，所有的排序算法都应该实现该接口

public interface Sort{ public abstract int[] sort(int arr[]); }

然后是三个具体的排序算法，他们实现Sort接口。

**冒泡排序：BubbleSort.java **

public class BubbleSort implements Sort{ public int[] sort(int arr[]){ int len=arr.length; for(int i=0;i<len;i++){ for(int j=i+1;j<len;j++){ int temp; if(arr[i]>arr[j]){ temp=arr[j]; arr[j]=arr[i]; arr[i]=temp; } } } System.out.println("冒泡排序"); return arr; } }

**插入排序：InsertionSort.java **

public class InsertionSort implements Sort { public int[] sort(int arr[]) { int len = arr.length; for (int i = 1; i < len; i++) { int j; int temp = arr[i]; for (j = i; j > 0; j--) { if (arr[j - 1] > temp) { arr[j] = arr[j - 1]; } else break; } arr[j] = temp; } System.out.println("插入排序"); return arr; } }

**选择排序：SelectSort.java **

public class SelectionSort implements Sort { public int[] sort(int arr[]) { int len = arr.length; int temp; for (int i = 0; i < len; i++) { temp = arr[i]; int j; int samllestLocation = i; for (j = i + 1; j < len; j++) { if (arr[j] < temp) { temp = arr[j]; samllestLocation = j; } } arr[samllestLocation] = arr[i]; arr[i] = temp; } System.out.println("选择排序"); return arr; } }

**最后就是测试类客户端了Client.java **

public class ArrayHandler { private Sort sortObj; public int[] sort(int arr[]) { sortObj.sort(arr); return arr; } public void setSortObj(Sort sortObj) { this.sortObj = sortObj; } } public class Client { public static void main(String args[]) { int arr[]={1,4,6,2,5,3,7,10,9}; int result[]; ArrayHandler ah=new ArrayHandler(); Sort sort = new SelectionSort(); //使用选择排序 ah.setSortObj(sort); //设置具体策略 result=ah.sort(arr); for(int i=0;i<result.length;i++) { System.out.print(result[i] + ","); } } }

运行结果：

选择排序

1,2,3,4,5,6,7,9,10,

实例二：

**以商场促销为例使用策略模式实现商场促销算法 **

1. 上下文类

首先声明一个CashSuper对象，通过构造方法，传入具体的收费策略，getResult()方法的功能为根据收费策略的不同获得计算结果。

public class CashContext { private CashSuper cashSuper; public CashContext(CashSuper cashSuper) { this.cashSuper = cashSuper; } public double getResult(double money) { return cashSuper.acceptCash(money); } }

2. 现金收费抽象类

策略类，为抽象类，抽象出收费的方法供子类实现。

public abstract class CashSuper { public abstract double acceptCash(double money); }

3. 正常收费子类

没有任何活动的情况，正常收费，返回原价。

public class CashNormal extends CashSuper { @Override public double acceptCash(double money) { return money; } }

4. 打折收费子类

打折活动，根据折扣返回打折后的价格。

public class CashRebate extends CashSuper { private double moneyRebate = 1; //折扣 public CashRebate(double moneyRebate) { this.moneyRebate = moneyRebate; } @Override public double acceptCash(double money) { return money * moneyRebate; } }

5. 返利收费子类

返利活动，输入返利条件和返利值，比如满300返100，moneyCoditation为300，moneyReturn为100。

result = money - Math.floor(money / moneyConditation) * moneyReturn; 的意思为，如果当前金额大于等于返利条件，则使用当前金额减去返利值

public class CashReturn extends CashSuper { private double moneyConditation = 0.0; //返利条件 private double moneyReturn = 0.0d; //返利值 public CashReturn(double moneyConditation, double moneyReturn) { this.moneyConditation = moneyConditation; this.moneyReturn = moneyReturn; } @Override public double acceptCash(double money) { double result = money; if (money >= moneyConditation) { result = money - Math.floor(money / moneyConditation) * moneyReturn; } return result; } }

6. Client客户端

下面写一个简单的程序测试一下上方编写的代码。

public class Client { public static void main(String[] args) { CashContext cashContext = null; Scanner scanner = new Scanner(System.in); System.out.print("请输入打折方式（1/2/3）："); int in = scanner.nextInt(); String type = ""; switch (in) { case 1: cashContext = new CashContext(new CashNormal()); type += "正常收费"; break; case 2: cashContext = new CashContext(new CashReturn(300, 100)); type += "满300返100"; break; case 3: cashContext = new CashContext(new CashRebate(0.8)); type += "打8折"; break; default: System.out.println("请输入1/2/3"); break; } double totalPrices = 0; System.out.print("请输入单价："); double price = scanner.nextDouble(); System.out.print("请输入数量："); double num = scanner.nextDouble(); totalPrices = cashContext.getResult(price * num); System.out.println("单价：" + price + "，数量：" + num + "，类型：" + type + "，合计：" + totalPrices); scanner.close(); } }

正常收费结果如下：

应用

1.何时使用

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

2.方法

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

3.优点

算法可以自由切换避免使用多重条件判断（如果不用策略模式我们可能会使用多重条件语句，不利于维护）扩展性良好，增加一个策略只需实现接口即可

4.缺点

策略类数量会增多，每个策略都是一个类，复用的可能性很小所有的策略类都需要对外暴露

5.使用场景

多个类只有算法或行为上稍有不同的场景算法需要自由切换的场景需要屏蔽算法规则的场景

6.应用实例

出行方式，自行车、汽车等，每一种出行方式都是一个策略商场促销方式，打折、满减等Java AWT中的LayoutManager，即布局管理器

7.注意事项

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