大话设计模式--第二章策略设计模式

策略设计模式

现在有一个需求: 给商场做一个收银软件. 营业员根据客户购买的产品的单价和数量, 向客户打印小票。

这个实现很简单. 一个类就可以搞定:

package com.designModel.chaper2_strategeModel.step1;

import java.util.Scanner;

/**
 * cash收银
 * @author samsung
 *
 */
public class Cash {
    public String list = "";
    public Double totalPrice = 0.00;
    
    public void buttonOK(){
        
        Scanner scan = new Scanner(System.in);
        System.out.println("输入单价：");
        String price = scan.nextLine();
        
        scan = new Scanner(System.in);
        System.out.println("输入数量：");
        String num = scan.nextLine();
        
        scan = new Scanner(System.in);
        System.out.println("输入折扣：");
        String zhekou = scan.nextLine();
        
        Double xiaoji = Double.parseDouble(price) * Integer.parseInt(num) * Double.parseDouble(zhekou)/10;
        list += "单价:" + price +", 数量: "+ num +",折扣: " + zhekou + "n";
        totalPrice += xiaoji;
        
        
    }
    
    public static void main(String[] args) {
        Cash cash = new Cash();
        boolean flag = true;
        while(flag) {
            cash.buttonOK();
            if(cash.totalPrice > 10){
                flag = false;
            }
        }
        
        System.out.println("========================");
        System.out.println("清单:n " + cash.list);
        System.out.println("总价: "+ cash.totalPrice);
    }
    
}

但是: 用面向对象的角度思考. 这个类将前端输入和业务逻辑混合在一块了. 不利于维护, 扩展, 复用, 也不灵活.

假如: 现在商场搞活动, 所有商品打折, 7折,

过一段时间, 商场又搞活动, 所有商品打5折

国庆节, 商品满200减50.

如果按照上面的方式来写代码, 那么每次都要写一遍, 如何将其复用起来呢? 并且每次增加新的活动的时候, 又不会影响到原来的活动.

对了, 简单工厂设计模式, 我们之前刚刚学过的. 下面看看简单工厂设计模式的UML图:

首先, 有一个工厂类, 在这个工厂类里面, 根据类型, 依赖于不同的现金收费方式. 具体代码如下:

首先与一个抽象的现金收费方式类:

package com.designModel.chaper2_strategeModel.step2;

/**
 * 现金收费类
 * @author samsung
 *
 */
public abstract class CashFee {
    
    public abstract double acceptCash(double money); 
}

定义现金收费方式的实现类,分别是: 正常收费类, 折扣类, 返现类

package com.designModel.chaper2_strategeModel.step2;

//正常收费类
public class NormalCashFee extends CashFee {

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

package com.designModel.chaper2_strategeModel.step2;

public class DiscountCashFee extends CashFee {

    private double discount = 0.00;
    
    public DiscountCashFee(double discount){
        this.discount = discount / 10;
    }
    
    @Override
    public double acceptCash(double money) {
        
        return this.discount * money;
    }

    public double getDiscount() {
        return discount;
    }

    public void setDiscount(double discount) {
        this.discount = discount;
    }

}

package com.designModel.chaper2_strategeModel.step2;

public class ReturnCashFee extends CashFee {

    //基础金额
    private double baseCash;
    
    //返现金额
    private double returnCash;
    
    public ReturnCashFee(double baseCash, double returnCash){
        this.baseCash = baseCash;
        this.returnCash = returnCash;
    }
    
    @Override
    public double acceptCash(double money) {
        return money - Math.floor(money/300) * 50;
    }
    

    public double getBaseCash() {
        return baseCash;
    }

    public void setBaseCash(double baseCash) {
        this.baseCash = baseCash;
    }

    public double getReturnCash() {
        return returnCash;
    }

