Bruce Eckel：再聊设计模式（篇四）函数对象模式

本文主要是介绍Bruce Eckel：再聊设计模式（篇四）函数对象模式，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

Bruce Eckel

读完需要

分钟

速读仅需 1 分钟

布鲁斯 • 埃克尔（Bruce Eckel），C++ 标准委员会的创始成员之一，知名技术顾问，专注于编程语言和软件系统设计方面的研究，常活跃于世界各大顶级技术研讨会。
他自 1986 年以来，累计出版 Thinking in C++、Thinking in Java、On Java 等十余部经典计算机著作，曾多次荣获 Jolt 最佳图书奖（被誉为“软件业界的奥斯卡”），其代表作 Thinking in Java 被译为中文、日文、俄文、意大利文、波兰文、韩文等十几种语言，在世界范围内产生了广泛影响。

Bruce Eckel：再聊设计模式（篇一）设计模式分类

Bruce Eckel：再聊设计模式（篇二）封装实现

Bruce Eckel：再聊设计模式（篇三）工厂模式

函数对象模式

一个函数对象（Function Object）封装一个方法，其目的是将函数的选择和调用函数的位置解耦。

《设计模式》中对“函数对象”这个术语有所提及，但并未使用。不过函数对象的核心思想在该书的若干模式中反复出现过。

7.1

命令模式

这种模式是函数对象最纯粹的形式：一个身为对象的方法。将一个函数对象作为参数传递，它便会生成不同的行为。

命令（Command）模式在本书前面的若干地方描述过，主要包括以下几章：

基础卷第 11 章
基础卷第 19 章
进阶卷第 1 章

在下面这个示例中，show()的代码保持不变，改变的是传给 show()的 Comand 对象：

// patterns/CommandPattern.java
import java.util.*;class Command {public final String msg;public Command(String msg) {this.msg = msg;}
}public class CommandPattern {public static void show(Command cmd) {System.out.println(cmd.msg);}public static void main(String[] args) {show(new Command("First Command"));show(new Command("Second Command"));}
}
/* 输出：
First Command
Second Command
*/

下面是另一个示例，创建了一个命令对象的列表，形成了一个“宏指令”。在Java 8之前的版本中，如果要实现独立函数的效果，就需要额外的繁文缛节，显式地将方法包装到一个对象中。而Java 8的lambda表达式可以创建函数对象，因此命令模式就变得相当简单了：

// patterns/Macro.java
import java.util.*;public class Macro {public static void main(String[] args) {List<Runnable> macro = new ArrayList<>(Arrays.asList(() -> System.out.print("Hello "),() -> System.out.println("World! ")));macro.forEach(Runnable::run);macro.add(() -> System.out.print("I'm the command pattern!"));macro.forEach(Runnable::run);}
}
/* 输出：
Hello World!
Hello World!
I'm the command pattern!
*/

命令模式最主要的一点在于，可以让我们将想要的行为传给一个方法或对象。macro会将一组要集体执行的行为排成一队，这样就可以动态地创建行为了，而这本来一般都需要编写新的代码来实现。

Macro.java经过修改后，还可以用来解释脚本，参见解释器（Interpreter）模式。

《设计模式》中指出：“命令模式是回调的面向对象形式的替代品。”然而我认为“回”字是回调概念的核心本质。也就是说，回调实际上会指回到回调的创建者，命令模式则一般只将命令对象创建出来，然后传给某个方法或对象，而不会随着时间的推移（往回）连接到命令对象上。不过这只是我的个人看法。稍后我会将一组设计模式结合起来，放到本章8.10节中。

7.2

策略模式

策略模式（Strategy）看起来就像命令模式的同胞兄弟，都是从同一个基类继承出来的一组函数对象。区别在于这些对象的使用方式。命令模式用于解决一类特定的问题——例如，通过传入一个描述所需文件的命令对象，从文件列表中选择一个文件。所调用的方法体即“保持不变的事物”，而变化的部分则被隔离在命令对象中。

策略模式包含一段可作为代理类的“上下文”，该代理类用于控制文件的选择以及对特定策略对象的使用——和策略模式很像。它看起来就像下面这样：

// patterns/strategy/StrategyPattern.java
// {java patterns.strategy.StrategyPattern}
package patterns.strategy;
import java.util.function.*;
import java.util.*;// 公共策略基类：
class FindMinima {protectedFunction<List<Double>, List<Double>> algorithm;
}// 各种策略，每一个都会生成无意义的数据：
class LeastSquares extends FindMinima {LeastSquares() {// Line is a sequence of points:// 直线是点的序列：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);}
}// “上下文”控制着策略：
class MinimaSolver {private FindMinima strategy;MinimaSolver(FindMinima strategy) {this.strategy = strategy;}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 Perturbation());System.out.println(solver.minima(line));solver.changeAlgorithm(new Bisection());System.out.println(solver.minima(line));}
}
/* 输出：
[1.1, 2.2]
[3.3, 4.4]
[5.5, 6.6]
*/

