设计模式之策略模式

策略模式学习笔记。学得有点慢哈，但还是日有所进，我相信长时间坚持学习下去总会有进步。题目：做一个商场收银软件，营业员根据客户所购买的单价和数量，向客户收费。我在这里就不写客户端了，直接在控制台模拟输入。

来个最直接的：

public class GoodsCalculator {
     double total = 0;
     public static void main(String[] args) {
         GoodsCalculator gc = new GoodsCalculator();
 //        Scanner scanner = new Scanner(System.in);
         while(true){
             Scanner scanner = new Scanner(System.in);
             System.out.println("请输入商品单价： ");
             String str = scanner.nextLine();        
             //输入'/'结束循环
             if("/".equals(str)){
                 break;
             }
             double price = Double.valueOf(str);
             System.out.println("请输入商品数量：");
             int number = Integer.valueOf(scanner.nextLine());
             System.out.println("请输入折扣：");
             double discount = Double.valueOf(scanner.nextLine());
             double totalPrice = gc.calculate(price,number,discount);
             System.out.println("此商品总价：" + totalPrice);
             gc.total = gc.total + totalPrice;
             System.out.println("总花费：" + gc.total);
         }
     }
     public double calculate(double price, int number,double discount){
         return  (price * number * discount);
     }
 }

从控制台输入商品单价、数量和折扣，再显示出此商品总价和总花费。这里收回上次的吐槽，原来可以插入代码，如此优美，刚入园，多多体谅。上面代码实现了简单的收银功能，但如果商场不想通过打折的方式促销，而改为满300减100或者其他方式，那怎么办呢?下面就用简单工厂模式实现以下。

public interface ICash {
    public double calculatePrice(Double price);
}

public class CashDiscount implements ICash {

    private double discount = 1;
    public CashDiscount(double discount){
        this.discount = discount;
    }
    public double calculatePrice(Double price) {
        // TODO Auto-generated method stub
        return price * discount;
    }
}

public class CashNormal implements ICash {
    
    @Override
    public double calculatePrice(Double price) {
        // TODO Auto-generated method stub
        return price;
    }

}

public class CashReturn implements ICash {
    private double reach;
    private double reduce;
    public CashReturn(double reach, double reduce){
        this.reach = reach;
        this.reduce = reduce;
    }
    @Override
    public double calculatePrice(Double price) {
        // TODO Auto-generated method stub
        return price - ((int)(price/reach) * reduce);
    }

}

public class CashFactory {
    public static ICash createCashAccept(String type){
        ICash cash = null;
        if("打八折".equals(type)){
            cash = new CashDiscount(0.8);
        }else if("满300减100".equals(type)){
            cash = new CashReturn(300,100);
        }else if("正常收费".equals(type)){
            cash = new CashNormal();
        }else if("满500减200".equals(type)){
            cash = new CashReturn(500,200);
        }
        return cash;
    }
}

public class GoodsCalculator2 {
    double total = 0;
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        GoodsCalculator2 gc = new GoodsCalculator2();
        while(true){
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入商品单价： ");
            String str = scanner.nextLine();        
            if("/".equals(str)){
                break;
            }
            double price = Double.valueOf(str);
            System.out.println("请输入商品数量：");
            int number = Integer.valueOf(scanner.nextLine());
            System.out.println("请输入折扣：");
            String type = scanner.nextLine();
            ICash cash = CashFactory.createCashAccept(type);
            double totalPriceTemp = price * number;
            double totalPrice = cash.calculatePrice(totalPriceTemp);
            System.out.println("此商品总价：" + totalPrice);
            gc.total = gc.total + totalPrice;
            System.out.println("总花费：" + gc.total);
        }
    }

}

这里打折基本都是一样的，只要有个初始化的参数就行。满几送几的需要两个参数才行。除了打折和满几送几方式，现在如果需要增加新的促销方式，则需要新增ICash子类，同时修改下工厂类。这样就不算太麻烦了。“面向对象的编程，并不是类越多越好，类的划分是为了封装，但分类的基础是抽象，具有相同属性和功能的对象的抽象集合才是类”。打一折和打九折只是形式不同，抽象分析出来，所有的打折方法都是一样的，所以打折算法应该是一个类。

显然简单工厂模式是能解决这个问题的。但还能不能有更好的写法呢?

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

由图可以分析出策略模式和简单工厂模式其实挺像的。主要是Context类的不同。

public class CashContext {
    ICash cash = null;
    public CashContext(String type){
        if("打八折".equals(type)){
            cash = new CashDiscount(0.8);
        }else if("满300减100".equals(type)){
            cash = new CashReturn(300,100);
        }else if("正常收费".equals(type)){
            cash = new CashNormal();
        }else if("满500减200".equals(type)){
            cash = new CashReturn(500,200);
        }
    }
    public double getTotalPrice(double priceTemp){
        return cash.calculatePrice(priceTemp);
    }
}

可以看出，他们不同之处在于简单工厂模式需要让客户端认识两个类，ICash和CashFactory。而策略模式只要认识一个CashContext就可以了。耦合更加降低。

策略模式总结：

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

优点：

策略模式的strategy类层次为context定义了一系列的可供重用的算法和行为。继承有助于析取出这些算法的公共功能。对于打折、返利或其他的算法，其实都是对实际商品收费的一种计算方式，通过继承，可以得到他们的公共功能。另一个优点就是简化了单元测试，因为每个算法都有自己的类，可以通过自己的接口单独测试，修改其中一个不会影响其他的算法。策略模式封装了变化。策略模式是用来封装算法的，但在实践中，我们发现可以用它来封装几乎任何类型的规则，只要在分析过程中听到需要在不同时间应用不同的业务规则，就可以考虑使用策略模式处理这种变化的可能性。