    public void setReturnCash(double returnCash) {
        this.returnCash = returnCash;
    }
    
}

在定义一个工厂类, 用来产生各种现金收费方式

package com.designModel.chaper2_strategeModel.step2;

import java.util.Scanner;


public class CashFeeFactory {
    public static CashFee createCashFee(int type, double discount, double basePrice, double returnPrice){
        CashFee cashFee = null;
        switch(type){
            case 1:
                cashFee = new NormalCashFee();
                break;
            case 2:
                cashFee = new DiscountCashFee(discount);
                break;
            case 3:
                cashFee = new ReturnCashFee(basePrice, returnPrice);
                break;
        }
        
        return cashFee;
    }
    
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("输入单价：");
        String price = scan.nextLine();
        
        scan = new Scanner(System.in);
        System.out.println("输入数量：");
        String num = scan.nextLine();
        
        scan = new Scanner(System.in);
        System.out.println("输入折扣类型(1 无折扣 2打折 3满减)：");
        String zhekou = scan.nextLine();
        
        double discount = 0.0d;
        double basePrice = 0;
        double returnPrice = 0;
        if("2".equals(zhekou)){
            scan = new Scanner(System.in);
            System.out.println("输入折扣：");
            discount = Double.parseDouble(scan.nextLine());
        }
        
        if("3".equals(zhekou)){
            scan = new Scanner(System.in);
            System.out.println("基础金额：");
            basePrice = Double.parseDouble(scan.nextLine());
            scan = new Scanner(System.in);
            System.out.println("返现金额：");
            returnPrice = Double.parseDouble(scan.nextLine());
        }
        Double xiaoji = Double.parseDouble(price) * Integer.parseInt(num) * Double.parseDouble(zhekou)/10;
        CashFee cashFee = CashFeeFactory.createCashFee(1, discount, basePrice, returnPrice);
    }
}

完成了, 在main方法里, 我们模拟了客户端, 输入单价和数量,打印小票

-------------------------------------------------------------------------------------------------

思考:

使用简单工厂设计模式的优缺点:

优点:

　　1. 业务逻辑和前端展示相分离开了。业务逻辑的修改，不影响前端代码

　　2. 每一个业务逻辑单独一个类, 修改或者添加一个类, 不会影响到其他的类.

　　3. 使用工厂类封装了业务逻辑类. 前端不需要知道到底每种业务逻辑具体怎么实现的. 只需要知道他的父类即可.

缺点:

　　1. 如果活动很频繁, 经常会搞各种各样的活动, 那么业务逻辑类就会有很多, 每一次都要增加一个类.

　　2. 每增加一个类都要修改工厂类. 修改会非常频繁

小结: 简单工厂设计模式虽然也能解决这个问题, 但这个模式只是解决对类的创建问题.

--------------------------------------------------------------------------

下面介绍策略设计模式:

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

　　封装变化点, 是面向对象的一种很重要的思维方式.

下面以商场促销打印收银小票为例, 来分析策略设计模式

　　1. 在策略设计模式中, 有各种算法: 所有的算法有一个算法父类: CashFee. 这个父类是一个抽象类. 里面有一个抽象方法acceptCash(double money)

　　2. 所有的算法类实现抽象算法父类, 并实现抽象方法

　　3. 重点: 有一个上下文对象. 这个对象封装了对算法类的调用

下面看代码:

1. 现金类算法, 以及现金的各种实现类算法

package com.designModel.chaper2_strategeModel.step3;

/**
 * 现金收费类
 * @author samsung
 *
 */
public abstract class CashFee {
    
    public abstract double acceptCash(double money); 
}

package com.designModel.chaper2_strategeModel.step3;

//正常收费类
public class NormalCashFee extends CashFee {

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

package com.designModel.chaper2_strategeModel.step3;

public class DiscountCashFee extends CashFee {

    private double discount = 0.00;
    
    public DiscountCashFee(double discount){
        this.discount = discount / 10;
    }
    
    @Override
    public double acceptCash(double money) {
        
        return this.discount * money;
    }

