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

2024-02-20 20:10
文章标签 函数 设计模式 模式 对象 再聊 bruce eckel

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

Bruce Eckel

读完需要

10

分钟

速读仅需 1 分钟

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

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

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

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

7

   

函数对象模式

一个函数对象（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，并找出执行成功的算法。

0f6905d7ac4f88b28a15a4e52379cfdb.png

4fdaabb5815d0471e0c5d2aa799b796b.jpeg

本书特色

  • 查漏宝典：涵盖Java关键特性的设计原理和应用方法

  • 避坑指南：以产业实践的得失为鉴，指明Java开发者不可不知的设计陷阱

  • 经典普适：值得不同层次的Java开发者反复研读

  • 专家领读：4位一线业务专家、知名作译者帮你拆解书中难点，总结Java开发精要

值得一提的是，为了帮助新手加深理解，出版方邀请了4位从业10年以上知名作译者（DDD 专家张逸、服务端专家梁桂钊、软件系统架构专家王前明、译者陈德伟）为本书录制【精讲视频】和【导读指南】，该视频已在B站和图灵社区发布，感兴趣的朋友可以去看看。

c9e5cc8fc938076fa8ff08289867db5b.png

往期推荐

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

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

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

Bruce Eckel - 详解函数式编程（卷一）

Bruce Eckel - 详解函数式编程（卷二）

Bruce Eckel - 详解函数式编程（卷三）

知明：技术 Leader 的思考法

史海峰：在时代节点上顺势而为是一种幸运

我，程序员，马上35岁...

后Kubernetes时代的微服务

怎样才能持续输出技术原创文章？

同事多线程使用不当导致OOM，被我怒怼了

如何在 SpringBoot 项目中控制 RocketMQ消费线程数量

聊聊 8 种架构模式

Google工程师是怎么写设计文档的？

聊聊技术人员如何做好团队管理

ade661da459e3d5378b81f73bdc52819.jpeg

这篇关于Bruce Eckel：再聊设计模式（篇四）函数对象模式的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/729405。

相关文章

hdu1171（母函数或多重背包）

hdu1171（母函数或多重背包）

题意：把物品分成两份，使得价值最接近 可以用背包，或者是母函数来解，母函数（1 + x^v+x^2v+.....+x^num*v）（1 + x^v+x^2v+.....+x^num*v）（1 + x^v+x^2v+.....+x^num*v） 其中指数为价值，每一项的数目为（该物品数+1）个 代码如下： #include<iostream>#include<algorithm>
阅读更多...
在JS中的设计模式的单例模式、策略模式、代理模式、原型模式浅讲

在JS中的设计模式的单例模式、策略模式、代理模式、原型模式浅讲

1. 单例模式（Singleton Pattern） 确保一个类只有一个实例，并提供一个全局访问点。 示例代码： class Singleton {constructor() {if (Singleton.instance) {return Singleton.instance;}Singleton.instance = this;this.data = [];}addData(value)
阅读更多...
C++操作符重载实例(独立函数)

C++操作符重载实例(独立函数)

C++操作符重载实例，我们把坐标值CVector的加法进行重载，计算c3=c1+c2时，也就是计算x3=x1+x2，y3=y1+y2，今天我们以独立函数的方式重载操作符+（加号），以下是C++代码： c1802.cpp源代码： D:\YcjWork\CppTour>vim c1802.cpp #include <iostream>using namespace std;/*** 以独立函数
阅读更多...
函数式编程思想

函数式编程思想

我们经常会用到各种各样的编程思想，例如面向过程、面向对象。不过笔者在该博客简单介绍一下函数式编程思想. 如果对函数式编程思想进行概括，就是f(x) = na(x) , y=uf(x)…至于其他的编程思想，可能是y=a(x)+b(x)+c(x)…，也有可能是y=f(x)=f(x)/a + f(x)/b+f(x)/c… 面向过程的指令式编程 面向过程，简单理解就是y=a(x)+b(x)+c(x)
阅读更多...
模版方法模式template method

模版方法模式template method

学习笔记，原文链接 https://refactoringguru.cn/design-patterns/template-method 超类中定义了一个算法的框架， 允许子类在不修改结构的情况下重写算法的特定步骤。 上层接口有默认实现的方法和子类需要自己实现的方法
阅读更多...
【iOS】MVC模式

【iOS】MVC模式

MVC模式 MVC模式MVC模式demo MVC模式 MVC模式全称为model(模型)view(视图)controller(控制器)，他分为三个不同的层分别负责不同的职责。 View：该层用于存放视图，该层中我们可以对页面及控件进行布局。Model：模型一般都拥有很好的可复用性，在该层中，我们可以统一管理一些数据。Controlller：该层充当一个CPU的功能，即该应用程序
阅读更多...
迭代器模式iterator

迭代器模式iterator

学习笔记，原文链接 https://refactoringguru.cn/design-patterns/iterator 不暴露集合底层表现形式 （列表、 栈和树等） 的情况下遍历集合中所有的元素
阅读更多...
Java第二阶段---09类和对象---第三节 构造方法

Java第二阶段---09类和对象---第三节 构造方法

第三节 构造方法 1.概念 构造方法是一种特殊的方法，主要用于创建对象以及完成对象的属性初始化操作。构造方法不能被对象调用。 2.语法 //[]中内容可有可无 访问修饰符 类名([参数列表]){ } 3.示例 public class Car {     //车特征(属性）     public String name;//车名   可以直接拿来用 说明它有初始值     pu
阅读更多...
《x86汇编语言：从实模式到保护模式》视频来了

《x86汇编语言：从实模式到保护模式》视频来了

《x86汇编语言：从实模式到保护模式》视频来了 很多朋友留言，说我的专栏《x86汇编语言：从实模式到保护模式》写得很详细，还有的朋友希望我能写得更细，最好是覆盖全书的所有章节。 毕竟我不是作者，只有作者的解读才是最权威的。 当初我学习这本书的时候，只能靠自己摸索，网上搜不到什么好资源。 如果你正在学这本书或者汇编语言，那你有福气了。 本书作者李忠老师，以此书为蓝本，录制了全套视频。 试
阅读更多...
利用命令模式构建高效的手游后端架构

利用命令模式构建高效的手游后端架构

在现代手游开发中，后端架构的设计对于支持高并发、快速迭代和复杂游戏逻辑至关重要。命令模式作为一种行为设计模式，可以有效地解耦请求的发起者与接收者，提升系统的可维护性和扩展性。本文将深入探讨如何利用命令模式构建一个强大且灵活的手游后端架构。 1. 命令模式的概念与优势 命令模式通过将请求封装为对象，使得请求的发起者和接收者之间的耦合度降低。这种模式的主要优势包括： 解耦请求发起者与处理者
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2