大话设计模式之2策略模式-java代码

需求：
   做一个商场收银软件，营业员根据客户所购商品的单价和数量，向客户收费；

1、第一版

public class Demo {
    //声名一个变量来记录总计
    double total = 0d;
    String result = "";

    private void btnOk_Click(String cbxType, String txtPrice,String txtNum) {
        double totalPrice = Double.valueOf(txtPrice) * Double.valueOf(txtNum);
        total = total + totalPrice;
        result = result + "单价：" + txtPrice + "，数量：" + txtNum + " 合计：" +totalPrice + "\n";
    }
}

需求变更/延伸：商场搞活动，所有商品打八折、打五折。。。

  商场满300送100、满200送50。。。

2、简单工厂模式实现商场促销（第二版）

/**
 * 现金收费抽象类
 */
abstract class CashSuper{
    /**
     * 现金收取超类的抽象方法，收取现金，参数为原价，返回为当前价
     * @param money
     * @return
     */
    public abstract double acceptCash(double money);
}

//正常收费子类
class CashNormal extends CashSuper{

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

//打折收费子类
class CashRebate extends CashSuper{

    private double moneyRebate = 1d;
    public CashRebate(String moneyRebate){
        //打折收费，初始化时，必须要输入折扣率，如八折，就是0.8
        this.moneyRebate = Double.parseDouble(moneyRebate);
    }
    @Override
    public double acceptCash(double money) {
        return money * moneyRebate;
    }
}

//返利收费子类
class CashReturn extends CashSuper{
    private double moneyCondition = 0;
    private  double moneyReturn = 0;
    //返利收费，初始化时，必须要输入返利条件和返利值，比如满300，返100，
    //则moneyCondition为300，moneyReturn为100
    public CashReturn(String mongeyCondition, String moneyReturn) {
        this.moneyCondition = Double.valueOf(mongeyCondition);
        this.moneyReturn = Double.valueOf(moneyReturn);
    }

    @Override
    public double acceptCash(double money) {
        double result = money;
        if (money >= moneyCondition)
            //若大于返利条件，则需要减去返利值
            result = money - Math.floor(money/moneyCondition)*moneyReturn;
        return result;
    }
}

/**
 * 现金收费工厂类
 */
class CashFactory{
    public static CashSuper createCashAccept(String type) {
        CashSuper cs = null;
        if (type.equals("正常收费")) {
            cs = new CashNormal();
        } else if (type.equals("满300返100")) {
            CashReturn cr1 = new CashReturn("300", "100");
            cs = cr1;
        } else if (type.equals("打8折")) {
            CashRebate cr2 = new CashRebate("0.8");
            cs = cr2;
        }
        return cs;
    }
}

//客户端程序主要部分
class Body{
        double total = 0.0d;
        String result = "";

    public static void main(String[] args) {
        Body body = new Body();
        body.btnOk_Click("打8折","20","3");
        body.btnOk_Click("满300返100","300","3");
        body.btnOk_Click("正常收费","99","3");
        System.out.println(body.result + "\n" + "总计：" +body.total);
    }

    private void btnOk_Click(String cbxType, String txtPrice,String txtNum) {
        CashSuper csuper = CashFactory.createCashAccept(cbxType);

        double totalPrice = 0d;
        totalPrice = csuper.acceptCash(Double.valueOf(txtPrice)) * Double.valueOf(txtNum);
        total = total + totalPrice;
        result = result + "单价：" + txtPrice + "，数量：" + txtNum + " 合计：" +totalPrice + "\n";
    }
}

3、策略模式简单介绍

/**
 * Strategy类，定义所有支持的算法的公共接口
 * 抽象算法类
 */
abstract class Strategy{
    //算法方法
    public abstract void AlgorithmInterface();
}

/**
 * ConcreteStrategy,封装了具体的算法或行为，
 */

//具体算法A
class ConcreteStrategyA extends Strategy{
    @Override
    public void AlgorithmInterface() {
        System.out.println("算法A实现");
    }
}

class ConcreteStrategyB extends Strategy {
    @Override
    public void AlgorithmInterface() {
        System.out.println("算法B实现");
    }
}

class ConcreteStrategyC extends Strategy{
    @Override
    public void AlgorithmInterface() {
        System.out.println("算法C实现");
    }
}

class Context{
    Strategy strategy;

    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    //上下文接口
    public void ContextInterface(){
        strategy.AlgorithmInterface();
    }
}


class StrategyMain{
    public static void main(String[] args) {
        Context context;

        context = new Context(new ConcreteStrategyA());
        context.ContextInterface();

        context = new Context(new ConcreteStrategyB());
        context.ContextInterface();

        context = new Context(new ConcreteStrategyC());
        context.ContextInterface();

    }

}

4、策略模式实现商场促销（第三版）

package DesignPattern.strategyPattern;

import java.sql.ResultSet;

public class StrategyPattern{
    //客户端主要代码
    double total = 0.0d;
    String txtPrice = "100";
    String txtNum = "3";
    String result = "";