    public double getDiscount() {
        return discount;
    }

    public void setDiscount(double discount) {
        this.discount = discount;
    }

}

package com.designModel.chaper2_strategeModel.step3;

public class ReturnCashFee extends CashFee {

    //基础金额
    private double baseCash;
    
    //返现金额
    private double returnCash;
    
    public ReturnCashFee(double baseCash, double returnCash){
        this.baseCash = baseCash;
        this.returnCash = returnCash;
    }
    
    @Override
    public double acceptCash(double money) {
        return money - Math.floor(money/300) * 50;
    }
    

    public double getBaseCash() {
        return baseCash;
    }

    public void setBaseCash(double baseCash) {
        this.baseCash = baseCash;
    }

    public double getReturnCash() {
        return returnCash;
    }

    public void setReturnCash(double returnCash) {
        this.returnCash = returnCash;
    }
    
}

最后. 来看看上下文类

package com.designModel.chaper2_strategeModel.step3;

import java.util.Scanner;


public class CashContext {
    private CashFee cashFee;
    public CashContext(CashFee cashFee)
    {
        this.cashFee = cashFee;
    }
    public static double getResult(double money){return cashFee.acceptCash(money);
    }
    
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("输入单价：");
        String price = scan.nextLine();
        
        scan = new Scanner(System.in);
        System.out.println("输入数量：");
        String num = scan.nextLine();
        
        scan = new Scanner(System.in);
        System.out.println("输入折扣类型(1 无折扣 2打折 3满减)：");
        String type = scan.nextLine();
        
        double discount = 0.0d;
        double basePrice = 0;
        double returnPrice = 0;
        
        if("2".equals(type)){
            scan = new Scanner(System.in);
            System.out.println("输入折扣：");
            discount = Double.parseDouble(scan.nextLine());
        }
        
        if("3".equals(type)){
            scan = new Scanner(System.in);
            System.out.println("基础金额：");
            basePrice = Double.parseDouble(scan.nextLine());
            scan = new Scanner(System.in);
            System.out.println("返现金额：");
            returnPrice = Double.parseDouble(scan.nextLine());
        }
        
        
        Double xianjin = Double.parseDouble(price) * Integer.parseInt(num);
        CashContext cc = null;
        switch(type){
            case "1":
                cc = new CashContext(new NormalCashFee());
                break;
            case "2":
                cc = new CashContext(new DiscountCashFee(discount));
                break;
            case "3":
                cc = new CashContext(new ReturnCashFee(basePrice, returnPrice));
                break;
        }
        
        cc.getResult(xianjin);
    }
}

分析:

1. 业务逻辑和前端页面展示分开

2. 有一个context上下文类, 在其内部引用了CashFee类. 构造方法定义了具体的实现类.

3. 这样操作的问题: 客户端依然需要switch判断.

----------------------------------------------

策略设计模式和简单工厂设计模式相结合的方案:

其他都不变: 变化的是CashContext类

package com.designModel.chaper2_strategeModel.step4;

import java.util.Scanner;


public class CashContext {
    private CashFee cashFee;
    public CashContext(int type, double discount, double basePrice, double returnPrice)
    {
        switch(type){
            case 1:
                cashFee = new NormalCashFee();
                break;
            case 2:
                cashFee = new DiscountCashFee(discount);
                break;
            case 3:
                cashFee = new ReturnCashFee(basePrice, returnPrice);
                break;
    　　}
    }
    public static double getResult(double money){
        CashFee cashFee = null;
        return cashFee.acceptCash(money);
    }
    
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("输入单价：");
        String price = scan.nextLine();
        
        scan = new Scanner(System.in);
        System.out.println("输入数量：");
        String num = scan.nextLine();
        
        scan = new Scanner(System.in);
        System.out.println("输入折扣类型(1 无折扣 2打折 3满减)：");
        String zhekou = scan.nextLine();
        
