策略模式 · 《Java 編程思想》第五版

### 策略模式 *策略模式* 看起來像是從同一個基類繼承而來的一系列 *命令* 類。但是仔細查看 *命令模式*，你就會發現它也具有同樣的結構：一系列分層次的 *函數對象*。不同之處在于，這些函數對象的用法和策略模式不同。就像前面的 `io/DirList.java` 那個例子，使用 *命令* 是為了解決特定問題 -- 從一個列表中選擇文件。“不變的部分”是被調用的那個方法，而變化的部分被分離出來放到 *函數對象* 中。我認為 *命令模式* 在編碼階段提供了靈活性，而 *策略模式* 的靈活性在運行時才會體現出來。盡管如此，這種區別卻是非常模糊的。另外，*策略模式* 還可以添加一個“上下文（context）”，這個上下文（context）可以是一個代理類（surrogate class），用來控制對某個特定 *策略* 對象的選擇和使用。就像 *橋接模式* 一樣！下面我們來一探究竟： ```java // patterns/strategy/StrategyPattern.java // {java patterns.strategy.StrategyPattern} package patterns.strategy; import java.util.function.*; import java.util.*; // The common strategy base type: class FindMinima { Function<List<Double>, List<Double>> algorithm; } // The various strategies: class LeastSquares extends FindMinima { LeastSquares() { // Line is a sequence of points (Dummy data): algorithm = (line) -> Arrays.asList(1.1, 2.2); } } class Perturbation extends FindMinima { Perturbation() { algorithm = (line) -> Arrays.asList(3.3, 4.4); } } class Bisection extends FindMinima { Bisection() { algorithm = (line) -> Arrays.asList(5.5, 6.6); } } // The "Context" controls the strategy: class MinimaSolver { private FindMinima strategy; MinimaSolver(FindMinima strat) { strategy = strat; } List<Double> minima(List<Double> line) { return strategy.algorithm.apply(line); } void changeAlgorithm(FindMinima newAlgorithm) { strategy = newAlgorithm; } } public class StrategyPattern { public static void main(String[] args) { MinimaSolver solver = new MinimaSolver(new LeastSquares()); List<Double> line = Arrays.asList( 1.0, 2.0, 1.0, 2.0, -1.0, 3.0, 4.0, 5.0, 4.0 ); System.out.println(solver.minima(line)); solver.changeAlgorithm(new Bisection()); System.out.println(solver.minima(line)); } } /* Output: [1.1, 2.2] [5.5, 6.6] */ ``` `MinimaSolver` 中的 `changeAlgorithm()` 方法將一個不同的策略插入到了 `私有` 域 `strategy` 中，這使得在調用 `minima()` 方法時，可以使用新的策略。我們可以通過將上下文注入到 `FindMinima` 中來簡化我們的解決方法。 ```java // patterns/strategy/StrategyPattern2.java // {java patterns.strategy.StrategyPattern2} package patterns.strategy; import java.util.function.*; import java.util.*; // "Context" is now incorporated: class FindMinima2 { Function<List<Double>, List<Double>> algorithm; FindMinima2() { leastSquares(); } // default // The various strategies: void leastSquares() { algorithm = (line) -> Arrays.asList(1.1, 2.2); } void perturbation() { algorithm = (line) -> Arrays.asList(3.3, 4.4); } void bisection() { algorithm = (line) -> Arrays.asList(5.5, 6.6); } List<Double> minima(List<Double> line) { return algorithm.apply(line); } } public class StrategyPattern2 { public static void main(String[] args) { FindMinima2 solver = new FindMinima2(); List<Double> line = Arrays.asList( 1.0, 2.0, 1.0, 2.0, -1.0, 3.0, 4.0, 5.0, 4.0 ); System.out.println(solver.minima(line)); solver.bisection(); System.out.println(solver.minima(line)); } } /* Output: [1.1, 2.2] [5.5, 6.6] */ ``` `FindMinima2` 封裝了不同的算法，也包含了“上下文”（Context），所以它便可以在一個單獨的類中控制算法的選擇了。