Java 编程问题:八、函数式编程-基础和设计模式
原文: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
方法,该方法将瓜列表和要过滤的类型作为参数。
得到的方法非常简单:
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;
}
完成!现在,我们可以很容易地按类型过滤西瓜,如下例所示:
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 天(按类型和重量过滤瓜)
事情变得更糟了。马克现在要求我们添加一个新的过滤器,按类型和重量过滤西瓜,他需要这个很快。然而,最快的实现是最丑陋的。过来看:
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 {@Overridepublic boolean test(Melon melon) {return "gac".equalsIgnoreCase(melon.getType());}
}
或者,过滤所有重量超过 5000 克的西瓜可以写:
public class HugeMelonPredicate implements MelonPredicate {@Overridepublic 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 匿名类。换句话说,同时声明和实例化没有名称的类将导致如下结果:
List<Melon> europeans = Filters.filterMelons(melons, new MelonPredicate() {@Overridepublic 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 为我们做。
结果如下:
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()));
我们也可以对数字做同样的处理:
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 表达式支持直接内联实现函数式接口的抽象方法。基本上,整个表达式被视为函数式接口的具体实现的实例,如以下代码所示:
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 的匿名类版本如下所示:
FilenameFilter filter = new FilenameFilter() {@Overridepublic 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();}
调用方代码不需要进一步修改:
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;}
}
无法通过空构造器获取创建此类的实例。但如果我们定义了一个支持三个参数和一个返回的函数式接口,那么我们就回到了正轨:
@FunctionalInterface
public interface TriFunction<T, U, V, R> {R apply(T t, U u, V v);
}
这一次,下面的语句将尝试获取具有三个参数的构造器,这三个参数分别是String
、Integer
和String
类型:
private static finalTriFunction<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 实现策略模式
经典的策略模式非常简单。它由一个表示一系列算法(策略)的接口和该接口的几个实现(每个实现都是一个策略)组成。
例如,以下接口统一了从给定字符串中删除字符的策略:
public interface RemoveStrategy {String execute(String s);
}
首先,我们将定义从字符串中删除数值的策略:
public class NumberRemover implements RemoveStrategy {@Overridepublic String execute(String s) {return s.replaceAll("\\d", "");}
}
然后,我们将定义一种从字符串中删除空格的策略:
public class WhitespacesRemover implements RemoveStrategy {@Overridepublic String execute(String s) {return s.replaceAll("\\s", "");}
}
最后,让我们定义一个工具类作为策略的入口点:
public final class Remover {private Remover() {throw new AssertionError("Cannot be instantiated");}public static String remove(String s, RemoveStrategy strategy) {return strategy.execute(s);}
}
这是一个简单而经典的策略模式实现。如果要从字符串中删除数值,可以按以下操作:
String text = "This is a text from 20 April 2050";
String noNr = Remover.remove(text, new NumberRemover());
但是我们真的需要NumberRemover
和WhitespacesRemover
类吗?我们是否需要为进一步的策略编写类似的类?显然,答案是否定的。
再次查看我们的接口:
@FunctionalInterface
public interface RemoveStrategy {String execute(String s);
}
我们刚刚添加了@FunctionalInterface
提示,因为RemoveStrategy
接口定义了一个抽象方法,所以它是一个函数式接口。
我们可以在函数式接口的上下文中使用什么?嗯,显而易见的答案是兰巴斯。此外,在这种情况下,Lambda 能为我们做些什么?它可以删除样板文件代码(在本例中是表示策略的类),并将策略封装在其主体中:
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 {@Overridepublic void addTopIngredients(Pizza p) {System.out.println("Add: fresh mozzarella, tomatoes,basil leaves, oregano, and olive oil ");}
}
另一方面,希腊披萨将如下:
public class GreekPizza extends PizzaMaker {@Overridepublic 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 {@Overridepublic 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
}
一半的工作完成了!现在,我们需要注册这些观察者,由接收器通知。也就是说,每个地方消防站都需要注册为消防站总部的观察者(主体)。为此,我们声明了另一个接口,它定义了主体合同,用于注册和通知其观察者:
public interface FireStationRegister {void registerFireStation(FireObserver fo);void notifyFireStations(String address);
}
最后,我们可以写消防站指挥部(主体):
public class FireStation implements FireStationRegister {private final List<FireObserver> fireObservers = new ArrayList<>();@Overridepublic void registerFireStation(FireObserver fo) {if (fo != null) {fireObservers.add(fo);}}@Overridepublic void notifyFireStations(String address) {if (address != null) {for (FireObserver fireObserver: fireObservers) {fireObserver.fire(address);}}}
}
现在,让我们把我们的三个本地站(观察者)登记到消防站总部(主体):
FireStation fireStation = new FireStation();
fireStation.registerFireStation(new BrookhavenFireStation());
fireStation.registerFireStation(new DecaturFireStation());
fireStation.registerFireStation(new ViningsFireStation());
现在,当发生火灾时,消防局总部将通知所有注册的当地消防局:
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 表达式的主体中定义。
我们只需要以下计算,但可以添加更多计算:
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());
第二个公式如下:
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 {@Overridepublic 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;}@Overridepublic String decorate() {return cake.decorate();}
}
下一步,我们重点写我们的装饰。
每个装饰器扩展CakeDecorator
并修改decorate()
方法来添加相应的装饰。
例如,Nuts
装饰器如下所示:
public class Nuts extends CakeDecorator {public Nuts(Cake cake) {super(cake);}@Overridepublic 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 NutsSystem.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 实现这一点,如下所示:
public final class Delivery {public Delivery firstname(String firstname) {System.out.println(firstname);return this;}//similar for lastname, address and contentpublic static void deliver(Consumer<Delivery> parcel) {Delivery delivery = new Delivery();parcel.accept(delivery);System.out.println("\nDone ...");}
}
对于递送包裹,我们只需使用 Lambda:
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 {@Overridepublic void copy() {System.out.println("Copying ...");}@Overridepublic void delete() {System.out.println("Deleting ...");}@Overridepublic 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;}@Overridepublic 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 来减少甚至消除样板代码是一种技术,也可以用于其他设计模式和场景。拥有迄今为止积累的知识应该为你相应地调整案例提供坚实的基础。
从本章下载应用以查看结果和其他详细信息。******
Java 编程问题:八、函数式编程-基础和设计模式相关推荐
- java和python中函数式编程
本篇文章将基于java和python分别介绍Lambda表达式,包括定义,使用等 java函数式编程 自jdk1.8开始,java中引入了函数式编程,使编程更加简洁灵活.接下来通过详细的例子阐述 函数 ...
- 编程范式及函数式编程
一.编程范式 编程范式主要有三种:命令式编程(Imperative).声明式编程(Declarative)和函数式编程(Functional). 1.命令式编程(Imperative): 命令式编程的 ...
- 函数式编程和面向对象式编程_比较函数式编程,命令式编程和面向对象的编程
函数式编程和面向对象式编程 As Oracle Corporation has introduced some Functional constructs in Java SE 8, now-a-da ...
- 成为javascript大神要掌握,面向对象编程技术、面向方面编程技术和函数式编程技术
面向对象编程技术.面向方面编程技术和函数式编程技术 mart一下,面向对象,面向切面,有一定的了解,函数式编程没接触过,得安排时间深入下.还有元编程.
- Java技术分享之函数式编程
Java是一种计算机编程语言,可用于编写桌面应用程序.Web应用程序.分布式系统和嵌入式系统应用程序等,是IT开发行业中最受欢迎的编程语言之一.想要学好Java必须要一步一个脚印打好基础.积攒实战经验 ...
- 【DS with Python】Matplotlib入门(一):架构概述、面向对象编程绘图与函数式绘图基础
文章目录 前言 一.Matplotlib架构概述 1.1 Backend(后端) 1.2 Artist(美工) 1.2.1 Figure.Subplot与Axes 1.2.2 Axis.ticks与l ...
- java函数式编程_说说函数式编程的那些事
今天这篇文章我们主要来聊聊函数式编程的思想. 函数式编程有用吗? 什么是函数式编程? 函数式编程的优点. 总所周知 JavaScript 是一种拥有很多共享状态的动态语言,慢慢的,代码就会积累足够的复 ...
- java8 函数式编程_使用Javaslang进行Java 8中的函数式编程
java8 函数式编程 我们非常高兴地在jOOQ博客上宣布一个客座帖子,该帖子由HSH Nordbank的高级软件工程师Daniel Dietrich (三人的丈夫和父亲)撰写. 他目前作为项目负责人 ...
- 使用Javaslang进行Java 8中的函数式编程
我们非常高兴地在jOOQ博客上宣布一个客座帖子,该帖子由HSH Nordbank的高级软件工程师,三个孩子的父亲, Daniel Dietrich撰写. 他目前作为项目负责人和首席开发人员为金融产品创 ...
- java函数式编程例子_java函数式编程Lambda表达式的示例(一)
函数式编程是时下比较流行的编程方式了,很多新兴的编程语言都对函数式编程有了比较好的支持,她有别于传统的命令式编程,可以将函数(执行代码的过程)作为参数进行传递.JAVA也意识到了函数式编程的重要性,在 ...
最新文章
- pwd python 安装 模块_Python自动化办公之邮件定时发送
- SQL Server 2008 R2 安装
- SQL Server2005创建新数据库时不允许创建新数据库的问题
- jquerymobile点击图片放大_微信朋友圈心形图片如何制作?电脑文件如何批量编号?...
- egret 白鹭引擎学习笔记-写在前面的话
- JAVA项目实战开发电商项目案例(九)收货地址模块开发
- java中resultset的previous_在 Java中,已获得默认类型的ResultSet对象rs,要获得结果集中的数据,必须执行的语句是( )。_学小易找答案...
- Linux下截图的简单方案
- 电池测试系统连接服务器失败,服务器报电池故障
- zotero文献管理高级操作|解决文献条目题录元数据一键更新问题
- html按钮点击后无效,关于html中按钮的单击事件,第一次单击可以运行,再次单击不能运行的解决方法...
- java熄灯问题,枚举算法案例--熄灯问题
- 飞桨高阶使用教程:自定义CPU算子的实现和使用
- OkHttp GET请求步骤
- Fasm汇编程序1.73,中文文档,第一章
- html读秒倒计时,读秒倒计时
- 39.html5的动画(animation)
- 【论文阅读|cryoET】Isotropic reconstruction for electrontomography with deep learning (解决缺失楔问题降噪)
- 2022-2028全球干式抽水马桶行业调研及趋势分析报告
- paddlepaddle学习