        double discount = 0.0d;
        double basePrice = 0;
        double returnPrice = 0;
        
        if("2".equals(zhekou)){
            scan = new Scanner(System.in);
            System.out.println("输入折扣：");
            discount = Double.parseDouble(scan.nextLine());
        }
        
        if("3".equals(zhekou)){
            scan = new Scanner(System.in);
            System.out.println("基础金额：");
            basePrice = Double.parseDouble(scan.nextLine());
            scan = new Scanner(System.in);
            System.out.println("返现金额：");
            returnPrice = Double.parseDouble(scan.nextLine());
        }
        
        
        Double xianjin = Double.parseDouble(price) * Integer.parseInt(num);
        CashContext cc = new CashContext(1, discount, basePrice, returnPrice);
        cc.getResult(xianjin);
    }
}

我们将前端的switch转移到了CashContext的内部. 这样,前端只需要传递给我, 类型信息就可以了.

下面来看看: 简单工厂设计模式和策略模式+简单工厂设计模式的区别:

对于客户端而言: 简单工厂设计模式, 客户端需要知道两个类, 而简单工厂+策略设计模式, 客户端只需要知道一个类, 减低了耦合性.

---------------------------------------------------------------------------------------

使用策略模式的优点:

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

2. 策略模式的另一个优点: 简化了单元测试, 因为每个算法都有自己的类, 可以通过自己的接口单独测试.

3. 每个算法都是独立的, 修改其中一个, 不会影响其他的算法.

4. 在策略模式中, 选择所用具体实现的职责有客户端对象承担，并转给策略模式的Context对象。这本身并没有解除客户端需要选择判断的压力。而策略模式和简单工厂设计模式结合后，选择具体实现的职责也交给了Context来承担，最大化的减轻了客户端的职责。这比期初的策略模式好用，但是依然不够完美。因为他在context里还是用到了switch，这样人很不爽。如何才能不用switch呢？反射。

---------------------------------------------------------------------------------------

思考,

书上说: 为什么要用策略设计模式呢?

因为商场打折的算法很多, 每次增加一个促销活动, 可能就会有一个新的算法. 这时候, 如果用简单工厂设计模式, 需要增加一个算法类, 同时修改工厂类. 这是, 最好使用策略设计模式.

疑问: 使用策略设计模式. 每次增加一个算法, 也要增加一个算法类, 而且要修改CashContext类. 并没有得到简化呀

应该是我修行不够, 还没能够理解, 忘懂得大神指点.

-------------------------------------------------------------------

后续---使用反射加载类, 这里的修改主要是对Context中构造方法的修改.

package com.designModel.chaper2_strategeModel.step5;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;


public class CashContext {
    private CashFee cashFee = null;
    static Map<String, String> map = new HashMap<String, String>();
    static{
        map.put("1", "com.designModel.chaper2_strategeModel.step5.NormalCashFee");
        map.put("2", "com.designModel.chaper2_strategeModel.step5.DiscountCashFee");
        map.put("3", "com.designModel.chaper2_strategeModel.step5.ReturnCashFee");
    }
    
