策略模式

什么是策略模式？

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

也就是说策略模式是一种定义一系列算法的方法，从概念上看，所有这些算法都是完成相同的工作，只是实现不同而已，它可以以相同的方式来调用所有的算法，减少各类算法类与使用算法类的耦合。

其实白话一点来说，就是将算法归类，比如说以商场促销这种例子来说，当一个商场搞促销时，可能有几种方案，方案一：满多少送多少，方案二：买东西打几折，方案三：无优惠，原价购买等等，那么这三种方案就涉及到三种算法策略，最终其实都是将客户需要付费多少钱计算出来而已。

策略模式实现

可能光是看概念不是很懂，这里我来做一个策略模式的demo，实现代码如下：

首先我们先来建立一个消费类的接口类，其中包含一个收费的静态方法：

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

然后建立方案一，满300减100的实现类：

public class CashReturn implements CashSuper {

  private double moneyCondition = 0;
  private double moneyReturn = 0;

  public CashReturn(String moneyCondition, String moneyReturn) {
    this.moneyCondition = Double.parseDouble(moneyCondition);
    this.moneyReturn = Double.parseDouble(moneyReturn);
  }

  @Override
  public double acceptCash(double money) {
    double result = 0;

    if (money > moneyCondition) {
      result = money - Math.floor(money / moneyCondition) * moneyReturn;
    }

    return result;
  }

}

建立方案二购物打8折的实现类：

public class CashRebate implements CashSuper {
  private double rebate = 1;

  public CashRebate(double rebate) {
    this.rebate = rebate;
  }

  @Override
  public double acceptCash(double money) {
    money = money * rebate;
    return money;
  }

}

建立方案三购物无优惠的实现类：

public class CashNormal implements CashSuper {

  @Override
  public double acceptCash(double money) {

    return money;
  }

}

这里最重要的是有个收费的上下文关系类：

public class CashContext {
  private CashSuper cs = null;

  public CashContext(CashSuper csuper) {
    this.cs = csuper;
  }
  
  public double getRequest(double money) {
    return cs.acceptCash(money);
  }
}

最后当客户端需要调用的时候就很方便了：

public class Client {

  public static void main(String args[]) {
    CashContext cs = null;
    int operation = 1;
    double result = 0;

    switch (operation) {
      case 1:
        cs = new CashContext(new CashReturn("300", "100"));
        break;
      case 2:
        cs = new CashContext(new CashRebate(0.8));
        break;
      case 3:
        cs = new CashContext(new CashNormal());
    }
    result = cs.getRequest(350);
    System.out.println("购物350元，最终应付费：" + result);
  }
}

结果如下：

这里我来大概说明一下，这个策略模式的示例代码大概是什么思路：
1、我们首先建立了一个收费的接口类，然后在接口类中，定义了一个收费的静态方法（这里使用接口的目的是，无论需要多少算法策略模型，只需要实现这个接口类，然后重写收费的静态方法就行了，减少了代码间耦合性）。

2、我们先后定义了满300送100，打8折与无优惠的三种策略类，然后实现了收费接口，并重写了收费的方法。

3、我们定义了一个收费的上下文关系类，无论你传进来的是那种收费策略，最终返回的都是该策略的收费结果（这里通过收费上下文关系类管理收费策略的返回值，你传入相应的收费策略，然后上下文关系类调用该策略的收费方法，结算完成后返回对应的结果）。

4、我们在客户端选择调用满300送100的策略，最终获得需要付费的结果。

其实策略模式还是很简单的对吧，整体思路还是比较清晰，最重要的无非就是上下文关系类来管理，然后看客户端需要调用什么策略而已，但是这里有个很不好的地方，客户端需要接触的类太多了，又要接触各种策略类，又要接触上下文关系类，假如需要再添加什么策略或者修改什么策略，那么客户端又要跟着修改，这样客户端和各种策略类的耦合性太严重了。

那么我们有没有什么好的方法来解决这个问题呢？必须有啊。还记得我们的简单工厂模式吗？我们可以用策略与简单工厂的结合来解决这个问题。

策略与简单工厂结合

这里我们修改一下收费上下文关系类：

public class CashContext {
  private CashSuper cs = null;

  public CashContext(int operation) {
    switch (operation) {
      case 1:
        cs = new CashNormal();
        break;
      case 2:
        cs = new CashRebate(0.8);
        break;
      case 3:
        cs = new CashReturn("300", "100");
    }
  }

  public double getResult(double money) {
    return cs.acceptCash(money);
  }
}

再来看下我们的客户端类：

public class Client {

  public static void main(String args[]) {
    int operation = 2;
    double money = 500;
    CashContext context = new CashContext(operation);
    money = context.getResult(money);

    System.out.println("购物300元，最终应付费：" + money);
  }
}

最终结果如下：

这样一看是不是就觉得客户端清爽多了呢，客户端只需要了解收费上下文类就行了，其余的策略相关问题都交给收费上下文类解决，这样就把客户端和各种策略隔离开，耦合性基本降到最低。

总结

最后我们再来回顾下，通过上面的demo，我们可以发现策略模式就是用来封装各种算法的，同时还具有以下几个优点：
1、减少了算法类与使用算法类之间的耦合

2、简化了单元测试，每个算法都有自己的类，可以通过自己的单独接口测试。

而且我们在实践过程中，我们可以发现可以用它来封装集合任何类型的规则，只要在分析过程中听到需要在不同的时间应用不同的业务规则，就可以考虑使用策略模式进行处理