设计模式之策略模式(转)
简说设计模式——策略模式（优先推荐此文）
https://www.cnblogs.com/adamjwh/p/11011095.html
一、什么是策略模式
策略这个词应该怎么理解，打个比方说，我们出门的时候会选择不同的出行方式，比如骑自行车、坐公交、坐火车、坐飞机、坐火箭等等，这些出行方式，每一种都是一个策略。
再比如我们去逛商场，商场现在正在搞活动，有打折的、有满减的、有返利的等等，其实不管商场如何进行促销，说到底都是一些算法，这些算法本身只是一种策略，并且这些算法是随时都可能互相替换的，比如针对同一件商品，今天打八折、明天满100减30，这些策略间是可以互换的。
策略模式（Strategy），定义了一组算法，将每个算法都封装起来，并且使它们之间可以互换。UML结构图如下：
其中，Context是上下文，用一个ConcreteStrategy来配置，维护一个对Strategy对象的引用；Strategy是策略类，用于定义所有支持算法的公共接口；ConcreteStrategy是具体策略类，封装了具体的算法或行为，继承于Strategy。
1. Context上下文
Context上下文角色，也叫Context封装角色，起承上启下的作用，屏蔽高层模块对策略、算法的直接访问，封装可能存在的变化。
1 public class Context {
2
3 Strategy strategy;
4
5 public Context(Strategy strategy) {
6 this.strategy = strategy;
7 }
8
9 //上下文接口
10 public void contextInterface() {
11 strategy.algorithmInterface();
12 }
13
14 }
2. 策略角色
抽象策略角色，是对策略、算法家族的抽象，通常为接口，定义每个策略或算法必须具有的方法和属性。algorithm是“运算法则”的意思。
1 public abstract class Strategy {
2
3 //算法方法
4 public abstract void algorithmInterface();
5
6 }
3. 具体策略角色
用于实现抽象策略中的操作，即实现具体的算法，下方用print代替。测试类共3个ConcreteStrategy，其它两个类与ConcreteStrategyA同理，就不再赘述了。
1 public class ConcreteStrategyA extends Strategy {
2
3 @Override
4 public void algorithmInterface() {
5 System.out.println("算法A实现");
6 }
7
8 }
4. Client客户端
下面依次更换策略，测试一下策略模式。
1 public class Client {
2
3 public static void main(String[] args) {
4 Context context;
5
6 context = new Context(new ConcreteStrategyA());
7 context.contextInterface();
8
9 context = new Context(new ConcreteStrategyB());
10 context.contextInterface();
11
12 context = new Context(new ConcreteStrategyC());
13 context.contextInterface();
14 }
15
16 }
运行结果如下：
二、策略模式的应用
1. 何时使用
- 一个系统有许多类，而区分它们的只是他们直接的行为时
2. 方法
- 将这些算法封装成一个一个的类，任意的替换
3. 优点
- 算法可以自由切换
- 避免使用多重条件判断（如果不用策略模式我们可能会使用多重条件语句，不利于维护）
- 扩展性良好，增加一个策略只需实现接口即可
4. 缺点
- 策略类数量会增多，每个策略都是一个类，复用的可能性很小
- 所有的策略类都需要对外暴露
5. 使用场景
- 多个类只有算法或行为上稍有不同的场景
- 算法需要自由切换的场景
- 需要屏蔽算法规则的场景
6. 应用实例
- 出行方式，自行车、汽车等，每一种出行方式都是一个策略
- 商场促销方式，打折、满减等
- Java AWT中的LayoutManager，即布局管理器
7. 注意事项
- 如果一个系统的策略多于四个，就需要考虑使用混合模式来解决策略类膨胀的问题
三、策略模式的实现
下面就以商场促销为例使用策略模式实现商场促销算法。UML图如下：
1. 上下文类
首先声明一个CashSuper对象，通过构造方法，传入具体的收费策略，getResult()方法的功能为根据收费策略的不同获得计算结果。
1 public class CashContext {
2
3 private CashSuper cashSuper;
4
5 public CashContext(CashSuper cashSuper) {
6 this.cashSuper = cashSuper;
7 }
8
9 public double getResult(double money) {
10 return cashSuper.acceptCash(money);
11 }
12
13 }
2. 现金收费抽象类
策略类，为抽象类，抽象出收费的方法供子类实现。
1 public abstract class CashSuper {
2
3 public abstract double acceptCash(double money);
4
5 }
3. 正常收费子类
没有任何活动的情况，正常收费，返回原价。
1 public class CashNormal extends CashSuper {
2
3 @Override
4 public double acceptCash(double money) {
5 return money;
6 }
7
8 }
4. 打折收费子类
打折活动，根据折扣返回打折后的价格。
1 public class CashRebate extends CashSuper {
2
3 private double moneyRebate = 1; //折扣
4
5 public CashRebate(double moneyRebate) {
6 this.moneyRebate = moneyRebate;
7 }
8
9 @Override
10 public double acceptCash(double money) {
11 return money * moneyRebate;
12 }
13
14 }
5. 返利收费子类
返利活动，输入返利条件和返利值，比如满300返100，moneyCoditation为300，moneyReturn为100。
result = money - Math.floor(money / moneyConditation) * moneyReturn; 的意思为，如果当前金额大于等于返利条件，则使用当前金额减去返利值。
1 public class CashReturn extends CashSuper {
2
3 private double moneyConditation = 0.0; //返利条件
4 private double moneyReturn = 0.0d; //返利值
5
6 public CashReturn(double moneyConditation, double moneyReturn) {
7 this.moneyConditation = moneyConditation;
8 this.moneyReturn = moneyReturn;
9 }
10
11 @Override
12 public double acceptCash(double money) {
13 double result = money;
14
15 if (money >= moneyConditation) {
16 result = money - Math.floor(money / moneyConditation) * moneyReturn;
17 }
18
19 return result;
20 }
21
22 }
6. Client客户端
下面写一个简单的程序测试一下上方编写的代码。
1 public class Client {
2
3 public static void main(String[] args) {
4 CashContext cashContext = null;
5
6 Scanner scanner = new Scanner(System.in);
7 System.out.print("请输入打折方式（1/2/3）：");
8 int in = scanner.nextInt();
9 String type = "";
10
11 switch (in) {
12 case 1:
13 cashContext = new CashContext(new CashNormal());
14 type += "正常收费";
15 break;
16
17 case 2:
18 cashContext = new CashContext(new CashReturn(300, 100));
19 type += "满300返100";
20 break;
21
22 case 3:
23 cashContext = new CashContext(new CashRebate(0.8));
24 type += "打8折";
25 break;
26
27 default:
28 System.out.println("请输入1/2/3");
29 break;
30 }
31
32 double totalPrices = 0;
33
34 System.out.print("请输入单价：");
35 double price = scanner.nextDouble();
36 System.out.print("请输入数量：");
37 double num = scanner.nextDouble();
38 totalPrices = cashContext.getResult(price * num);
39
40 System.out.println("单价：" + price + "，数量：" + num + "，类型：" + type + "，合计：" + totalPrices);
41
42 scanner.close();
43 }
44
45 }
正常收费结果如下：
返利收费结果如下：
打折收费结果如下：
源码地址：https://gitee.com/adamjiangwh/GoF
另外一篇博文介绍：
一、理解策略模式
为了更好的理解这个模式，我们再举一个例子，我们出去旅游的时候可能有很多种出行方式，比如说我们可以坐火车、坐高铁、坐飞机等等。不管我们使用哪一种出行方式，最终的目的地都是一样的。也就是选择不同的方式产生的结果都是一样的。
有了这个例子，我相信你应该对其思想有了一个基本的认识，下面看一下其正式的概念介绍：
定义一系列的算法,把每一个算法封装起来, 并且使它们可相互替换
二、实现策略模式
策略模式把对象本身和运算规则区分开来，因此我们整个模式也分为三个部分。
环境类(Context):用来操作策略的上下文环境，也就是我们游客。抽象策略类(Strategy):策略的抽象，出行方式的抽象具体策略类(ConcreteStrategy):具体的策略实现，每一种出行方式的具体实现。下面我们代码去实现一遍就能很清楚的理解了，
第一步：定义抽象策略接口+
第二步：具体策略类
第三步：环境类实现
三、分析策略模式
1、为什么要使用策略模式？
策略模式的优点：
我们之前在选择出行方式的时候，往往会使用if-else语句，也就是用户不选择A那么就选择B这样的一种情况。这种情况耦合性太高了，而且代码臃肿，有了策略模式我们就可以避免这种现象，策略模式遵循开闭原则，实现代码的解耦合。扩展新的方法时也比较方便，只需要继承策略接口就好了上面列出的这两点算是策略模式的优点了，但是不是说他就是完美的，有很多缺点仍然需要我们去掌握和理解，
客户端必须知道所有的策略类，并自行决定使用哪一个策略类。策略模式会出现很多的策略类。context在使用这些策略类的时候，这些策略类由于继承了策略接口，所以有些数据可能用不到，但是依然初始化了。2、与其他模式的区别？
（1）与状态模式的区别
策略模式只是条件选择方法，只执行一次方法，而状态模式是随着状态的改变不停地更改执行方法。举个例子，就好比我们旅游，对于策略模式我们只需要选择其中一种出行方法就好了，但是状态模式不一样，可能我们到了A地点选择的是火车，到了B地点又选择飞机，根据不同的状态选择不同的出行方式。
（2）与工厂模式的区别
工厂模式是创建型模式 ，它关注对象创建，提供创建对象的接口，让对象的创建与具体的使用客户无关。 策略模式是对象行为型模式 ，它关注行为和算法的封装 。再举个例子，还是我们出去旅游，对于策略模式我们只需要选择其中一种出行方法就好，但是工厂模式不同，工厂模式是你决定哪种旅行方案后，由工厂代替你去构建具体方案（工厂代替你去买火车票）。
3、使用场景是什么？
说实话，对于设计模式来说，使用场景仅仅只是举一两个例子。如果你能够理解我们出去旅游的这个案例，基本上你也就能在自己遇到这种情况的时候自动的去选择它。这里就不说了。
OK，策略模式还是比较简单的。一句话说明白就是一个问题有好几种解法，我们选择其中一种就可以了
转自：
https://baijiahao.baidu.com/s?id=1638224488060180625&wfr=spider&for=pc