    public CashContext(String type, double discount, double basePrice, double returnPrice) throws ClassNotFoundException, NoSuchMethodException, SecurityException
    {
        /**
         * 使用反射加载策略算法
         */
        try {
            String className = map.get(type);
            System.out.println(className);
            Class cla = Class.forName(className);
            //Class cla = Class.forName("com.designModel.chaper2_strategeModel.step5.NormalCashFee");
            Constructor cons = cla.getConstructor(double.class,double.class,double.class);
            cashFee = (CashFee) cons.newInstance(discount, basePrice, returnPrice);
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        /*switch(type){
            case 1:
                cashFee = new NormalCashFee();
                break;
            case 2:
                cashFee = new DiscountCashFee(discount);
                break;
            case 3:
                cashFee = new ReturnCashFee(basePrice, returnPrice);
                break;
        }*/
    }
    public double getResult(double money){
        return cashFee.acceptCash(money);
    }
    
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("输入单价：");
        String price = scan.nextLine();
        
        scan = new Scanner(System.in);
        System.out.println("输入数量：");
        String num = scan.nextLine();
        
        scan = new Scanner(System.in);
        System.out.println("输入折扣类型(1:无折扣  2:打折  3:满减)：");
        String zhekou = scan.nextLine();
        
        double discount = 0.0d;
        double basePrice = 0;
        double returnPrice = 0;
        
        if("2".equals(zhekou)){
            scan = new Scanner(System.in);
            System.out.println("输入折扣：");
            discount = Double.parseDouble(scan.nextLine());
        }
        
        if("3".equals(zhekou)){
            scan = new Scanner(System.in);
            System.out.println("基础金额：");
            basePrice = Double.parseDouble(scan.nextLine());
            scan = new Scanner(System.in);
            System.out.println("返现金额：");
            returnPrice = Double.parseDouble(scan.nextLine());
        }
        
        
        Double xianjin = Double.parseDouble(price) * Integer.parseInt(num);
        CashContext cc;
        try {
            cc = new CashContext(zhekou, discount, basePrice, returnPrice);
            double result = cc.getResult(xianjin);
            System.out.println("result:"+result);
        } catch (Exception e) {
            e.printStackTrace();
        } 
    }
}

这样做的好处很明显, 不用每次增加一个类, 添加一个switch分支啦. 并且消除了switch分支.

今天有回顾了一下策略模式, 似乎有了一点点更加深入的理解.

-----------------------------------------------------------------------

下面来一个最终版的全部代码:

package com.designModel.chaper2_strategeModel.step5;

/**
 * 现金收费类
 * @author samsung
 *
 */
public abstract class CashFee {
    
    private double discount;
    private double basePrice;
    private double returnPrice;
    
    public CashFee(){}
    
    public CashFee(double discount, double basePrice, double returnPrice){
        this.discount = discount;
        this.basePrice = basePrice;
        this.returnPrice = returnPrice;
    }
    
    public abstract double acceptCash(double money);


    public double getDiscount() {
        return discount;
    }


    public void setDiscount(double discount) {
        this.discount = discount;
    }


    public double getBasePrice() {
        return basePrice;
    }


    public void setBasePrice(double basePrice) {
        this.basePrice = basePrice;
    }


    public double getReturnPrice() {
        return returnPrice;
    }


    public void setReturnPrice(double returnPrice) {
        this.returnPrice = returnPrice;
    }
}

package com.designModel.chaper2_strategeModel.step5;

//正常收费类
public class NormalCashFee extends CashFee {

    public NormalCashFee(double discount, double basePrice, double returnPrice){
        
    };
    
    public NormalCashFee(){}
    
    @Override
    public double acceptCash(double money) {
        return money;
    }
}

package com.designModel.chaper2_strategeModel.step5;

public class ReturnCashFee extends CashFee {

    /**
     * @param baseCash 基础金额
     * @param returnCash 返现金额
     */
    
    public ReturnCashFee(double discount, double basePrice, double returnPrice){
        super(0, basePrice, returnPrice);
    }
    
    @Override
    public double acceptCash(double money) {
        return money - Math.floor(money/super.getBasePrice()) * super.getReturnPrice();
    }
    
}

package com.designModel.chaper2_strategeModel.step5;

public class DiscountCashFee extends CashFee {

    
    public DiscountCashFee(){}
    
    public DiscountCashFee(double discount, double basePrice, double returnPrice){
        super(discount/10, 0, 0);
    }
    
    @Override
    public double acceptCash(double money) {
        return super.getDiscount() * money;
    }

}

package com.designModel.chaper2_strategeModel.step5;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;


