策略模式

1.定義

一個類的行為或其算法可以在運行時進行更改。

策略模式通常有3種角色。

AbstractStrategy：抽象策略角色。策略，算法的抽象。

public interface AbstractStrategy {

    /**
     * 策略的行為，算法
     */
    void operate();
}

Strategy：具體策略角色。實現抽象策略中定義的行為或算法。

public class StrategyOne implements AbstractStrategy {

    @Override
    public void operate() {
        System.out.println("策略模式1的具體行為");
    }
}

public class StrategyTwo implements AbstractStrategy {

    @Override
    public void operate() {
        System.out.println("策略模式2的具體行為");
    }
}

Context：上下文角色。封裝具體的策略，屏蔽高層模塊對策略，算法的直接訪問。

public class Context {

    /** 抽象策略 **/
    private AbstractStrategy strategy;

    /**
     * 設置具體的策略
     * @param strategy
     */
    public void setStrategy(AbstractStrategy strategy) {
        this.strategy = strategy;
    }

    /**
     * 封裝策略方法
     */
    public void run() {
        this.strategy.operate();
    }
}

場景類

public class Client {

    public static void main(String[] args) {
        Context context = new Context();

        /** 設置第一個策略 **/
        context.setStrategy(new StrategyOne());
        /** 執(zhí)行第一個策略 **/
        context.run();

        /** 設置第二個策略 **/
        context.setStrategy(new StrategyTwo());
        /** 執(zhí)行第二個策略 **/
        context.run();
    }
}

2.應用

2.1 優(yōu)點

• 策略，算法可以自由的切換。
• 擴展性良好，只需要實現抽象策略即可。

2.2 缺點

• 當策略過多時，策略類的數量也會增加。
• 所有的策略類都需要對外暴露。高層模塊必須知道有哪些策略才可以進行調用。

2.3 注意事項

當一個策略家族中策略類的數量超過4個時，需要考慮結合其它模式使用，解決策略類膨脹和對外暴露的問題。

3.擴展

輸入三個參數（int, int, String），進行加減法運算，不考慮參數校驗。

3.1 直接加減法

public class DirectCalculator {

    private final static String ADD = "+";

    private final static String SUB = "-";

    public int calculate(int a, int b, String symbol) {
        int result = 0;

        if (ADD.equals(symbol)) {
            result = this.add(a, b);
        } else if (SUB.equals(symbol)) {
            result = this.sub(a, b);
        }

        return result;
    }

    /**
     * 加法 a + b
     * @param a
     * @param b
     * @return
     */
    private int add(int a, int b) {
        return a + b;
    }

    /**
     * 減法 a - b
     * @param a
     * @param b
     * @return
     */
    private int sub(int a, int b) {
        return a - b;
    }
}

3.2 策略模式

public interface Calculator {

    /**
     * 抽象計算方法
     * @param a
     * @param b
     * @return
     */
    int calculate(int a, int b);
}

public class AddCalculator implements Calculator {

    /**
     * 加法 a + b
     * @param a
     * @param b
     * @return
     */
    @Override
    public int calculate(int a, int b) {
        return a + b;
    }
}

public class SubCalculator implements Calculator {

    /**
     * 減法 a - b
     * @param a
     * @param b
     * @return
     */
    @Override
    public int calculate(int a, int b) {
        return a - b;
    }
}

public class CalculatorContext {

    private Calculator calculator;

    public CalculatorContext(Calculator calculator) {
        this.calculator = calculator;
    }

    public void setCalculator(Calculator calculator) {
        this.calculator = calculator;
    }

    public int calculate(int a, int b) {
        return this.calculator.calculate(a, b);
    }
}

3.3 策略枚舉

public enum CalculatorStrategyEnum {

    /** 加法運算 **/
    ADD("+") {
        @Override
        public int calculate(int a, int b) {
            return a + b;
        }
    },

    /** 減法運算 **/
    SUB("-") {
        @Override
        public int calculate(int a, int b) {
            return a - b;
        }
    };

    private String symbol = "";

    CalculatorStrategyEnum(String symbol) {
        this.symbol = symbol;
    }

    public String getSymbol() {
        return this.symbol;
    }

    /**
     * 聲明一個計算的抽象方法
     * @param a
     * @param b
     * @return
     */
    public abstract int calculate(int a, int b);
}

public class Client {

    public static void main(String[] args) {
        System.out.println(CalculatorStrategyEnum.ADD.calculate(1, 2));

        System.out.println(CalculatorStrategyEnum.SUB.calculate(5, 1));
    }
}