策略模式
策略模式（Strategy）: 定义了算法家族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化，不会影响到使用算法的客户。
策略模式是一种定义一系列算法的方法，从概念上来看，所有这些算法完成的都是相同的工作，只是实现不同，它可以以相同的方式调用所有的算法，减少了各种算法类与使用算法类之间的耦合。
当不同的的行为堆砌在一个类中，就很难避免使用条件语句来选择合适的行为，将这些行为封装在一个个独立的Strategy类中，可以在使用这些行为的类中消除条件语句。
--摘自《大话设计模式》
该模式涉及到三个角色：
- 环境（Context）角色：持有一个Strategy的引用
- 抽象策略（Strategy）角色：这是一个抽象角色，通常由一个接口或抽象类实现。此角色给出所有的绝体策略类所需的接口
- 具体策略（Concrete Stategy）角色：包装了相关的算法或行为
public class Context { //持有一个具体策略的对象 private Strategy strategy; /** * 构造函数，传入一个具体策略对象 * @param strategy 具体策略对象 */ public Context(Strategy strategy){ this.strategy = strategy; } /** * 策略方法 */ public void contextInterface(){ strategy.strategyInterface(); } }
public interface Strategy { /** * 策略方法 */ public void strategyInterface(); }
public class ConcreteStrategyA implements Strategy { @Override public void strategyInterface() { //相关的业务 } } public class ConcreteStrategyB implements Strategy { @Override public void strategyInterface() { //相关的业务 } }
使用场景：
假设有三种类别客户，分别为普通客户，会员，超级会员。针对不同类别的会员，有不同的打折方式。
普通客户原价，会员9折，超级会员8折。
不使用策略模式：
package com.example.demo.designpattern; /** * 假设有3种会员，分别为会员，超级会员以及金牌会员和普通顾客，针对不同类别的会员，有不同的打折方式， * 并且一个顾客每消费10000就增加一个级别 * 以上四种会员分别采用原价（普通顾客），九折（会员），八折（超级会员）和七折（金牌会员）的折扣方式。 */ public class Settlement { /** * 总价 */ private double totalPrice = 0; /** * 单次消费的金额 */ private double amount = 0; /** * 购买的方法 * @param amount 商品价格 * @return double 支付的价格 */ public double buy(double amount) throws Exception { this.amount = amount; this.totalPrice += this.amount; if(this.totalPrice < 10000) { return this.amount; } else if(this.totalPrice >= 10000 && this.totalPrice < 20000) { return this.amount * 0.9; } else if(this.totalPrice >= 20000 && this.totalPrice < 30000) { return this.amount * 0.8; } else { return this.amount * 0.7; } } } --------------------- 作者：zhongxuebin_xq 来源：CSDN 原文：https://blog.csdn.net/zhongxuebin_xq/article/details/81275958 版权声明：本文为博主原创文章，转载请附上博文链接！
这种面向过程的实现方式，再以后的维护和新增会员类型的时候，得需要重新添加条件判断，来满足我们的业务需求变化，是一种不灵活的设计方式，下面进行改造。
package strategy; /** * * Title: IDiscountStrategy * Description: 折扣 策略 * @author yacong_liu Email:2682505646@qq.com * @date 2019年1月22日 */ public interface IDiscountStrategy { double discout(double price); }
普通顾客策略
package strategy; public class OrdinaryCustomerStrategy implements IDiscountStrategy { @Override public double discout(double price) { System.out.println("普通顾客不打折......."); return price; } }
会员策略
package strategy; /** * * Title: Member * Description: 会员 9折 * @author yacong_liu Email:2682505646@qq.com * @date 2019年1月22日 */ public class MemberStrategy implements IDiscountStrategy { @Override public double discout(double price) { System.out.println("会员打9折......"); return price * 0.9; } }
超级会员策略
package strategy; /** * * Title: SuperMember Description: 超级会员 8 折 * * @author yacong_liu Email:2682505646@qq.com * @date 2019年1月22日 */ public class SuperMemberStrategy implements IDiscountStrategy { @Override public double discout(double price) { System.out.println("超级会员打8折......"); return price * 0.8; } }
Context 持有抽象策略 调用具体方法
package strategy; /** * * Title: Context Description: 策略类的引用 * * @author yacong_liu Email:2682505646@qq.com * @date 2019年1月22日 */ public class Context { private IDiscountStrategy strategy; public Context(IDiscountStrategy strategy) { super(); this.strategy = strategy; } public double buy(double price) { return this.strategy.discout(price); } }
客户端
@Test public void testBuy() { Context ctx = new Context(new MemberStrategy()); System.out.println("会员最终价格：" + ctx.buy(300)); Context ctx2 = new Context(new OrdinaryCustomerStrategy()); System.out.println("普通顾客最终价格：" + ctx2.buy(300)); Context ctx3 = new Context(new SuperMemberStrategy()); System.out.println("超级会员最终价格：" + ctx3.buy(300)); /* * 此时 需要客户端自己确定选择那种打折策略进行实例化 需要进行解耦。因此需要借助简单工厂，封装一个产生打折策略对象过程的类 */ }
运行结果
会员打9折...... 会员最终价格：270.0 普通顾客不打折....... 普通顾客最终价格：300.0 超级会员打8折...... 超级会员最终价格：240.0
上述的客户端测试类中可以看到，使用的过程中 客户端需要自己知道调用的具体策略，造成了耦合。因此下面进行使用工厂模式进行解耦。
构造策略工厂类，根据购买价格自行判定 构造具体的策略类
package strategy.factory; import strategy.IDiscountStrategy; import strategy.MemberStrategy; import strategy.OrdinaryCustomerStrategy; import strategy.SuperMemberStrategy; /** * * Title: PriceFactory Description: 策略工厂类 * * @author yacong_liu Email:2682505646@qq.com * @date 2019年1月22日 */ public class PriceFactory { public static PriceFactory getInstance() { return new PriceFactory(); } public IDiscountStrategy getStrategy(double price) { if (price < 1000) { return new OrdinaryCustomerStrategy(); } else if (price >= 1000 && price < 2000) { return new MemberStrategy(); } else { return new SuperMemberStrategy(); } } }
此时的Context 改造如下
package strategy.factory; import strategy.IDiscountStrategy; public class Context { @SuppressWarnings("unused") private IDiscountStrategy strategy = null; public double buy(double price) { IDiscountStrategy strategy = PriceFactory.getInstance().getStrategy(price); return strategy.discout(price); } }
客户端
@Test public void testBuyByFactory() { strategy.factory.Context ctx = new strategy.factory.Context(); System.out.println("顾客最终价格：" + ctx.buy(1000)); System.out.println("顾客最终价格：" + ctx.buy(599)); System.out.println("顾客最终价格：" + ctx.buy(2499)); System.out.println(System.getProperty("user.dir")); }
此时可以看到，客户端不再复杂具体的策略调用，完全根据价格交给工厂类判定。
测试结果
会员打9折...... 顾客最终价格：900.0 普通顾客不打折....... 顾客最终价格：599.0 超级会员打8折...... 顾客最终价格：1999.2 G:\WS-Eclipse-Oxygen\Design_Pattern
此时还可以分析出 构造的 策略工厂类中也需要 知道具体有那些策略类，当增加打折策略时，需要修改这个工厂类，也会违反开闭原则，此时可以使用反射进行处理。但是所有的需求变更都是有成本的！ 此处不再介绍如何搭配反射进行改造了。