public class CashContext {
    private CashFee cashFee = null;
    static Map<String, String> map = new HashMap<String, String>();
    static{
        map.put("1", "com.designModel.chaper2_strategeModel.step5.NormalCashFee");
        map.put("2", "com.designModel.chaper2_strategeModel.step5.DiscountCashFee");
        map.put("3", "com.designModel.chaper2_strategeModel.step5.ReturnCashFee");
    }
    
    public CashContext(String type, double discount, double basePrice, double returnPrice) throws ClassNotFoundException, NoSuchMethodException, SecurityException
    {
        /**
         * 使用反射加载策略算法
         */
        try {
            String className = map.get(type);
            System.out.println(className);
            Class cla = Class.forName(className);
            //Class cla = Class.forName("com.designModel.chaper2_strategeModel.step5.NormalCashFee");
            Constructor cons = cla.getConstructor(double.class,double.class,double.class);
            cashFee = (CashFee) cons.newInstance(discount, basePrice, returnPrice);
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        /*switch(type){
            case 1:
                cashFee = new NormalCashFee();
                break;
            case 2:
                cashFee = new DiscountCashFee(discount);
                break;
            case 3:
                cashFee = new ReturnCashFee(basePrice, returnPrice);
                break;
        }*/
    }
    public double getResult(double money){
        return cashFee.acceptCash(money);
    }
    
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("输入单价：");
        String price = scan.nextLine();
        
        scan = new Scanner(System.in);
        System.out.println("输入数量：");
        String num = scan.nextLine();
        
        scan = new Scanner(System.in);
        System.out.println("输入折扣类型(1:无折扣  2:打折  3:满减)：");
        String zhekou = scan.nextLine();
        
        double discount = 0.0d;
        double basePrice = 0;
        double returnPrice = 0;
        
        if("2".equals(zhekou)){
            scan = new Scanner(System.in);
            System.out.println("输入折扣：");
            discount = Double.parseDouble(scan.nextLine());
        }
        
        if("3".equals(zhekou)){
            scan = new Scanner(System.in);
            System.out.println("基础金额：");
            basePrice = Double.parseDouble(scan.nextLine());
            scan = new Scanner(System.in);
            System.out.println("返现金额：");
            returnPrice = Double.parseDouble(scan.nextLine());
        }
        
        
        Double xianjin = Double.parseDouble(price) * Integer.parseInt(num);
        CashContext cc;
        try {
            cc = new CashContext(zhekou, discount, basePrice, returnPrice);
            double result = cc.getResult(xianjin);
            System.out.println("result:"+result);
        } catch (Exception e) {
            e.printStackTrace();
        } 
    }
}

亲测代码可用, 一下是运行结果: 分为三种

第一种: 正常收费

第二种: 打折, 打5折

第三种: 满减, 满300减50

------------------------------------------------------

问题:

使用反射, 依然会有问题, 从代码就可以看出. 为了能够使用反射调用通用的构造函数, 所以在CashFee中定义了一个带有三个参数的构造方法

public CashFee(double discount, double basePrice, double returnPrice){
        this.discount = discount;
        this.basePrice = basePrice;
        this.returnPrice = returnPrice;
    }

然后在3个子类中, 调用这个构造方法

public NormalCashFee(double discount, double basePrice, double returnPrice){
        
};

public DiscountCashFee(double discount, double basePrice, double returnPrice){
    super(discount/10, 0, 0);
}

public ReturnCashFee(double discount, double basePrice, double returnPrice){
    super(0, basePrice, returnPrice);
}

可以明显看出, NormalCashFee类中的这个带三个参数的构造方法, 其内部根本没有任何操作.

而DiscountCashFee只想传递第一个参数.

而ReturnCashFee只想传递第二个和第三个参数.

可是为了能够使用反射. 他们必须传递本身所不必须的参数. 这一点感觉还是不好, 应该优化. 可是如何优化呢? 尚未可知. 有知道的朋友, 请给我留言.

大话设计模式--第二章 策略设计模式

大话设计模式--第二章策略设计模式