09、策略模式

2019独角兽企业重金招聘Python工程师标准>>>

策略模式与工厂模式最大的区别在于，策略模式注重的是对算法的维护，也可以理解为对算法的封装。而工厂模式，则只是负责创建类，在刚接触策略模式时候，往往与工厂模式容易产生混淆。

官方对策略模式的解释：

它定义了算法家族，分别封装起来，让他们之间可以互换，此模式，让算法的变化不会影响到使用算法的客户。

从此模式开始，每次总结的时候画出一个UML图。

此例子结合商场搞活动销售活动，商品价格打折、以及返价活动。

任何一种活动，最终都要有一个计算结果的方法，所以对此方法进行抽象：

public interface PriceCalculate {
public abstract double getFinalPrice();
}

然后对其进行实现，分别为不搞活动，折扣，返现活动，分别如下：

public class NormalPrice implements PriceCalculate {
private double finalPrice = 0d;
public double getFinalPrice() {
// TODO Auto-generated method stub
return finalPrice;
}
public NormalPrice(double sourcePrice){
this.finalPrice = sourcePrice;
}
}

然后是折扣活动：

public class DebetPrice implements PriceCalculate {
private double finalPrice = 0d;
@Override
public double getFinalPrice() {
return finalPrice;
}
public DebetPrice(double sourcePrice,double debet){
this.finalPrice = Calculate.mul(sourcePrice, debet);
}
}

Calculate为工具类，具体代码在最后。

然后是折现活动：

public class ReturnPrice implements PriceCalculate {
private double finalPrice = 0d;
@Override
public double getFinalPrice() {
// TODO Auto-generated method stub
return finalPrice;
}
/**满多少价反钱活动
* @param sourcePrice 原价
* @param conditionPrice 返现金消费额度
* @param returnPrice 返现金力度
*/
public ReturnPrice(double sourcePrice,double conditionPrice,double returnPrice){
this.finalPrice = sourcePrice;
if( sourcePrice >= conditionPrice ){
double times = Math.floor(Calculate.div(sourcePrice, conditionPrice)) ;
int count = times>=1? (int)times:0;
while(count-->0){
this.finalPrice = Calculate.sub(sourcePrice,returnPrice);
}
}
}
}

其中的Calculate为工具类，具体如下：

package com.yp.learn.util;
import java.math.BigDecimal;
public class Calculate {
// 默认除法运算精度
private static final int DEF_DIV_SCALE = 10;
private Calculate(){};
/**精确加法运算
* @param d1 被加数
* @param d2 加数
* @return 和
*/
public static double add(double d1,double d2){
BigDecimal b1= new BigDecimal(Double.toString(d1));
BigDecimal b2= new BigDecimal(Double.toString(d2));
return b1.add(b2).doubleValue();
}
/**
* 提供精确的减法运算。
* @param v1 被减数
* @param v2 减数
* @return 两个参数的差
*/
public static double sub(double v1, double v2) {
BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2));
return b1.subtract(b2).doubleValue();
}
/**
* 提供精确的乘法运算。
* @param v1 被乘数
* @param v2 乘数
* @return 两个参数的积
*/
public static double mul(double v1, double v2) {
BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2));
return b1.multiply(b2).doubleValue();
}
/**
* 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到小数点以后10位，以后的数字四舍五入。
* @param v1 被除数
* @param v2 除数
* @return 两个参数的商
*/
public static double div(double v1, double v2) {
return div(v1, v2, DEF_DIV_SCALE);
}
/**
* 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指定精度，以后的数字四舍五入。
* @param v1 被除数
* @param v2 除数
* @param scale 表示表示需要精确到小数点以后几位。
* @return 两个参数的商
*/
public static double div(double v1, double v2, int scale) {
if (scale < 0) {
throw new IllegalArgumentException(
"The scale must be a positive integer or zero");
}
BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2));
return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
}
}

然后策略模式的核心出来了，几种类都已经实现类，并且都有算法，策略模式要做的，就是对这个抽象出来的算法进行维护，如下：

public class PriceCalculateContext {
PriceCalculate cal = null;
/**无活动情况
* @param sourcePrice
*/
public PriceCalculateContext(double sourcePrice){
cal = new NormalPrice(sourcePrice);
}
/**打折活动
* @param sourcePrice 原价
* @param debet 打折力度
*/
public PriceCalculateContext(double sourcePrice,double debet){
cal = new DebetPrice(sourcePrice,debet);
}
/**返现活动
* @param sourcePrice 原价
* @param conditionPrice 返现所需满足额度
* @param returnPrice 返现力度
*/
public PriceCalculateContext(double sourcePrice,double conditionPrice,double returnPrice){
cal = new ReturnPrice(sourcePrice,conditionPrice,returnPrice);
}
public double getResult() {
return cal.getFinalPrice();
}
}

与之前的工厂模式相比较，策略模式并没有提供创建运算类的工厂类，而只是将这些运算类维护在了PriceCalculateContext类中，并且此类中提供了方法getResult（），此方法所调用的刚好是算法接口。那么现在，客户端的代码就非常的清晰了：

public class Start {
public static void main(String[] args) {
PriceCalculateContext p = new PriceCalculateContext(100d);
System.out.println(p.getResult());
p = new PriceCalculateContext(122.2d, 100d, 15d);
System.out.println(p.getResult());
}
}

通过构造价格计算维护类来计算所得的最终结果，计算的具体形式完全对客户端屏蔽。策略模式最明显的就是对每种策略所实现的算法进行了封装，在本例中，就是 PriceCalculateContext的getResult的方法，在后续，可以说如果需要新增新的算法，那么我只需要新增新的算法类，然后在PriceCalculateContext增加相应的映射即可。在客户端只需要依据不同的参数进行初始化，然后调用的方法不用发生任何改变。

UML图如下：