策略模式

　　定義：策略模式是定義一系列的演算法,把它們一個個封裝起來, 並且使它們可相互替換。

　　大白話：將原來所有if-else裡的具體演算法封裝各自的類中。

優點

　　1.可以消除大量的if-else語句，想要徹底去掉if-else可以使用策略+工廠模式來實現

　　2.提高了演算法的保密性和安全性，可以使用這種模式避免暴漏複雜的演算法。

　　3.具體策略發生修改，對客戶端沒有影響

缺點

　　1.客戶端使用的時候，必須要知道所有的策略類

　　2.策略過多的話，會導致類過多。

比如現在需求是：

有四類會員：0-普通會員 1-白銀會員 2-黃金會員 3-白金會員

1. 少於1000不打折

2. 普通會員 不打折

3. 白銀會員 優惠50元

4. 黃金會員 8折

5. 白金會員 優惠50元，再打7折

傳統方法

public class Test {
    public static void main(String[] args) {
        //普通會員 不打折  10000.0
        System.out.println(getResult(10000L, 0));
        //白銀會員 優惠50元  9950.0
        System.out.println(getResult(10000L, 1));
        //黃金會員 8折  8000.0
        System.out.println(getResult(10000L, 2));
        
 
//白金會員 優惠50元，再打7折  6965.0
        System.out.println(getResult(10000L, 3));
    }

    private static double getResult(long money, int type) {

        if (money < 1000) {
            return money;
        }
        if (type == 0) {//普通會員
            System.out.println("普通會員 不打折");
            money = money;
        } 
 
else if (type == 1) {//白銀會員
            System.out.println("白銀會員 優惠50元");
            money = money - 50;
        } else if (type == 2) {//黃金會員
            System.out.println("黃金會員 8折");
            money = (long) (money * 0.8);
        } else {//白金會員
            System.out.println("白金會員 優惠50元，再打7折");
            money = (long) ((money - 50) * 0.7);
        }
        return money;
    }
}

使用策略模式

思路：

1. 建立策略介面，裡面定義計算money的抽象方法。

2. 建立四個會員策略實現類，實現上面的策略介面。重寫計算money的方法

3. 建立測試類，根據會員型別的不同，new不同的實現類物件。呼叫物件的計算money的方法。

//策略介面
public interface Strategy {
    //計算費用
    double compute(long money);
}

//四個實現類
//普通會員
public class OrdinaryStrategy implements Strategy {
    @Override
    public double compute(long money) {
        System.out.println("普通會員 不打折");
        return money;
    }
}
//白銀會員
public class SilverStrategy implements Strategy {
    @Override
    public double compute(long money) {
        System.out.println("白銀會員 優惠50元");
        return money - 50;
    }
}
//黃金會員
public class GoldStrategy implements Strategy {
    @Override
    public double compute(long money) {
        System.out.println("黃金會員 8折");
        return money * 0.8;
    }
}
//白金會員
public class PlatinumStrategy implements Strategy {
    @Override
    public double compute(long money) {
        System.out.println("白金會員 優惠50元，再打7折");
        return (money - 50) * 0.7;
    }
}

//測試類
public class Test {
    
    public static void main(String[] args) {
        //普通會員 不打折  10000.0
        System.out.println(getResult(10000L, 0));
        //白銀會員 優惠50元  9950.0
        System.out.println(getResult(10000L, 1));
        //黃金會員 8折  8000.0
        System.out.println(getResult(10000L, 2));
        //白金會員 優惠50元，再打7折  6965.0
        System.out.println(getResult(10000L, 3));
    }

    private static double getResult(long money, int type) {

        if (money < 1000) {
            return money;
        }
        Strategy strategy;
        if (type == 0) {//普通會員
            strategy = new OrdinaryStrategy();
        } else if (type == 1) {//白銀會員
            strategy = new SilverStrategy();
        } else if (type == 2) {//黃金會員
            strategy = new GoldStrategy();
        } else {//白金會員
            strategy = new PlatinumStrategy();
        }
        return strategy.compute(money);
    }
}

工廠+策略模式

（徹底處理掉if-else）

//策略介面
public interface Strategy {
    //計算費用
    double compute(long money);
    // 返回 type
    int getType();
}
//四個實現類
//普通會員策略
public class OrdinaryStrategy implements Strategy {
    @Override
    public double compute(long money) {
        System.out.println("普通會員 不打折");
        return money;
    }
    // 新增 type 返回
    @Override
    public int getType() {
        return 0;
    }
}
//白銀會員
public class SilverStrategy implements Strategy {
    @Override
    public double compute(long money) {

        System.out.println("白銀會員 優惠50元");
        return money - 50;
    }
    // type 返回
    @Override
    public int getType() {
        return 1;
    }
}
//黃金會員
public class GoldStrategy implements Strategy{

    @Override
    public double compute(long money) {
        System.out.println("黃金會員 8折");
        return money * 0.8;
    }
    // type 返回
    @Override
    public int getType() {
        return 2;
    }
}
//白金會員
public class PlatinumStrategy implements Strategy {
    @Override
    public double compute(long money) {
        System.out.println("白金會員 優惠50元，再打7折");
        return (money - 50) * 0.7;
    }
    // type 返回
    @Override
    public int getType() {
        return 3;
    }
}

//工廠類
public class StrategyFactory {
    
    private Map<Integer, Strategy> map;
    
    public StrategyFactory() {
        List<Strategy> strategies = new ArrayList<>();
        
        strategies.add(new OrdinaryStrategy());
        strategies.add(new SilverStrategy());
        strategies.add(new GoldStrategy());
        strategies.add(new PlatinumStrategy());

        // 看這裡 看這裡 看這裡！
        map = strategies.stream().collect(Collectors.toMap(Strategy::getType, strategy -> strategy));

        /* 等同上面
        map = new HashMap<>();
        for (Strategy strategy : strategies) {
            map.put(strategy.getType(), strategy);
        }*/
    }

    public static class Holder {
        public static StrategyFactory instance = new StrategyFactory();
    }

    public static StrategyFactory getInstance() {
        return Holder.instance;
    }

    public Strategy get(Integer type) {
        return map.get(type);
    }
}

//測試類
public class Test {

    public static void main(String[] args) {
        //普通會員 不打折  10000.0
        System.out.println(getResult(10000L, 0));
        //白銀會員 優惠50元  9950.0
        System.out.println(getResult(10000L, 1));
        //黃金會員 8折  8000.0
        System.out.println(getResult(10000L, 2));
        //白金會員 優惠50元，再打7折  6965.0
        System.out.println(getResult(10000L, 3));
    }

    private static double getResult(long money, int type) {

        if (money < 1000) {
            return money;
        }

        Strategy strategy = StrategyFactory.getInstance().get(type);

        if (strategy == null){
            throw new IllegalArgumentException("please input right type");
        }

        return strategy.compute(money);
    }
}

在Java中的應用

　　策略介面-Comparator介面