溫故而知新，每次讀設計模式都會有不同的體驗，堅持每天一個設計模式，直到熟練運用設計模式。

策略模式定義了很多完成相同工作的算法，但實現不同，它可以以相同的方式調用所有的算法，減少了算法和調用算法的耦合。

以下是大話設計模式的策略類圖

/**
 * 上下文
 */
public class Context {

    private Strategy strategy;

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

    public Double getResult() {
        
 
return strategy.getResult();
    }
}

/**
 * 策略接口
 */
public interface Strategy {

    public Double getResult();
}

/**
 * （具體策略類）原價策略
 */
public class StrategyA implements Strategy{

    private Double money;

    public StrategyA(Double money) {
        this.money = money;
    }

    @Override
    
 
public Double getResult() {

        return money;
    }

}

/**
 * （具體策略類）折扣策略
 */
public class StrategyB implements Strategy{

    private Double money;

    private Double discount;

    public StrategyB(Double money, Double discount) {
        this.money = money;
        this.discount = discount;
    }

    @Override
    
 
public Double getResult() {

        return money * discount;
    }

}

/**
 * （具體策略類）滿減策略
 */
public class StrategyC implements Strategy{

    private Double money;

    private Double subMoney;

    public StrategyC(Double money, Double subMoney) {
        this.money = money;
        this.subMoney = subMoney;
    }

    @Override
    public Double getResult() {

        if (money > subMoney) {
            return money - subMoney;
        }
        return money;
    }

}

/**
 * 客戶端
 */
public class Test {

    public static void main(String[] args) {
        Context contextA = new Context(new StrategyA(60d));
        System.out.println(contextA.getResult());
        Context contextB = new Context(new StrategyB(60d, 0.8d));
        System.out.println(contextB.getResult());
        Context contextC = new Context(new StrategyB(60d, 10d));
        System.out.println(contextC.getResult());
    }
}

以上是策略模式的一個demo，不過現在客戶端還是要知道具體使用哪個策略，還是存在耦合，如果用簡單工廠模式和策略模式結合

思考下，我們不需要改變策略類，而是希望改變客戶端，讓客戶端不在去知道具體new哪個對象於是下面我們改造下客戶端和上下文，讓上下文幫我們選擇具體策略。

上下文代碼改造後

/**
 * 上下文
 */
public class Context {

    private Strategy strategy;

    /**
     * @param type 策略類型
     * @param money 價錢
     * @param subMoney 滿減價錢
     * @param discount 折扣
     */
    public Context(String type, Double money, Double subMoney, Double discount) {

        switch (type) {
        case "折扣":
            strategy = new StrategyB(money, discount);
            break;
        case "滿減":
            strategy = new StrategyC(money, subMoney);
            break;
        default:
            strategy = new StrategyA(money);
            break;
        }
    }

    public Double getResult() {
        return strategy.getResult();
    }
}

客戶端代碼

/**
 * 客戶端
 */
public class Test {

    public static void main(String[] args) {
        Context contextA = new Context("原價", 60d, null, null);
        System.out.println(contextA.getResult());

        Context contextB = new Context("折扣", 60d, null, 0.8d);
        System.out.println(contextB.getResult());

        Context contextC = new Context("滿減", 60d, 10d, null);
        System.out.println(contextC.getResult());
    }
}

這樣就實現了簡單工廠模式和策略模式的結合，客戶端只需要直接創建一個上下文，而不需要知道具體去創建的哪個對象。實際工作中很多業務模型都可以抽象成策略加工廠模式，對策略模式理解不同層次會有不同的認識，

逐漸的會發現大話設計模式不僅僅可以應用在代碼層次，還可以上升到公司的業務模型等！

以上希望能夠幫助學習策略模式的小夥伴！

java 之 策略模式（大話設計模式）