策略模式

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

1.定义：

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

封装变化点

在这里插入图片描述

Context类：

在这里插入图片描述

2.优点

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

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

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

只要在分析过程中听到需要在不同的时间应用不同的业务规则，就可以考虑使用策略模式处理这种变化的可能性。

3.使用商场促销的例子理解策略模式

3.1简单工厂模式：

可是实现，但是只解决了对象的创建问题，将具体子类的实例化问题由客户端转向工厂类内但是由于工厂本身包含了所有的实现子类，每次维护或者修改或者扩展子类都要改变这个工厂类。

在这里插入图片描述

(1)结账父类

package com.strategy.simplefactoty;public abstract  class CashSuper {
       //现金收取超类，收取现金，参数为原价，返回为当前价    public abstract double acceptCash(double money);}

(2)正常收费子类

package com.strategy.simplefactoty;public class CashNormal extends  CashSuper{
       //正常收费类    @Override    public double acceptCash(double money) {
           return money;    }}

(3)满减收费子类

package com.strategy.simplefactoty;import org.omg.CORBA.WStringSeqHelper;public class CashReturn extends CashSuper{
       //返利收费子类  满300反20这种    private  double  moneyCondition=0.0;    private  double moneyReturn=0.0;    public CashReturn(String moneyCondition,String moneyReturn){
           this.moneyCondition=Double.parseDouble(moneyCondition);        this.moneyReturn=Double.parseDouble(moneyReturn);    }    @Override    public double acceptCash(double money) {
           double result=money;        if(result>=moneyCondition){
               result=money-Math.floor(money/moneyCondition)*moneyReturn;        }        return result;    }}

(4)打折收费子类

package com.strategy.simplefactoty;public class CashRebate extends CashSuper{
       //打折收费子类    private double moneyRebate=1.0;    public CashRebate(String mRebate){
           this.moneyRebate=Double.parseDouble(mRebate);    }    @Override    public double acceptCash(double money) {
           return money*moneyRebate;    }}

(5)现金工厂类

package com.strategy.simplefactoty;public class CashFactory {
       public static CashSuper createCashAccept(String type){
           CashSuper cs=null;        switch (type) {
               case "正常收费":                cs = new CashNormal();                break;            case "满300减100":                cs = new CashReturn("300", "100");                break;            case "打8折":                cs = new CashRebate("0.8");                break;        }        return cs;    }}

(6)客户端类

package com.strategy.simplefactoty;public class Client {
       public static void main(String[] args) {
           double total=50.0; //总计        CashSuper cashSuper=CashFactory.createCashAccept("满300减100");        double price=20;        int number=60;        double  thisprice=  cashSuper.acceptCash(price*number);        total += thisprice;        System.out.println(thisprice);        System.out.println(total);    }}

简单工厂模式解决了对象的创建问题，在客户端不用暴漏现金收取子类的具体类，但是暴漏了现金收取的父类。

3.2策略模式

在这里插入图片描述

注意UML图中简单工厂类于各实现子类的关系和Context类与各实现子类的关系的不同。

父类和子类的实现同上边的简单工厂

(1)策略模式的Context类

package com.strategy.strategycontext;import com.strategy.simplefactoty.CashSuper;public class CashContext {
       private CashSuper cs;    public  CashContext(CashSuper cashSuper){
           this.cs=cashSuper;    }    public double GetResult(double money){
           return  cs.acceptCash(money);    }}

(2)策略模式的客户端

package com.strategy.strategycontext;import com.strategy.simplefactoty.CashNormal;import com.strategy.simplefactoty.CashRebate;import com.strategy.simplefactoty.CashReturn;public class client {
       public static void main(String[] args) {
           double total=0.0; //总计        CashContext cc=null;        String thetype="满300减100";  //模拟客户端的下拉框        switch (thetype) {
               case "正常收费":                cc = new CashContext(new CashNormal());                break;            case "满300减100":                cc = new CashContext(new CashReturn("300", "100"));                break;            case "打8折":                cc = new CashContext(new CashRebate("0,8"));                break;        }        double totalprice=cc.GetResult(1200);        total+=totalprice;        System.out.println(total);        }}

现在实现的子类的算法可以在客户端更换了，可是又回去了，判断建立哪一个对象的任务又交给了客户端。之前使用简单工厂模式可以将创建哪个对象的判断转移给工厂类，所以考虑策略模式和简单工厂模式的结合：

3.3 简单工厂+策略模式

（1）改造过后的CashContext

package com.strategy.simplefactoryandstrategy;import com.strategy.simplefactoty.CashNormal;import com.strategy.simplefactoty.CashRebate;import com.strategy.simplefactoty.CashReturn;import com.strategy.simplefactoty.CashSuper;public class CashContext {
       private 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;        }        //实例化的具体策略由客户端转移到了context类中，体现了简单工厂    }    public double GetResult(double money){
           return  cs.acceptCash(money);    }}

(2)策略模式+简单工厂模式的客户端类

package com.strategy.simplefactoryandstrategy;public class Client {
       public static void main(String[] args) {
           double total=0.0;        CashContext cc=new CashContext("满300减100");        double totalprice=cc.GetResult(1200);        total+=totalprice;        System.out.println(total);    }}

现在客户端代码更加简洁。相比于简单工厂模式，隐藏了现金收取父类，相比于策略模式实现了避免客户端选择使用哪个子类创建对象。客户端实现的是CashContext对象，并且调用的是CashContext对象的getResult方法，具体的收费算法完全与客户端隔离。

转载地址：http://lsfdi.baihongyu.com/

你可能感兴趣的文章