java 之 策略模式（大话设计模式）

温故而知新，每次读设计模式都会有不同的体验，坚持每天一个设计模式，直到熟练运用设计模式。

策略模式定义了很多完成相同工作的算法，但实现不同，它可以以相同的方式调用所有的算法，减少了算法和调用算法的耦合。

以下是大话设计模式的策略类图

/**
 * 上下文
 */
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());
    }
}

这样就实现了简单工厂模式和策略模式的结合，客户端只需要直接创建一个上下文，而不需要知道具体去创建的哪个对象。实际工作中很多业务模型都可以抽象成策略加工厂模式，对策略模式理解不同层次会有不同的认识，

逐渐的会发现大话设计模式不仅仅可以应用在代码层次，还可以上升到公司的业务模型等！

以上希望能够帮助学习策略模式的小伙伴！