设计模式之策略模式

策略模式——StrategyPattern

　　策略模式：它定义了算法家族，分别封装起来，让它们之间可以互相替换，此模式优点为算法变化时不会影响算法的客户。

基本实现方法是：

• 　　策略基类：为某一类功能设置一个策略基类，使用抽象方法，定义所有支持的算法的公共接口
• 　　策略类：继承策略基类，封装具体的算法或行为。
• 　　上下文类：用于选择使用哪一个策略类，并实现调用其对应的策略类的方法。

　　

　　我的理解是：

• 　　策略模式的重点是：在上下文类中，直接传入需要的对象，通过上下文类控制这个对象，调用这个对象的方法。
• 　　简单工厂模式的重点是：输入条件，通过工厂返回一个需要的对象。并将这个对象直接赋给基类。　　

例子：现有一商场进行促销，可对某商品采用打折促销方式，或采用满一定金额减免一部分金额的促销方案。

促销方案可以灵活的变化。

策略基类 CashSuper

public abstract class CashSuper {
    public abstract double acceptCash(double money);
}

正常收银策略类 CashNormal 

public class CashNormal extends CashSuper {
    @Override
    public double acceptCash(double money) {
        return money;
    }
}

打折收银策略类  CashRebate 

public class CashRebate extends  CashSuper {
    private double moneyRebate=1d;
    public CashRebate(String moneyRebate)
    {
        this.moneyRebate=Double.parseDouble(moneyRebate);
    }

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

满减收银策略类  CashReturn 

public class CashReturn extends CashSuper {
    private double moneyCondition=0.0d;
    private double moneyReturn=0.0d;
    public CashReturn(String moneyConditon,String moneyReturn)
    {
        this.moneyCondition=Double.parseDouble(moneyConditon);
        this.moneyReturn=Double.parseDouble(moneyReturn);
    }
    @Override
    public double acceptCash(double money) {
        double result=money;
        if(money>=moneyCondition)
            result=money-(int)(money/moneyCondition)*moneyReturn;
        return result;
    }
}

上下文类  CashContext 

public class CashContext {
    private CashSuper cashSuper;
    public CashContext(CashSuper cashSuper)
    {
        this.cashSuper=cashSuper;
    }
    public double getReslut(double money)
    {
        return cashSuper.acceptCash(money);
    }
}

主函数

public class Client {
    public static void main(String[] args) {
        String conditon="";
        double money=900;
//        conditon="正常收费";
//        conditon="八折";
        conditon="满200减100";

        /**
         * 正常策略模式
         */
        CashContext cashContext=null;
        switch (conditon)
        {
            case "正常收费":
                cashContext=new CashContext(new CashNormal());break;
            case  "八折":
                cashContext=new CashContext(new CashRebate("0.8"));break;
            case "满200减100":
                cashContext=new CashContext(new CashReturn("200","100"));break;
        }
        System.out.println("原价："+money+"  "+conditon+"后："+cashContext.getReslut(money));

    }
}

这种方法 在主函数中 通过swich函数判断需要实现哪种功能，然后new出相应对象传入上下文类中，再调用上下文类的方法就可以执行需要的方法。

但这种形式会让客户端去判断使用哪一个算法，可以使用策略模式与简单工厂模式相结合的方法进行改进。

策略模式与简单工厂模式相结合

与工厂模式结合的上下文类  CashContextWithFactory 

/**
 * 策略与工厂结合
 */
public class CashContextWithFactory {
    private CashSuper cashSuper;
    public CashContextWithFactory(String conditon)
    {
        switch (conditon)
        {
            case "正常收费":
                this.cashSuper=new CashNormal();break;
            case  "八折":
                this.cashSuper=new CashRebate("0.8");break;
            case "满200减100":
                this.cashSuper=new CashReturn("200","100");break;
        }
    }
    public double getReslut(double money)
    {
        return cashSuper.acceptCash(money);
    }
}

主函数 

public class Client {
    public static void main(String[] args) {
        String conditon="";
        double money=900;
//        conditon="正常收费";
//        conditon="八折";
        conditon="满200减100";

        /**
         * 策略模式与简单工厂结合
         */
       CashContextWithFactory cashContextWithFactory=new CashContextWithFactory(conditon);
       System.out.println("原价："+money+"  "+conditon+"后："+cashContextWithFactory.getReslut(money));
    }
}

这样就将方法判断转移到了上下文类中。

相关代码：https://github.com/lancelee98/DesignPattern/tree/master/src/StrategyPattern