[Android] 设计模式-策略模式

最简单的商场收银软件

如果要做一款收银软件，营业员根据客户所购买商品单价和数量向客户收费，这非常容易。

Demo 如下：

点击确定后的代码逻辑如下:

  private void doEnter() {
  String stringTotal = tv_total.getText().toString().trim();
  double total;
  if (stringTotal != null && stringTotal != "") {
    total = Double.valueOf(stringTotal);
  } else {
    total = 0.0d;
  }

  String stringDJ = et_dj.getText().toString().trim();
  String stringSL = et_sl.getText().toString().trim();
  if (stringDJ != null && !stringDJ.equals("") && stringSL != null && !stringSL.equals("")) {
    Log.d("TAG", "123" + stringDJ + "123");
    double price = Double.valueOf(stringDJ);
    int number = Integer.valueOf(stringSL);
    double totalPrice = price * number;
    total = total + totalPrice;
    tv_total.setText(String.valueOf(total));
    String text = tv_detail.getText().toString()
        + "单价： "
        + price
        + " 数量："
        + number
        + " 合计:"
        + totalPrice
        + "\n";
    tv_detail.setText(text);
  }
}

增加打折功能后的收银软件

可是如果商场搞促销，需要打折该怎么办，不可能每次都要修改代码然后重新安装，用下拉框可能会比较方便。
Demo 如下：

添加的代码如下：

     switch (sp_jsfs.getSelectedItemPosition()){
      case 1:
        totalPrice*=0.8;
        break;
      case 2:
        totalPrice*=0.7;
        break;
      case 3:
        totalPrice*=0.5;
        break;
    }

这样看似解决了问题，但是需求不断增加，比如满300返50之类，这样的代码未免显得太过重复。接下来我们试着用简单工厂模式来解决问题试试。

简单工厂实现

面向对象的编程，并不是类越多越好，类的划分是为了封装，但分类的基础是抽象，具有相同属性和功能的对象抽象集合才是类。

打一折和九折只是形式的不同，抽象分析出来，所有打折算法都是一样的，所以打折算法应该是一个类。返现算法也是一个类。

MainActivity 改动如下
CashSuper cSuper= CashFactor.createCashAccept(sp_jsfs.getSelectedItemPosition());
totalPrice=cSuper.acceptCash(totalPrice);
详细代码可以去最后上传的Demo里看
简单工厂模式虽然也能解决问题，但只是解决对象创建的问题，而且由于工厂本身包括了所有的收费方式，商场是可能经常性地更改打折和返利额度，每次维护或扩展收费方式都要改动这个工厂，以至代码要重新编译部署，这是很糟糕的，所以我们需要另一种新的设计模式–策略模式。

策略模式

什么是策略模式

策略模式就是定义一系列算法，把他们独立封装起来，并且这些算法之间可以相互替换。策略模式主要是管理一堆有共性的算法，客户端可以根据需要，很快切换这些算法，并且保持可扩展性。
策略模式的本质：分离算法，选择实现。

如何运用到收银系统中

商场收银如何促销，用打折还是返利，其实都是一些算法，用工厂来生成算法对象，这没有错，但算法本身只是一种策略，最重要的是这些算法是随时都可能互相替换的，这是变化点，而封装变化点是我们面向对象的一种很重要的思维方式。

以下是策略模式 UML 图

接下来我们将策略模式运用到收银系统中
首先创建一个 CashContext 代码如下：

    public class CashContext {
      private CashSuper cs;

      public CashContext(CashSuper cs) {
        this.cs = cs;

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

然后改动 MainActivity 如下：

    CashContext cc = null;
    switch (sp_jsfs.getSelectedItemPosition()) {
      case 0:
        cc = new CashContext(new CashNormal());
        break;
      case 1:
        cc = new CashContext(new CashReturn(300, 100));
        break;
      case 2:
        cc = new CashContext(new CashRebate(0.8));
        break;
      case 3:
        cc = new CashContext(new CashRebate(0.7));
        break;
      case 4:
        cc = new CashContext(new CashRebate(0.5));
        break;
    }
    totalPrice = cc.GetResule(totalPrice);

这时候，你会发现，我们又像原来一样在 MainActivity 中写了判断，可以试着将之前的工厂模式和策略模式结合吗？

策略模式与简单工厂结合

将 CashContext 类的构造方法修改如下：

    public CashContext(int type) {
        switch (type) {
          case 0:
            cs=new CashNormal();
            break;
          case 1:
            cs=new CashReturn(300,100);
            break;
          case 2:
            cs = new CashRebate(0.8);
            break;
          case 3:
            cs = new CashRebate(0.7);
            break;
          case 4:
            cs = new CashRebate(0.5);
            break;
        }
      }

MainActivity 代码修改如下：

    CashContext cc = new CashContext(sp_jsfs.getSelectedItemPosition());
    totalPrice = cc.GetResule(totalPrice);
    total = total + totalPrice;

这样客户端只需要认识一个类 CashContext就可以了，耦合度进一步降低了。
不过这样一旦需求变化依旧需要修改 switch ，其实想要更好的实现可以用反射方法，具体用法下次再做讨论。

Demo

策略模式 Demo

参考文献

《大话设计模式》

安卓设计模式–策略模式