MinimaSolver中的changeAlgorithm()将一个不同的策略插入strategy字段，然后minima()就会使用不同的算法了。

可以通过将上下文合并到FindMinima中来简化该方案：

// patterns/strategy/StrategyPattern2.java
// {java patterns.strategy.StrategyPattern2}
package patterns.strategy;
import java.util.function.*;
import java.util.*;// “上下文”现在合并了：
class FindMinima2 {privateFunction<List<Double>, List<Double>> algorithm;FindMinima2() { leastSquares(); } // 默认// 各种策略：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.perturbation();System.out.println(solver.minima(line));solver.bisection();System.out.println(solver.minima(line));}
}
/* 输出：
[1.1, 2.2]
[3.3, 4.4]
[5.5, 6.6]
*/

FindMinima2封装了各种不同的算法，现在还同时包含了上下文，因此可以在单个类中控制算法的选择了。

7.3

职责链模式

这种模式在本书第 1 章中介绍过。

职责链模式（Chain of Responsibility）大概可以被看作用策略对象实现的动态泛化版本的递归。先产生一个调用，然后一系列策略逐个尝试处理该调用。当某个策略处理成功，或者试过所有策略后（都不成功），整个过程结束。在递归过程中，一个方法不断重复调用自身，直到满足某个终结条件。而在职责链模式中，一个方法会调用相同基类的方法的不同实现，后者又会调用该基类方法的另一个实现，以此类推，直到满足终结条件。

不同于通过调用单个方法来处理请求，职责链中的多个方法都有机会处理该请求，因此职责链模式很适用于实现专家系统。职责链是高效的链表结构，因此可以动态地进行创建或修改。也可以将它看作一种更通用的、动态构建的 switch 语句。

你可能想让 StrategyPattern.java 自动尝试不同的算法，直到命中合适的那个。职责链模式提供了实现该功能的途径。Result 是包含一个 success 标签的信使，这样收件人就可以知道该算法是否成功，line 则用来承载实际的数据。如果某个算法失败，则返回 Result.fail：

// patterns/chain/Result.java
// 承载结果或表示失败
package patterns.chain;
import java.util.*;public class Result {public final boolean success;public final List<Double> line;public Result(List<Double> data) {success = true;line = data;}private Result() {success = false;line = Collections.<Double>emptyList();}public static final Result fail = new Result();
}

由于失败是预期结果，因此在某个策略失败时，返回Result.fail比抛出异常更加合适。

// patterns/chain/ChainOfResponsibility.java
// {java patterns.chain.ChainOfResponsibility}
package patterns.chain;
import java.util.*;
import java.util.function.*;interface Algorithm {Result algorithm(List<Double> line);
}class FindMinima {public static Result test(boolean success, String id, double d1, double d2) {System.out.println(id);if(success) // 实际的测试/计算：return new Result(Arrays.asList(d1, d2));else // 尝试职责链中的下一个：return Result.fail;}public static Result leastSquares(List<Double> line) {return test(false, "LeastSquares", 1.1, 2.2);}public static Result perturbation(List<Double> line) {return test(false, "Perturbation", 3.3, 4.4);}public static Result bisection(List<Double> line) {return test(true, "Bisection", 5.5, 6.6);}static List<Function<List<Double>, Result>>algorithms = Arrays.asList(FindMinima::leastSquares,FindMinima::perturbation,FindMinima::bisection);public static Result minima(List<Double> line) {for(Function<List<Double>, Result> alg :algorithms) {Result result = alg.apply(line);if(result.success)return result;}return Result.fail;}
}public class ChainOfResponsibility {public static void main(String[] args) {FindMinima solver = new FindMinima();List<Double> line = Arrays.asList(1.0, 2.0, 1.0, 2.0, -1.0,3.0, 4.0, 5.0, 4.0);Result result = solver.minima(line);if(result.success)System.out.println(result.line);elseSystem.out.println("No algorithm found");}
}
/* 输出：
LeastSquares
Perturbation
Bisection
[5.5, 6.6]
*/

每个Algorithm的实现针对algorithm()方法都有不同的方法。在FindMinima中，创建了一组algorithm的List（这便是职责链的那条“链”），而minima()方法会遍历该List，并找出执行成功的算法。