Java中的23种设计模式之——策略（Stragedy）模式（6）

举个比较形象的例子：

出行旅游：我们可以有几个策略可以考虑：可以骑自行车，汽车，做火车，飞机。每个策略都可以得到相同的结果，但是它们使用了不同的资源。选择策略的依据是费用，时间，使用工具还有每种方式的方便程度 。

1.策略模式-----对象行为型：定义一系列的算法,把每一个算法封装起来, 并且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化。

策略模式把对象本身和运算规则区分开来，其功能非常强大，因为这个设计模式本身的核心思想就是面向对象编程的多形性的思想

 

2.模式组成：

环境类(Context):用一个ConcreteStrategy对象来配置。维护一个对Strategy对象的引用。可定义一个接口来让Strategy访问它的数据。
抽象策略类(Strategy):定义所有支持的算法的公共接口。 Context使用这个接口来调用某ConcreteStrategy定义的算法。
具体策略类(ConcreteStrategy):以Strategy接口实现某具体算法。

3.优缺点：

Strategy模式有下面的一些优点：
1) 相关算法系列 Strategy类层次为Context定义了一系列的可供重用的算法或行为。 继承有助于析取出这些算法中的公共功能。
2) 提供了可以替换继承关系的办法： 继承提供了另一种支持多种算法或行为的方法。 将算法封装在独立的Strategy类中使得你可以独立于其Context改变它，使它易于切换、易于理解、易于扩展。
3) 消除了一些if else条件语句 ：Strategy模式提供了用条件语句选择所需的行为以外的另一种选择。
4) 实现的选择 Strategy模式可以提供相同行为的不同实现。客户可以根据不同时间 /空间权衡取舍要求从不同策略中进行选择。

Strategy模式缺点:

1)客户端必须知道所有的策略类，并自行决定使用哪一个策略类；
2 ) Strategy和Context之间的通信开销 
3 )策略模式将造成产生很多策略类。

4.实例：

购买商品，有原价，打折，满减三种形式，也就是三种算法，利用策略模式就可以在context选择要调用的方式

public class Strategy {
    public static void main(String[] args) {
        CashContext_ test = new CashContext_(TYPE.CASH_DISCOUNT);
    }
}
enum TYPE{
    NORMAL,CASH_DISCOUNT,CASH_RETURN;//正常，折扣，满减
}
interface CashSuper {
    public double acceptCash(double money);
}
class CashNormal implements CashSuper{
    
    @Override
    public double acceptCash(double money) {
        return money;
    }
}
class CashDiscount implements CashSuper {
    private double moneyDiscoMt;

    public CashDiscount(double moneyDiscoMt) {
        this.moneyDiscoMt = moneyDiscoMt;
    }

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

class CashReturn implements CashSuper{
    private double moneyCondition;
    private double moneyReturn;
    public CashReturn(double moneyCondition, double moneyReturn){
        this.moneyCondition = moneyCondition;
        this.moneyReturn = moneyReturn;
    }
    @Override
    public double acceptCash(double money) {
        double result = money;
        if(money >= moneyCondition){
            result = money - Math.floor(money/moneyCondition)*moneyReturn;
        }
        return result;
    }
    
}
class CashContext_{
    private CashSuper cs;
    private TYPE t;
    public CashContext_(TYPE t){
        switch(t){
        case NORMAL:
            cs = new CashNormal();
            System.out.println(cs.acceptCash(300));
            break;
        case CASH_RETURN:
            cs = new CashReturn(300,100);
            System.out.println(cs.acceptCash(300));
            break;
        case CASH_DISCOUNT:
            cs = new CashDiscount(0.8);
            System.out.println(cs.acceptCash(300));
            break;
        }
    }
    public double getResult(double money){
        
        return money;
        
    }
}