学习大话设计模式02_工厂模式 进阶至 策略模式

  1 /**

  2  * 现金收费抽象类

  3  * @author Monica

  4  *

  5  */

  6 public abstract class CashSuper {

  7     /**

  8      * 现金收取超类的抽象方法

  9      * @param money 收取现金，参数为原价

 10      * @return 返回当前价

 11      */

 12     public abstract double acceptCash(double money);

 13 }

 14 

 15 /**

 16  * 正常收费子类

 17  * @author Monica

 18  *

 19  */

 20 public class CashNormal extends CashSuper{

 21 

 22     /**

 23      * 正常收费，原价返回

 24      */

 25     @Override

 26     public double acceptCash(double money) {

 27         return money;

 28     }

 29 

 30 }

 31 

 32 /**

 33  * 打折收费子类

 34  * @author Monica

 35  *

 36  */

 37 public class CashRebate extends CashSuper{

 38     private double moneyRebate = 1d;

 39     

 40     public CashRebate(String moneyRebate) {

 41         /*

 42          * 打折收费，初始化时，必须输入折扣费，如八折，就是0.8

 43          */

 44         this.moneyRebate = Double.parseDouble(moneyRebate);

 45     }

 46 

 47     @Override

 48     public double acceptCash(double money) {        

 49         return money * moneyRebate;

 50     }

 51 

 52 }

 53 

 54 /**

 55  * 返回收费子类

 56  * @author Monica

 57  *

 58  */

 59 public class CashReturn extends CashSuper {

 60     //返利条件

 61     private double moneyCondition = 0.0d;

 62     //返利值

 63     private double moneyReturn = 0.0d;

 64 

 65     public CashReturn(String moneyCondition, String moneyReturn) {

 66         this.moneyCondition = Double.parseDouble(moneyCondition);

 67         this.moneyReturn = Double.parseDouble(moneyReturn);

 68     }

 69     

 70     @Override

 71     public double acceptCash(double money) {

 72         double result = money;

 73         if (money >= moneyCondition) {

 74             //若大于返利条件，则需要减去返利值

 75             result = money - Math.floor(money / moneyCondition) * moneyReturn; 

 76         }

 77         return result;

 78     }

 79 }

 80 

 81 /**

 82  * 现金收费工厂类

 83  * @author Monica

 84  *

 85  */

 86 public class CashFactory {

 87     public static CashSuper createCashAccept(String type) {

 88         CashSuper cs = null;

 89         switch (type) {

 90         case "正常收费":

 91             cs = new CashNormal();

 92             break;

 93         case "满300返回100":

 94             cs = new CashReturn("300", "100");

 95             break;

 96         case "打8折":

 97             cs = new CashRebate("0.8");

 98             break;

 99         }

100         return cs;

101     }

102 }

不利点：每次维护和扩展收费方式，都要改动这个工厂。
进阶：策略模式

 

/**

 * 策略与简单工厂结合

 * @author Monica

 *

 */

public class CashContext {

    CashSuper cs = null;

    

    public CashContext(String type) {

        switch (type) {

        case "正常收费":

            cs = new CashNormal();

            break;

        case "满300返回100":

            cs = new CashReturn("300", "100");

            break;

        case "打8折":

            cs = new CashRebate("0.8");

            break;

        }

    }

    

    public double GetResult(double money) {

        return cs.acceptCash(money);

    }

}



//客户端

    public static void main(String[] args) {

        CashContext csuper = new CashContext("打8折");

        double totalPrices = 0d;

        totalPrices = csuper.GetResult(Double.parseDouble("800"));

    }

 

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

优点：

策略模式的Strategy类层次为Context定义了一系列的可供重用的算法或行为。继承有助于析取出这些算法中的公共功能。

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

当不同的行为堆砌在一个类中时，就很难避免使用条件语句来选择合适的行为。将这些行为封装在一个个独立的Strategy类中，可以在使用这些行为的类中消除条件语句。

策略模式就是用来封装算法的，但在实践中，我们可以用它来封装几乎任务类型的规则，只要在分析过程中听到需要在不同时间应用不同的业务规则，就可以考虑使用策略模式处理这种变化的可能性

在基本的策略模式中，选择所用具体实现的职责由客户端对象承担，并转给策略模式的Context对象。

 

任务需求的变更都是需要成本的

（更改需要还是需要更改switch，这个办法可以用到  反射技术  ）