    public static void main(String[] args) {
        StrategyPattern sp = new StrategyPattern();
        sp.btnOk_Click("打8折");
        sp.btnOk_Click("满300返100");
        sp.btnOk_Click("正常收费");
        System.out.println(sp.result);
    }
    
    private void btnOk_Click(String type){
        CashContext cc = null;

        //根据下拉框，将相应的策略对象作为参数传入CashContext的对象中
        if (type.equals("正常收费")) {
            cc = new CashContext(new CashNormal());
        } else if (type.equals("满300返100")) {
            cc = new CashContext(new CashReturn("300", "100"));
        } else if (type.equals("打8折")) {
            cc = new CashContext(new CashRebate("0.8"));
        }

        double totalPrice = 0d;
        //通过对Context的GetResult方法的调用，可以得到收取费用的结果，让具体算法与客户进行的隔离
        totalPrice = cc.GetResult(Double.valueOf(txtPrice) * Double.valueOf(txtNum));
        total = total + totalPrice;
        result = result + "单价：" + txtPrice + "，数量：" + txtNum + " 合计：" +totalPrice + "\n";
    }
}

//CashContext类
class CashContext{
    //声明一个CashSuper对象
    private CashSuper cs;

    //通过构造方法，传入具体的收费策略
    public CashContext(CashSuper cs) {
        this.cs = cs;
    }

    public double GetResult(double money){
        //根据收费策略的不同，获得计算结果
        return cs.acceptCash(money);
    }
}

/**
 * 现金收费抽象类
 */
abstract class CashSuper{
    /**
     * 现金收取超类的抽象方法，收取现金，参数为原价，返回为当前价
     * @param money
     * @return
     */
    public abstract double acceptCash(double money);
}

//正常收费子类
class CashNormal extends CashSuper{
    public double acceptCash(double money) {
        return money;
    }
}

//打折收费子类
class CashRebate extends CashSuper{

    private double moneyRebate = 1d;
    public CashRebate(String moneyRebate){
        //打折收费，初始化时，必须要输入折扣率，如八折，就是0.8
        this.moneyRebate = Double.parseDouble(moneyRebate);
    }
    @Override
    public double acceptCash(double money) {
        return money * moneyRebate;
    }
}

//返利收费子类
class CashReturn extends CashSuper{
    private double moneyCondition = 0;
    private  double moneyReturn = 0;
    //返利收费，初始化时，必须要输入返利条件和返利值，比如满300，返100，
    //则moneyCondition为300，moneyReturn为100
    public CashReturn(String mongeyCondition, String moneyReturn) {
        this.moneyCondition = Double.valueOf(mongeyCondition);
        this.moneyReturn = Double.valueOf(moneyReturn);
    }

    @Override
    public double acceptCash(double money) {
        double result = money;
        if (money >= moneyCondition)
            //若大于返利条件，则需要减去返利值
            result = money - Math.floor(money/moneyCondition)*moneyReturn;
        return result;
    }
}

5、策略模式和简单工厂模式结合（第四版）

与第三版的区别

CashContext类，构造方法传入的参数变了

调用变的简单了

总结：