原文：Java Coding Problems 协议：CC BY-NC-SA 4.0 贡献者：飞龙 本文来自【ApacheCN Java 译文集】，自豪地采用谷歌翻译。
本章包括 11 个涉及 Java 函数式编程的问题。我们将从一个问题开始，这个问题旨在提供从 0 到函数式接口的完整过程。然后，我们将继续研究 GoF 中的一套设计模式，我们将用 Java 函数风格来解释这些模式。
在本章结束时，您应该熟悉函数式编程，并准备好继续处理一组问题，这些问题允许我们深入研究这个主题。您应该能够使用一堆以函数式风格编写的常用设计模式，并且非常了解如何开发代码以利用函数式接口。
问题
使用以下问题来测试您的函数式编程能力。我强烈建议您在使用解决方案和下载示例程序之前，先尝试一下每个问题：
- “编写函数式接口”：编写一个程序，通过一组有意义的例子定义从 0 到函数式接口的路径。
- Lambda 概述：解释什么是 Lambda 表达式。
- 实现环绕执行模式：基于 Lambda 编写实现环绕执行模式的程序。
- 实现工厂模式：基于 Lambda 编写一个实现工厂模式的程序。
- 实现策略模式：基于 Lambda 编写一个实现策略模式的程序。
- 实现模板方法模式：基于 Lambda 编写一个实现模板方法模式的程序。
- 实现观察者模式：基于 Lambda 编写一个实现观察者模式的程序。
- 实现借贷模式：基于 Lambda 编写实现借贷模式的程序。
- 实现装饰器模式：基于 Lambda 编写一个实现装饰器模式的程序。
- 实现级联生成器模式：基于 Lambda 编写一个实现级联生成器模式的程序。
- 实现命令模式：基于 Lambda 编写一个实现命令模式的程序。
以下各节介绍上述问题的解决方案。记住，通常没有一个正确的方法来解决一个特定的问题。另外，请记住，这里显示的解释仅包括解决这些问题所需的最有趣和最重要的细节。您可以下载示例解决方案以查看更多详细信息并尝试程序。
166 编写函数式接口
在这个解决方案中，我们将强调函数式接口的用途和可用性，并与几种替代方案进行比较。我们将研究如何将代码从基本的、严格的实现发展到基于函数式接口的灵活实现。为此，让我们考虑以下Melon类：
public class Melon {
private final String type;
private final int weight;
private final String origin;
public Melon(String type, int weight, String origin) {
this.type = type;
this.weight = weight;
this.origin = origin;
}
// getters, toString(), and so on omitted for brevity
}假设我们有一个客户——我们叫他马克——他想开一家卖瓜的公司。我们根据他的描述塑造了前面的类。他的主要目标是拥有一个库存应用来支持他的想法和决策，因此需要创建一个必须基于业务需求和发展的应用。我们将在下面几节中查看每天开发此应用所需的时间。
第 1 天（按瓜的类型过滤）
有一天，马克让我们提供一个功能，可以按瓜的类型过滤瓜。因此，我们创建了一个名为Filters的工具类，并实现了一个static方法，该方法将瓜列表和要过滤的类型作为参数。
得到的方法非常简单：
代码语言：javascript复制public static List<Melon> filterByType(
List<Melon> melons, String type) {
List<Melon> result = new ArrayList<>();
for (Melon melon: melons) {
if (melon != null && type.equalsIgnoreCase(melon.getType())) {
result.add(melon);
}
}
return result;
}完成！现在，我们可以很容易地按类型过滤西瓜，如下例所示：
代码语言：javascript复制List<Melon> bailans = Filters.filterByType(melons, "Bailan");第 2 天（过滤一定重量的瓜）
虽然马克对结果很满意，但他要求另一个过滤器来获得一定重量的瓜（例如，所有 1200 克的瓜）。我们刚刚对甜瓜类型实现了这样一个过滤器，因此我们可以为一定重量的甜瓜提出一个新的static方法，如下所示：
public static List<Melon> filterByWeight(
List<Melon> melons, int weight) {
List<Melon> result = new ArrayList<>();
for (Melon melon: melons) {
if (melon != null && melon.getWeight() == weight) {
result.add(melon);
}
}
return result;
}这与filterByType()类似，只是它有不同的条件/过滤器。作为开发人员，我们开始明白，如果我们继续这样做，Filters类最终会有很多方法，这些方法只是重复代码并使用不同的条件。我们非常接近一个样板代码案例。
第 3 天（按类型和重量过滤瓜）
事情变得更糟了。马克现在要求我们添加一个新的过滤器，按类型和重量过滤西瓜，他需要这个很快。然而，最快的实现是最丑陋的。过来看：
代码语言：javascript复制public static List<Melon> filterByTypeAndWeight(
List<Melon> melons, String type, int weight) {
List<Melon> result = new ArrayList<>();
for (Melon melon: melons) {
if (melon != null && type.equalsIgnoreCase(melon.getType())
&& melon.getWeight() == weight) {
result.add(melon);
}
}
return result;
}在我们的情况下，这是不可接受的。如果我们在这里添加一个新的过滤条件，代码将变得很难维护并且容易出错。
第 4 天（将行为作为参数）
会议时间到了！我们不能继续像这样添加更多的过滤器；我们能想到的每一个属性的过滤器最终都会出现在一个巨大的Filters类中，这个类有大量复杂的方法，其中包含太多的参数和大量的样板代码。
主要的问题是我们在样板代码中有不同的行为。因此，只编写一次样板代码并将行为作为一个参数来推送是很好的。这样，我们就可以将任何选择条件/标准塑造成行为，并根据需要对它们进行处理。代码将变得更加清晰、灵活、易于维护，并且具有更少的参数。
这被称为行为参数化，如下图所示（左侧显示我们现在拥有的；右侧显示我们想要的）：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kLSlKwKL-1657284745693)(https://github.com/apachecn/apachecn-java-zh/raw/master/docs/java-coding-prob/img/11024e3c-1a23-4e17-a15b-f2e9060caada.png)]
如果我们将每个选择条件/标准看作一种行为，那么将每个行为看作一个接口的实现是非常直观的。基本上，所有这些行为都有一个共同点——选择条件/标准和返回boolean类型（这被称为谓词）。在接口的上下文中，这是一个可以按如下方式编写的合同：
public interface MelonPredicate {
boolean test(Melon melon);
}此外，我们可以编写MelonPredicate的不同实现。例如，过滤Gac瓜可以这样写：
public class GacMelonPredicate implements MelonPredicate {
@Override
public boolean test(Melon melon) {
return "gac".equalsIgnoreCase(melon.getType());
}
}或者，过滤所有重量超过 5000 克的西瓜可以写：
代码语言：javascript复制public class HugeMelonPredicate implements MelonPredicate {
@Override
public boolean test(Melon melon) {
return melon.getWeight() > 5000;
}
}这种技术有一个名字——策略设计模式。根据 GoF 的说法，这可以“定义一系列算法，封装每个算法，并使它们可以互换。策略模式允许算法在客户端之间独立变化”。
因此，主要思想是在运行时动态选择算法的行为。MelonPredicate接口统一了所有用于选择西瓜的算法，每个实现都是一个策略。
目前，我们有策略，但没有任何方法接收到一个MelonPredicate参数。我们需要一个filterMelons()方法，如下图所示：
所以，我们需要一个参数和多个行为。让我们看看filterMelons()的源代码：
public static List<Melon> filterMelons(
List<Melon> melons, MelonPredicate predicate) {
List<Melon> result = new ArrayList<>();
for (Melon melon: melons) {
if (melon != null && predicate.test(melon)) {
result.add(melon);
}
}
return result;
}这样好多了！我们可以通过以下不同的行为重用此方法（这里，我们传递GacMelonPredicate和HugeMelonPredicate：
List<Melon> gacs = Filters.filterMelons(
melons, new GacMelonPredicate());
List<Melon> huge = Filters.filterMelons(
melons, new HugeMelonPredicate());第 5 天（实现另外 100 个过滤器）
马克要求我们再安装 100 个过滤器。这一次，我们有足够的灵活性和支持来完成这项任务，但是我们仍然需要为每个选择标准编写 100 个实现MelonPredicate的策略或类。此外，我们必须创建这些策略的实例，并将它们传递给filterMelons()方法。
这意味着大量的代码和时间。为了保存这两者，我们可以依赖 Java 匿名类。换句话说，同时声明和实例化没有名称的类将导致如下结果：
代码语言：javascript复制List<Melon> europeans = Filters.filterMelons(
melons, new MelonPredicate() {
@Override
public boolean test(Melon melon) {
return "europe".equalsIgnoreCase(melon.getOrigin());
}
});在这方面取得了一些进展，但这并不是很重要，因为我们仍然需要编写大量代码。检查下图中突出显示的代码（此代码对每个实现的行为重复）：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VvKKN3tu-1657284745695)(https://github.com/apachecn/apachecn-java-zh/raw/master/docs/java-coding-prob/img/3b1ba54b-775c-46c8-8948-7c4970e96d1c.png)]
在这里，代码不友好。匿名类看起来很复杂，而且它们看起来有些不完整和奇怪，特别是对新手来说。
第 6 天（匿名类可以写成 Lambda）
新的一天，新的想法！任何智能 IDE 都可以为我们指明前进的道路。例如，NetbeansIDE 将不连续地警告我们，这个匿名类可以作为 Lambda 表达式编写。
如以下屏幕截图所示：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fZAx0nTz-1657284745696)(https://github.com/apachecn/apachecn-java-zh/raw/master/docs/java-coding-prob/img/016979a0-1499-49a3-ae48-f83e60f74e31.png)]
这个消息非常清楚——这个匿名的内部类创建可以转换成 Lambda 表达式。在这里，手工进行转换，或者让 IDE 为我们做。
结果如下：
代码语言：javascript复制List<Melon> europeansLambda = Filters.filterMelons(
melons, m -> "europe".equalsIgnoreCase(m.getOrigin()));这样好多了！Java8Lambda 表达式这次做得很好。现在，我们可以以更灵活、快速、干净、可读和可维护的方式编写马克的过滤器。
第 7 天（抽象列表类型）
马克第二天带来了一些好消息——他将扩展业务，销售其他水果和瓜类。这很酷，但是我们的谓词只支持Melon实例。
那么，我们应该如何继续支持其他水果呢？还有多少水果？如果马克决定开始销售另一类产品，如蔬菜，该怎么办？我们不能简单地为它们中的每一个创建谓词。这将带我们回到起点。
显而易见的解决方案是抽象List类型。我们首先定义一个新接口，这次将其命名为Predicate（从名称中删除Melon）：
@FunctionalInterface
public interface Predicate<T> {
boolean test(T t);
}接下来，我们覆盖filterMelons()方法并将其重命名为filter()：
public static <T> List<T> filter(
List<T> list, Predicate<T> predicate) {
List<T> result = new ArrayList<>();
for (T t: list) {
if (t != null && predicate.test(t)) {
result.add(t);
}
}
return result;
}现在，我们可以为Melon编写过滤器：
List<Melon> watermelons = Filters.filter(
melons, (Melon m) -> "Watermelon".equalsIgnoreCase(m.getType()));我们也可以对数字做同样的处理：
代码语言：javascript复制List<Integer> numbers = Arrays.asList(1, 13, 15, 2, 67);
List<Integer> smallThan10 = Filters
.filter(numbers, (Integer i) -> i < 10);退后一步，看看我们的起点和现在。由于 Java8 函数式接口和 Lambda 表达式，这种差异是巨大的。你注意到Predicate接口上的@FunctionalInterface注解了吗？好吧，这是一个信息注释类型，用于标记函数式接口。如果标记的接口不起作用，则发生错误是很有用的。
从概念上讲，函数式接口只有一个抽象方法。此外，我们定义的Predicate接口已经作为java.util.function.Predicate接口存在于 Java8 中。java.util.function包包含 40 多个这样的接口。因此，在定义一个新的包之前，最好检查这个包的内容。大多数情况下，六个标准的内置函数式接口就可以完成这项工作。具体如下：
Predicate<T>Consumer<T>Supplier<T>Function<T, R>UnaryOperator<T>BinaryOperator<T>
函数式接口和 Lambda 表达式是一个很好的团队。Lambda 表达式支持直接内联实现函数式接口的抽象方法。基本上，整个表达式被视为函数式接口的具体实现的实例，如以下代码所示：
代码语言：javascript复制Predicate<Melon> predicate = (Melon m)
-> "Watermelon".equalsIgnoreCase(m.getType());167 Lambda 简述
剖析 Lambda 表达式将显示三个主要部分，如下图所示：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3SkumBq3-1657284745697)(https://github.com/apachecn/apachecn-java-zh/raw/master/docs/java-coding-prob/img/7239e25b-eb5c-4b10-b5ed-978a5d2312e9.png)]
以下是 Lambda 表达式每个部分的说明：
- 在箭头的左侧，我们有 Lambda 主体中使用的参数。这些是
FilenameFilter.accept(File folder, String fileName)方法的参数。 - 在箭头的右侧，我们有 Lambda 主体，在本例中，它检查找到文件的文件夹是否可以读取，以及文件名是否以
.pdf后缀结尾。 - 箭头只是 Lambda 参数和主体的分隔符。
此 Lambda 的匿名类版本如下所示：
代码语言：javascript复制FilenameFilter filter = new FilenameFilter() {
@Override
public boolean accept(File folder, String fileName) {
return folder.canRead() && fileName.endsWith(".pdf");
}
};现在，如果我们看 Lambda 和它的匿名版本，那么我们可以得出结论，Lambda 表达式是一个简明的匿名函数，可以作为参数传递给方法或保存在变量中。我们可以得出结论，Lambda 表达式可以根据下图中所示的四个单词来描述：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GzCNamau-1657284745698)(https://github.com/apachecn/apachecn-java-zh/raw/master/docs/java-coding-prob/img/5f6de777-d9b2-4335-a7b3-36e5af1eb30d.png)]
Lambda 支持行为参数化，这是一个很大的优点（查看前面的问题以获得对此的详细解释）。最后，请记住 Lambda 只能在函数式接口的上下文中使用。
168 实现环绕执行模式
环绕执行模式试图消除围绕特定任务的样板代码。例如，为了打开和关闭文件，特定于文件的任务需要被代码包围。
主要地，环绕执行模式在暗示在资源的开-关生命周期内发生的任务的场景中很有用。例如，假设我们有一个Scanner，我们的第一个任务是从文件中读取一个double值：
try (Scanner scanner = new Scanner(
Path.of("doubles.txt"), StandardCharsets.UTF_8)) {
if (scanner.hasNextDouble()) {
double value = scanner.nextDouble();
}
}稍后，另一项任务包括打印所有double值：
try (Scanner scanner = new Scanner(
Path.of("doubles.txt"), StandardCharsets.UTF_8)) {
while (scanner.hasNextDouble()) {
System.out.println(scanner.nextDouble());
}
}下图突出了围绕这两项任务的样板代码：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VTncnQyP-1657284745699)(https://github.com/apachecn/apachecn-java-zh/raw/master/docs/java-coding-prob/img/9c5cc105-bad6-40a4-9334-0ea4aac81b72.png)]
为了避免这个样板代码，环绕执行模式依赖于行为参数化（在“编写函数式接口”一节中进一步详细说明）。实现这一点所需的步骤如下：
- 第一步是定义一个与
Scanner -> double签名匹配的函数式接口，该接口可能抛出一个IOException：
@FunctionalInterface
public interface ScannerDoubleFunction {
double readDouble(Scanner scanner) throws IOException;
}声明函数式接口只是解决方案的一半。
- 到目前为止，我们可以编写一个
Scanner -> double类型的 Lambda，但是我们需要一个接收并执行它的方法。为此，让我们考虑一下Doubles工具类中的以下方法：
public static double read(ScannerDoubleFunction snf)
throws IOException {
try (Scanner scanner = new Scanner(
Path.of("doubles.txt"), StandardCharsets.UTF_8)) {
return snf.readDouble(scanner);
}
}传递给read()方法的 Lambda 在这个方法的主体中执行。当我们传递 Lambda 时，我们提供了一个称为直接内联的abstract方法的实现。主要是作为函数式接口ScannerDoubleFunction的一个实例，因此我们可以调用readDouble()方法来获得期望的结果。
- 现在，我们可以简单地将任务作为 Lambda 传递并重用
read()方法。例如，我们的任务可以包装在两个static方法中，如图所示（这种做法是为了获得干净的代码并避免大 Lambda）：
private static double getFirst(Scanner scanner) {
if (scanner.hasNextDouble()) {
return scanner.nextDouble();
}
return Double.NaN;
}
private static double sumAll(Scanner scanner) {
double sum = 0.0d;
while (scanner.hasNextDouble()) {
sum = scanner.nextDouble();
}
return sum;
}- 以这两个任务为例，我们还可以编写其他任务。让我们把它们传递给
read()方法：
double singleDouble
= Doubles.read((Scanner sc) -> getFirst(sc));
double sumAllDoubles
= Doubles.read((Scanner sc) -> sumAll(sc));环绕执行模式对于消除特定于打开和关闭资源（I/O 操作）的样板代码非常有用。
169 实现工厂模式
简而言之，工厂模式允许我们创建多种对象，而无需向调用者公开实例化过程。通过这种方式，我们可以隐藏创建对象的复杂和/或敏感过程，并向调用者公开直观且易于使用的对象工厂
在经典实现中，工厂模式依赖于实习生switch()，如下例所示：
public static Fruit newInstance(Class<?> clazz) {
switch (clazz.getSimpleName()) {
case "Gac":
return new Gac();
case "Hemi":
return new Hemi();
case "Cantaloupe":
return new Cantaloupe();
default:
throw new IllegalArgumentException(
"Invalid clazz argument: " clazz);
}
}这里，Gac、Hemi、Cantaloupe实现相同的Fruit接口，并有空构造器。如果该方法生活在名为MelonFactory的实用类中，则可以调用如下：
Gac gac = (Gac) MelonFactory.newInstance(Gac.class);但是，Java8 函数样式允许我们使用方法引用技术引用构造器。这意味着我们可以定义一个Supplier<Fruit>来引用Gac空构造器，如下所示：
Supplier<Fruit> gac = Gac::new;那么Hemi、Cantaloupe等呢？好吧，我们可以简单地把它们都放在一个Map中（注意这里没有实例化甜瓜类型；它们只是懒惰的方法引用）：
private static final Map<String, Supplier<Fruit>> MELONS
= Map.of("Gac", Gac::new, "Hemi", Hemi::new,
"Cantaloupe", Cantaloupe::new);此外，我们可以覆盖newInstance()方法来使用这个映射：
public static Fruit newInstance(Class<?> clazz) {
Supplier<Fruit> supplier = MELONS.get(clazz.getSimpleName());
if (supplier == null) {
throw new IllegalArgumentException(
"Invalid clazz argument: " clazz);
}
return supplier.get();
}调用方代码不需要进一步修改：
代码语言：javascript复制Gac gac = (Gac) MelonFactory.newInstance(Gac.class);然而，很明显，构造器并不总是空的。例如，下面的Melon类公开了一个具有三个参数的构造器：
public class Melon implements Fruit {
private final String type;
private final int weight;
private final String color;
public Melon(String type, int weight, String color) {
this.type = type;
this.weight = weight;
this.color = color;
}
}无法通过空构造器获取创建此类的实例。但如果我们定义了一个支持三个参数和一个返回的函数式接口，那么我们就回到了正轨：
代码语言：javascript复制@FunctionalInterface
public interface TriFunction<T, U, V, R> {
R apply(T t, U u, V v);
}这一次，下面的语句将尝试获取具有三个参数的构造器，这三个参数分别是String、Integer和String类型：
private static final
TriFunction<String, Integer, String, Melon> MELON = Melon::new;专门为Melon类制作的newInstance()方法是：
public static Fruit newInstance(
String name, int weight, String color) {
return MELON.apply(name, weight, name);
}一个Melon实例可以创建如下：
Melon melon = (Melon) MelonFactory.newInstance("Gac", 2000, "red");完成！现在，我们有一个工厂的Melon通过函数式接口。
170 实现策略模式
经典的策略模式非常简单。它由一个表示一系列算法（策略）的接口和该接口的几个实现（每个实现都是一个策略）组成。
例如，以下接口统一了从给定字符串中删除字符的策略：
代码语言：javascript复制public interface RemoveStrategy {
String execute(String s);
}首先，我们将定义从字符串中删除数值的策略：
代码语言：javascript复制public class NumberRemover implements RemoveStrategy {
@Override
public String execute(String s) {
return s.replaceAll("\d", "");
}
}然后，我们将定义一种从字符串中删除空格的策略：
代码语言：javascript复制public class WhitespacesRemover implements RemoveStrategy {
@Override
public String execute(String s) {
return s.replaceAll("\s", "");
}
}最后，让我们定义一个工具类作为策略的入口点：
代码语言：javascript复制public final class Remover {
private Remover() {
throw new AssertionError("Cannot be instantiated");
}
public static String remove(String s, RemoveStrategy strategy) {
return strategy.execute(s);
}
}这是一个简单而经典的策略模式实现。如果要从字符串中删除数值，可以按以下操作：
代码语言：javascript复制String text = "This is a text from 20 April 2050";
String noNr = Remover.remove(text, new NumberRemover());但是我们真的需要NumberRemover和WhitespacesRemover类吗？我们是否需要为进一步的策略编写类似的类？显然，答案是否定的。
再次查看我们的接口：
代码语言：javascript复制@FunctionalInterface
public interface RemoveStrategy {
String execute(String s);
}我们刚刚添加了@FunctionalInterface提示，因为RemoveStrategy接口定义了一个抽象方法，所以它是一个函数式接口。
我们可以在函数式接口的上下文中使用什么？嗯，显而易见的答案是兰巴斯。此外，在这种情况下，Lambda 能为我们做些什么？它可以删除样板文件代码（在本例中是表示策略的类），并将策略封装在其主体中：
代码语言：javascript复制String noNr = Remover.remove(text, s -> s.replaceAll("\d", ""));
String noWs = Remover.remove(text, s -> s.replaceAll("\s", ""));所以，这就是通过 Lambda 的策略模式。
171 实现模板方法模式
模板方法是 GoF 的一个经典设计模式，它允许我们在方法中编写一个算法的框架，并将该算法的某些步骤推迟到客户端子类。
例如，做比萨饼需要三个主要步骤——准备面团、添加配料和烘烤比萨饼。虽然第一步和最后一步对于所有比萨饼来说都是相同的（固定步骤），但是对于每种比萨饼来说，第二步是不同的（可变步骤）。
如果我们通过模板方法模式将其放入代码中，那么我们会得到如下结果（方法make()表示模板方法，并以明确定义的顺序包含固定和可变的步骤）：
public abstract class PizzaMaker {
public void make(Pizza pizza) {
makeDough(pizza);
addTopIngredients(pizza);
bake(pizza);
}
private void makeDough(Pizza pizza) {
System.out.println("Make dough");
}
private void bake(Pizza pizza) {
System.out.println("Bake the pizza");
}
public abstract void addTopIngredients(Pizza pizza);
}固定步骤有默认实现，而可变步骤由一个名为addTopIngredients()的abstract方法表示。这个方法是由这个类的子类实现的。例如，那不勒斯比萨饼的抽象形式如下：
public class NeapolitanPizza extends PizzaMaker {
@Override
public void addTopIngredients(Pizza p) {
System.out.println("Add: fresh mozzarella, tomatoes,
basil leaves, oregano, and olive oil ");
}
}另一方面，希腊披萨将如下：
代码语言：javascript复制public class GreekPizza extends PizzaMaker {
@Override
public void addTopIngredients(Pizza p) {
System.out.println("Add: sauce and cheese");
}
}因此，每种类型的披萨都需要一个新类来覆盖addTopIngredients()方法。最后，我们可以这样做比萨饼：
Pizza nPizza = new Pizza();
PizzaMaker nMaker = new NeapolitanPizza();
nMaker.make(nPizza);这种方法的缺点在于样板文件代码和冗长。但是，我们可以通过 Lambda 解决这个缺点。我们可以将模板方法的可变步骤表示为 Lambda 表达式。根据具体情况，我们必须选择合适的函数式接口。在我们的情况下，我们可以依赖于Consumer，如下所示：
public class PizzaLambda {
public void make(Pizza pizza, Consumer<Pizza> addTopIngredients) {
makeDough(pizza);
addTopIngredients.accept(pizza);
bake(pizza);
}
private void makeDough(Pizza p) {
System.out.println("Make dough");
}
private void bake(Pizza p) {
System.out.println("Bake the pizza");
}
}这一次，不需要定义子类（不需要有NeapolitanPizza、GreekPizza或其他）。我们只是通过 Lambda 表达式传递变量step。让我们做一个西西里比萨饼：
Pizza sPizza = new Pizza();
new PizzaLambda().make(sPizza, (Pizza p)
-> System.out.println("Add: bits of tomato, onion,
anchovies, and herbs "));完成！不再需要样板代码。Lambda 解决方案大大改进了解决方案。
172 实现观察者模式
简言之，观察者模式依赖于一个对象（称为主体），当某些事件发生时，该对象会自动通知其订户（称为观察者）。
例如，消防站总部可以是主体，地方消防站可以是观察者。火灾发生后，消防局总部通知所有当地消防局，并向他们发送火灾发生的地址。每个观察者分析接收到的地址，并根据不同的标准决定是否灭火。
所有本地消防站通过一个名为FireObserver的接口进行分组。此方法定义一个由消防站指挥部调用的抽象方法（主体）：
public interface FireObserver {
void fire(String address);
}各地方消防站（观察者）实现此接口，并在fire()实现中决定是否灭火。在这里，我们有三个本地站（Brookhaven、Vinings和Decatur）：
public class BrookhavenFireStation implements FireObserver {
@Override
public void fire(String address) {
if (address.contains("Brookhaven")) {
System.out.println(
"Brookhaven fire station will go to this fire");
}
}
}
public class ViningsFireStation implements FireObserver {
// same code as above for ViningsFireStation
}
public class DecaturFireStation implements FireObserver {
// same code as above for DecaturFireStation
}一半的工作完成了！现在，我们需要注册这些观察者，由接收器通知。也就是说，每个地方消防站都需要注册为消防站总部的观察者（主体）。为此，我们声明了另一个接口，它定义了主体合同，用于注册和通知其观察者：
代码语言：javascript复制public interface FireStationRegister {
void registerFireStation(FireObserver fo);
void notifyFireStations(String address);
}最后，我们可以写消防站指挥部（主体）：
代码语言：javascript复制public class FireStation implements FireStationRegister {
private final List<FireObserver> fireObservers = new ArrayList<>();
@Override
public void registerFireStation(FireObserver fo) {
if (fo != null) {
fireObservers.add(fo);
}
}
@Override
public void notifyFireStations(String address) {
if (address != null) {
for (FireObserver fireObserver: fireObservers) {
fireObserver.fire(address);
}
}
}
}现在，让我们把我们的三个本地站（观察者）登记到消防站总部（主体）：
代码语言：javascript复制FireStation fireStation = new FireStation();
fireStation.registerFireStation(new BrookhavenFireStation());
fireStation.registerFireStation(new DecaturFireStation());
fireStation.registerFireStation(new ViningsFireStation());现在，当发生火灾时，消防局总部将通知所有注册的当地消防局：
代码语言：javascript复制fireStation.notifyFireStations(
"Fire alert: WestHaven At Vinings 5901 Suffex Green Ln Atlanta");观察者模式在那里成功实现。
这是样板代码的另一个经典案例。每个地方消防站都需要一个新的类和实现fire()方法。
不过，兰博达斯可以再次帮助我们！查看FireObserver接口。它只有一个抽象方法；因此，这是一个函数式接口：
@FunctionalInterface
public interface FireObserver {
void fire(String address);
}这个函数式接口是Fire.registerFireStation()方法的一个参数。在此上下文中，我们可以将 Lambda 传递给此方法，而不是本地消防站的新实例。Lambda 将在其主体中包含行为；因此，我们可以删除本地站类并依赖 Lambda，如下所示：
fireStation.registerFireStation((String address) -> {
if (address.contains("Brookhaven")) {
System.out.println(
"Brookhaven fire station will go to this fire");
}
});
fireStation.registerFireStation((String address) -> {
if (address.contains("Vinings")) {
System.out.println("Vinings fire station will go to this fire");
}
});
fireStation.registerFireStation((String address) -> {
if (address.contains("Decatur")) {
System.out.println("Decatur fire station will go to this fire");
}
});完成！不再有样板代码。
173 实现借贷模式
在这个问题上，我们将讨论如何实现借贷模式。假设我们有一个包含三个数字的文件（比如说，double），每个数字都是一个公式的系数。例如，数字x、y、z是以下两个公式的系数：x y - z和x - y * sqrt(z)。同样的，我们也可以写出其他的公式。
在这一点上，我们有足够的经验来认识到这个场景听起来很适合行为参数化。这一次，我们没有定义自定义函数式接口，而是使用一个名为Function<T, R>的内置函数式接口。此函数式接口表示接受一个参数并生成结果的函数。其抽象方法的签名为R apply(T t)。
这个函数式接口成为一个static方法的参数，该方法旨在实现借贷模式。让我们把这个方法放在一个名为Formula的类中：
public class Formula {
...
public static double compute(
Function<Formula, Double> f) throws IOException {
...
}
}注意，compute()方法在Formula类中声明时接受Formula -> Double类型的 Lambda。让我们来展示一下compute()的全部源代码：
public static double compute(
Function<Formula, Double> f) throws IOException {
Formula formula = new Formula();
double result = 0.0 d;
try {
result = f.apply(formula);
} finally {
formula.close();
}
return result;
}这里应该强调三点。首先，当我们创建一个新的Formula实例时，我们实际上在我们的文件中打开了一个新的Scanner（检查这个类的private构造器）：
public class Formula {
private final Scanner scanner;
private double result;
private Formula() throws IOException {
result = 0.0 d;
scanner = new Scanner(
Path.of("doubles.txt"), StandardCharsets.UTF_8);
}
...
}第二，当我们执行 Lambda 时，我们实际上是在调用Formula的实例链方法来执行计算（应用公式）。每个方法都返回当前实例。应该调用的实例方法在 Lambda 表达式的主体中定义。
我们只需要以下计算，但可以添加更多计算：
代码语言：javascript复制public Formula add() {
if (scanner.hasNextDouble()) {
result = scanner.nextDouble();
}
return this;
}
public Formula minus() {
if (scanner.hasNextDouble()) {
result -= scanner.nextDouble();
}
return this;
}
public Formula multiplyWithSqrt() {
if (scanner.hasNextDouble()) {
result *= Math.sqrt(scanner.nextDouble());
}
return this;
}由于计算结果（公式）是一个double，我们需要提供一个终端方法，返回最终结果：
public double result() {
return result;
}最后，我们关闭Scanner并重置结果。这在private close()方法中发生：
private void close() {
try (scanner) {
result = 0.0 d;
}
}这些片段已经粘在一个名为Formula的类下与本书捆绑在一起的代码中。
你还记得我们的公式吗？我们有x y - z和x - y * sqrt(z)。第一个可以写如下：
double xPlusYMinusZ = Formula.compute((sc)
-> sc.add().add().minus().result());第二个公式如下：
代码语言：javascript复制double xMinusYMultiplySqrtZ = Formula.compute((sc)
-> sc.add().minus().multiplyWithSqrt().result());注意，我们可以专注于我们的公式，而不必费心打开和关闭文件。此外，流利的 API 允许我们形成任何公式，并且很容易用更多的操作来丰富它。
174 实现装饰器模式
装饰器模式更喜欢组合而不是继承；因此，它是子类化技术的优雅替代方案。因此，我们主要从基本对象开始，以动态方式添加其他特性。
例如，我们可以用这个图案来装饰蛋糕。装饰过程并没有改变蛋糕本身——它只是添加了一些坚果、奶油、水果等。
下图说明了我们将实现的功能：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qDIObyko-1657284745700)(https://github.com/apachecn/apachecn-java-zh/raw/master/docs/java-coding-prob/img/66d6e3a6-9a8e-4fe1-8a4e-e0266d3ec7ce.png)]
首先，我们创建一个名为Cake的接口：
public interface Cake {
String decorate();
}然后，我们通过BaseCake实现这个接口：
public class BaseCake implements Cake {
@Override
public String decorate() {
return "Base cake ";
}
}之后，我们为这个Cake创建一个抽象的CakeDecorator类。这个类的主要目标是调用给定的Cake的decorate()方法：
public class CakeDecorator implements Cake {
private final Cake cake;
public CakeDecorator(Cake cake) {
this.cake = cake;
}
@Override
public String decorate() {
return cake.decorate();
}
}下一步，我们重点写我们的装饰。
每个装饰器扩展CakeDecorator并修改decorate()方法来添加相应的装饰。
例如，Nuts装饰器如下所示：
public class Nuts extends CakeDecorator {
public Nuts(Cake cake) {
super(cake);
}
@Override
public String decorate() {
return super.decorate() decorateWithNuts();
}
private String decorateWithNuts() {
return "with Nuts ";
}
}为了简洁起见，我们跳过了Cream修饰符。然而，凭直觉很容易看出这个装饰器与Nuts基本相同。
同样，我们有一些样板代码。
现在，我们可以创建一个用坚果和奶油装饰的Cake，如下所示：
Cake cake = new Nuts(new Cream(new BaseCake()));
// Base cake with Cream with Nuts
System.out.println(cake.decorate());因此，这是装饰器模式的一个经典实现。现在，让我们来看一看基于 Lambda 的实现，它大大减少了代码。尤其是当我们有大量的装饰师时。
这次我们将Cake接口转换成一个类，如下所示：
public class Cake {
private final String decorations;
public Cake(String decorations) {
this.decorations = decorations;
}
public Cake decorate(String decoration) {
return new Cake(getDecorations() decoration);
}
public String getDecorations() {
return decorations;
}
}这里的高潮是decorate()方法。这种方法主要是将给定的装饰应用到现有装饰的旁边，并返回一个新的Cake。
作为另一个例子，让我们考虑一下java.awt.Color类，它有一个名为brighter()的方法。这个方法创建了一个新的Color，它是当前Color的一个更亮的版本。类似地，decorate()方法创建了一个新的Cake，它是当前Cake的一个更加修饰的版本。
此外，不需要将装饰器作为单独的类来编写。我们将依靠 Lambda 将装饰人员传递给CakeDecorator：
public class CakeDecorator {
private Function<Cake, Cake> decorator;
public CakeDecorator(Function<Cake, Cake>... decorations) {
reduceDecorations(decorations);
}
public Cake decorate(Cake cake) {
return decorator.apply(cake);
}
private void reduceDecorations(
Function<Cake, Cake>... decorations) {
decorator = Stream.of(decorations)
.reduce(Function.identity(), Function::andThen);
}
}这个类主要完成两件事：
- 在构造器中，它调用
reduceDecorations()方法。此方法将通过Stream.reduce()和Function.andThen()方法链接传递的Function数组。结果是由给定的Function数组组成的单个Function。 - 当组合的
Function的apply()方法从decorate()方法调用时，它将逐一应用给定函数的链。由于给定数组中的每一个Function都是一个修饰符，因此合成的Function将逐个应用每个修饰符。
让我们创建一个Cake用坚果和奶油装饰：
CakeDecorator nutsAndCream = new CakeDecorator(
(Cake c) -> c.decorate(" with Nuts"),
(Cake c) -> c.decorate(" with Cream"));
Cake cake = nutsAndCream.decorate(new Cake("Base cake"));
// Base cake with Nuts with Cream
System.out.println(cake.getDecorations());完成！考虑运行本书附带的代码来检查输出。
175 实现级联生成器模式
我们已经在第 2 章、“对象、不变性和switch表达式”中讨论过这个模式，“通过构建器模式编写一个不可变类”部分。处理这个问题是明智的，就像快速提醒构建器模式一样。
在我们的工具带下面有一个经典的生成器，假设我们想编写一个传递包裹的类。主要是设置收件人的名字、姓氏、地址和包裹内容，然后交付包裹。
我们可以通过构建器模式和 Lambda 实现这一点，如下所示：
代码语言：javascript复制public final class Delivery {
public Delivery firstname(String firstname) {
System.out.println(firstname);
return this;
}
//similar for lastname, address and content
public static void deliver(Consumer<Delivery> parcel) {
Delivery delivery = new Delivery();
parcel.accept(delivery);
System.out.println("nDone ...");
}
}对于递送包裹，我们只需使用 Lambda：
代码语言：javascript复制Delivery.deliver(d -> d.firstname("Mark")
.lastname("Kyilt")
.address("25 Street, New York")
.content("10 books"));显然，Consumer<Delivery>参数有助于使用 Lambda。
176 实现命令模式
简而言之，命令模式用于将命令包装在对象中的场景。可以在不知道命令本身或命令接收器的情况下传递此对象。
此模式的经典实现由几个类组成。在我们的场景中，我们有以下内容：
Command接口负责执行某个动作（在这种情况下，可能的动作是移动、复制和删除）。该接口的具体实现为CopyCommand、MoveCommand、DeleteCommand。IODevice接口定义支持的动作（move()、copy()、delete()）。HardDisk类是IODevice的具体实现，代表接收器。Sequence类是命令的调用方，它知道如何执行给定的命令。调用方可以以不同的方式进行操作，但是在这种情况下，我们只需记录命令，并在调用runSequence()时成批执行它们。
命令模式可以用下图表示：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OOStXQwJ-1657284745701)(https://github.com/apachecn/apachecn-java-zh/raw/master/docs/java-coding-prob/img/21b15cf7-75d5-4fa5-9b3f-5a675b2dd078.png)]
因此，HardDisk实现了在IODevice接口中给出的动作。作为接收器，HardDisk负责在调用某个命令的execute()方法时运行实际动作。IODevice的源代码如下：
public interface IODevice {
void copy();
void delete();
void move();
}HardDisk是IODevice的具体实现：
public class HardDisk implements IODevice {
@Override
public void copy() {
System.out.println("Copying ...");
}
@Override
public void delete() {
System.out.println("Deleting ...");
}
@Override
public void move() {
System.out.println("Moving ...");
}
}所有具体的命令类都实现了Command接口：
public interface Command {
public void execute();
}
public class DeleteCommand implements Command {
private final IODevice action;
public DeleteCommand(IODevice action) {
this.action = action;
}
@Override
public void execute() {
action.delete()
}
}同样，为了简洁起见，我们实现了CopyCommand和MoveCommand，并跳过了它们。
此外，Sequence类充当调用方类。调用方知道如何执行给定的命令，但对命令的实现没有任何线索（它只知道命令的接口）。在这里，我们将命令记录在一个List中，并在调用runSequence()方法时批量执行这些命令：
public class Sequence {
private final List<Command> commands = new ArrayList<>();
public void recordSequence(Command cmd) {
commands.add(cmd);
}
public void runSequence() {
commands.forEach(Command::execute);
}
public void clearSequence() {
commands.clear();
}
}现在，让我们看看它的工作。让我们在HardDisk上执行一批操作：
HardDisk hd = new HardDisk();
Sequence sequence = new Sequence();
sequence.recordSequence(new CopyCommand(hd));
sequence.recordSequence(new DeleteCommand(hd));
sequence.recordSequence(new MoveCommand(hd));
sequence.recordSequence(new DeleteCommand(hd));
sequence.runSequence();显然，我们这里有很多样板代码。查看命令类。我们真的需要所有这些类吗？好吧，如果我们意识到Command接口实际上是一个函数式接口，那么我们可以删除它的实现并通过 Lambda 提供行为（命令类只是行为块，因此它们可以通过 Lambda 表示），如下所示：
HardDisk hd = new HardDisk();
Sequence sequence = new Sequence();
sequence.recordSequence(hd::copy);
sequence.recordSequence(hd::delete);
sequence.recordSequence(hd::move);
sequence.recordSequence(hd::delete);
sequence.runSequence();总结
我们现在已经到了这一章的结尾。使用 Lambda 来减少甚至消除样板代码是一种技术，也可以用于其他设计模式和场景。拥有迄今为止积累的知识应该为你相应地调整案例提供坚实的基础。
