2、策略模式—算法家族的支配者

策略模式（Strategy）：它定義了算法家族，分別封裝起來，讓他們之間可以互相替換，此模式讓算法的變化，不會影響到使用算法的客戶。

UML圖：

package com.thpin.repository.designpattern;

import java.io.FileInputStream;
import java.io.IOException;
import java.util.Properties;

public class StrategyDemo {
    public static void main(String[] args) {
        Strategy strategy = null;
        // 一般策略測試
        strategy = new Strategy(new AlgorithmA());
        strategy.strategyAlgorithm();
        strategy = new Strategy(new AlgorithmB());
        strategy.strategyAlgorithm();
        strategy = new Strategy(new AlgorithmC());
        strategy.strategyAlgorithm();

        // 與工廠模式結合測試
        strategy = new Strategy("A");
        strategy.strategyAlgorithm();
        strategy = new Strategy("B");
        strategy.strategyAlgorithm();
        strategy = new Strategy("C");
        strategy.strategyAlgorithm();
    }
}

/*
 * 策略模式
 * 算法之間可以互相替換，此模式讓算法的變化，不會影響到使用算法的客戶
 */
class Strategy {
    private Algorithm algorithm;

    /*
     * 一般策略，初始化算法字段
     */
    public Strategy(Algorithm algorithm) {
        this.algorithm = algorithm;
    }

    /*
     * 與工廠模式結合，初始化算法字段
     */
    public Strategy(String algorithmName) {
        this.algorithm = AlgorithmFactory.createAlgorithm(algorithmName);
    }

    /*
     * 實質執行的是算法字段的方法
     * 想要什麼算法，替換算法字段就ok了
     */
    public void strategyAlgorithm() {
        algorithm.algorithm();
    }
}

/*
 * 抽象算法類
 */
abstract class Algorithm {
    public abstract void algorithm();
}

/*
 * 算法A
 */
class AlgorithmA extends Algorithm {
    public void algorithm() {
        System.out.println("Algorithm A");
    }
}

/*
 * 算法B
 */
class AlgorithmB extends Algorithm {
    public void algorithm() {
        System.out.println("Algorithm B");
    }
}

/*
 * 算法C
 */
class AlgorithmC extends Algorithm {
    public void algorithm() {
        System.out.println("Algorithm C");
    }
}

/*
 * 算法工廠
 */
class AlgorithmFactory {
    private static Properties init() {
        Properties properties = new Properties();
        try {
            properties.load(new FileInputStream(
                    "src/main/java/com/thpin/repository/designpattern/algorithmMapping.properties"));
        } catch (IOException e) {
            e.printStackTrace();
        }
        return properties;
    }

    public static Algorithm createAlgorithm(String algorithmName) {
        Algorithm algorithm = null;
        String fullName = init().getProperty(algorithmName);
        try {
            algorithm = (Algorithm) Class.forName(fullName).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return algorithm;
    }
}


algorithmMapping.properties：
A=com.thpin.repository.designpattern.AlgorithmA
B=com.thpin.repository.designpattern.AlgorithmB
C=com.thpin.repository.designpattern.AlgorithmC

結果：

Algorithm A
Algorithm B
Algorithm C
Algorithm A
Algorithm B
Algorithm C

策略模式就利用其擁有所有算法的原始類型字段，根據多態性可以將任意繼承了這個類型的子類算法實例初始化這個字段，這個策略就擁有這個子類的算法功能。舉個形象的例子，一個人有一個屬性就是武器，你給他一把勺子他就能做飯，你給他一把槍他就能打小日本，你給他原子彈他就能就去炸廣島，你可以試着實現我說的這個例子。