设计模式—–策略模式
- 2019 年 11 月 2 日
- 笔记
策略模式
定义
所谓策略模式就是定义了算法族，分别封装起来，让他们之前可以互相转换，此模式让该算法的变化独立于使用算法的客户
理解
**策略这个词应该怎么理解，打个比方说，我们出门的时候会选择不同的出行方式，比如骑自行车、坐公交、坐火车、坐飞机、坐火箭等等，这些出行方式，每一种都是一个策略 **
**再比如我们去逛商场，商场现在正在搞活动，有打折的、有满减的、有返利的等等，其实不管商场如何进行促销，说到底都是一些算法，这些算法本身只是一种策略，并且这些算法是随时都可能互相替换的，比如针对同一件商品，今天打八折、明天满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.注意事项
- 如果一个系统的策略多于四个，就需要考虑使用混合模式来解决策略类膨胀的问题
