从变化理解设计模式
食谱是模式,厨房是业务,厨具是语言特性。食谱告诉你如何配合,不替你买菜;模式也不是复制就能运行的万能代码。
1.1 学习目标与路线
适合已理解类、接口、继承、多态的学生。示例支持 Java、Python、C++、C#、TypeScript、Go、Rust、Kotlin、Swift、Dart,默认 Java。点击任意代码区的语言 Tab,整份课程同步切换。除第 20 章完整实验外,每块是独立机制片段,不跨章拼接;图中的类名与方法名用于表达模式角色。金额统一用整数“分”。学完应能说明每种模式的变化点、协作关系和代价。
| 家族 | 核心问题 | 本课章节与数量 |
|---|---|---|
| 创建型 | 对象如何产生?调用者要知道多少细节? | 04–07 · 5 种 |
| 结构型 | 对象如何组合,形成可替换的结构? | 08–11 · 7 种 |
| 行为型 | 职责、算法、通知如何分配? | 12–17 · 11 种 |
1.2 跟踪一次多态调用
interface Notifier { void send(String text); }
class ConsoleNotice implements Notifier {
public void send(String text) { System.out.println(text); }
}
class Alert {
private final Notifier notifier;
Alert(Notifier notifier) { this.notifier = notifier; }
void fire() { notifier.send("库存不足"); }
}Alert 不关心发送细节,只依赖 send 合同。后续章节会回答:实现由谁创建?能否加日志?能否通知多人?这些是不同变化轴,不应混为同一问题。
1.9 随堂自测
SOLID:五条设计检查线
学校里教师管教学、财务管收费;岗位说明对应接口,换老师对应替换实现。边界:现实岗位可临时兼任,程序合同却不能依赖临场商量。
2.1 S · 单一职责:按变化原因划边界
SRP:模块对一类变化原因负责。报表计算与 PDF 排版由不同诉求驱动,分开后改字体不用动计费规则。不是“每个类只能有一个方法”。
2.2 O · 开闭原则:给已知变化留下扩展点
OCP:对扩展开放,对修改关闭。新增折扣可以增加实现,但装配策略的入口仍可能变化;没有设计能保证永远不改旧代码。
2.3 L · 里氏替换:行为合同高于继承语法
LSP:子类型应能替换父类型,不加强前置条件、不削弱后置条件、不破坏不变量。父类型承诺可写,子类却总抛异常,仍属于违约。
2.4 I · 接口隔离:只依赖需要的能力
ISP:只会打印的设备不应被迫实现 scan()。划分 Printer 与 Scanner 后,多功能机可同时实现两个接口。接口按客户需求划分,不按“凑够方法数”划分。
2.5 D · 依赖倒置:业务与细节都依赖合同
DIP:高层策略不依赖底层细节,两者依赖抽象。依赖注入是传入依赖的手法;若注入具体数据库类,仍可能没有依赖倒置。
interface OrderStore { void save(String id); }
class Checkout {
private final OrderStore store;
Checkout(OrderStore store) { this.store = store; }
void place(String id) { store.save(id); }
}2.9 随堂自测
读懂协作图与组合
主机“有一个”手柄是组合,赛车“是一种”载具是继承。换手柄对应替换协作者;边界:软件对象可被共享,现实物件不足以解释所有权与生命周期。
3.1 本课的图怎样读
| 符号/布局 | 含义 | 注意 |
|---|---|---|
| 实线箭头 + 调用标签 | 持有引用或调用方向 | 以标签为准,不推断生命周期 |
| 虚线 + 实现标签 | 类型实现某接口 | 是契约关系,不代表发送消息 |
| 分叉/汇合 | 多个实现或多路协作 | 不自动表示并发 |
| 嵌套框 | 包装或包含关系 | 调用顺序须另看箭头 |
本课主要用协作示意图,不全是正式 UML。正式 UML 的空心三角表示继承/实现,实心菱形表示组合,空心菱形表示聚合,菱形位于整体一端;普通箭头不要误认成继承。
3.2 组合优先,继承有条件
interface Sender { void send(String text); }
class OrderService {
private final Sender sender;
OrderService(Sender sender) { this.sender = sender; }
void paid() { sender.send("支付成功"); }
}
// new OrderService(emailSender) 或 new OrderService(smsSender)
// 不必再派生 EmailOrderService。组合复用:委托协作者实现行为,代价是多一层对象与转发。迪米特法则:少知道陌生对象的内部链路,用 order.shipTo() 表达能力,避免穿透 order.customer.
3.3 小步重构
3.9 随堂自测
单例:唯一实例与边界
班级值日表只有一本,大家从同一入口查看。唯一登记本对应唯一实例;边界:多校区可能各有一本,对应不同进程或类加载器,不能宣称全世界只有一个。
4.1 让“创建权”集中起来
角色:Singleton 自己控制创建入口,Client 只能取得同一对象。适合明确需要唯一身份、生命周期稳定的协调对象;若只是共享一份配置,用不可变对象和显式注入常常更简单。
enum Config {
INSTANCE;
private final String env = "demo";
String env() { return env; }
}
// 在某个方法中:
// Config a = Config.INSTANCE;
// Config b = Config.INSTANCE;
// System.out.println(a == b); // true4.2 三种选择,别背成一种
| 写法 | 创建时机与性质 | 注意 |
|---|---|---|
| static final 饿汉式 | 类初始化时创建,初始化有 JVM 保证 | 可能提早持有资源 |
| 静态内部类 Holder | 首次使用 Holder 时初始化 | 仍受类加载器作用域限制 |
| enum 枚举 | 枚举常量初始化,由 JVM 管理 | 适合无复杂继承要求的唯一对象 |
本课选 enum 展示机制。它不能替代数据库锁、分布式协调,也不保证实例方法里修改的集合安全。单例还会隐藏依赖,使测试互相污染;可由应用装配层创建一份普通对象并注入来替代。
4.9 随堂自测
工厂方法:延迟选择产品
饮品店总部规定“取杯→装饮料→出杯”,各分店决定用哪种杯。总店流程对应 Creator,选杯钩子对应工厂方法;边界:真实分店能随意改流程,代码中应明确哪些步骤允许覆盖。
5.1 先看稳定流程,再看创建钩子
角色:Product 是产品合同;ConcreteProduct 实现合同;Creator 使用产品但把创建交给工厂方法;ConcreteCreator 覆盖创建逻辑。调用顺序:client → deliver() → create() → product.send()。
interface Transport { void send(); }
class Truck implements Transport {
public void send() { System.out.println("公路运输"); }
}
abstract class Delivery {
protected abstract Transport create();
final void deliver() { create().send(); }
}
class RoadDelivery extends Delivery {
protected Transport create() { return new Truck(); }
}5.2 简单工厂为何不等同于工厂方法
| 方案 | 选择具体产品的位置 | 适合 |
|---|---|---|
| 简单工厂 | 一个函数里的 switch / 注册表 | 创建分支少、集中管理方便 |
| 工厂方法 | Creator 子类覆盖创建方法 | 有稳定流程,需要子类扩展创建点 |
| 直接 new | 调用者现场 | 依赖简单稳定,无需额外扩展点 |
收益:流程不认识 Truck。代价:每个创建变体可能新增 Creator 子类;若根本没有可复用流程,单用函数工厂就够了。简单工厂是常用惯用法,不属于 GoF 的 23 种之一。
5.9 随堂自测
抽象工厂:成套产品一起换
买同系列桌椅,商店给出“北欧套装”或“古典套装”。风格对应产品族,桌/椅对应产品种类;边界:现实中能混搭,代码是否禁止混搭要靠装配约束或类型设计。
6.1 两个维度:新增一族,还是新增一种产品
interface Button { String paint(); }
interface CheckBox { String paint(); }
interface UiFactory {
Button button();
CheckBox checkBox();
}
class DarkFactory implements UiFactory {
public Button button() { return () -> "深色按钮"; }
public CheckBox checkBox() { return () -> "深色勾选框"; }
}
class Screen {
String draw(UiFactory f) {
return f.button().paint() + f.checkBox().paint();
}
}角色:AbstractFactory 定义各产品创建入口;ConcreteFactory 实现某一产品族;产品接口让客户端不认识具体风格。例中用 lambda 代替只有一个方法的产品类,缩短代码,不改变模式意图。
6.2 收益与代价
| 变更 | 影响范围 | 结论 |
|---|---|---|
| 增加浅色/高对比主题族 | 新增工厂与该族产品 | 对既有客户较友好 |
| 增加 Slider 产品种类 | 改 UiFactory 及所有实现 | 横向扩展成本高 |
| 客户自己混用不同工厂产品 | 可能打破兼容关系 | 装配处集中选择一套工厂 |
6.9 随堂自测
建造者与原型:组装或复制
点套餐时逐项选主食/饮料,对应 Builder;复印一张已填表格再改姓名,对应 Prototype。边界:纸张复印会复制内容,软件浅拷贝却可能仍共用同一个可变子对象。
7.1 建造者 Builder:把有效性检查集中到出口
痛点:参数过多,连续位置参数容易传错。角色:Builder 收集步骤,Product 是成品,可选 Director 编排固定步骤。链式调用是常见写法,并不是模式定义;经典建造者还可用相同构建步骤生成不同表示。
record Meeting(String room, int seats) {}
class MeetingBuilder {
private String room = "A";
private int seats = 1;
MeetingBuilder room(String r) { room = r; return this; }
MeetingBuilder seats(int n) { seats = n; return this; }
Meeting build() {
if (room == null || room.isBlank() || seats < 1)
throw new IllegalArgumentException("房间和人数无效");
return new Meeting(room, seats);
}
}
// new MeetingBuilder().room("B").seats(8).build();适用:可选参数多、存在跨字段约束。代价:多一个构建器;两个简单参数直接用构造器通常更清楚。例子把校验置于 build;若允许客户绕过 Builder 直接创建,Product 构造器也必须守住不变量。
7.2 原型 Prototype:复制的是对象图,而不只是外壳
角色:Prototype 暴露 copy 合同,具体原型决定如何复制;客户从样板产生新实例。适合初始状态复杂或运行时才知道具体类型的对象。复制成本和共享策略必须讲清。
class Badge {
final java.util.List<String> tags;
Badge(java.util.List<String> tags) {
this.tags = new java.util.ArrayList<>(tags);
}
Badge copy() { return new Badge(tags); }
}
// Badge b = a.copy();
// b.tags.add("新标签"); // 不会改动 a.tags7.9 随堂自测
适配器与桥接:接口和维度
转换插头把旧接口接到新插座,是适配器;遥控器种类与电视品牌分开组合,是桥接。边界:电压、安全性和行为语义不会因插头能插上就自动匹配。
8.1 适配器 Adapter:把合同翻译完整
角色:Client 认 Target;Adapter 实现 Target 并持有 Adaptee。调用链:客户 → 新接口 → 适配器转换 → 旧接口。对象适配通过组合实现;类适配通常借继承,受语言限制。
interface Pay { void charge(int cents); }
class LegacyPay {
void payYuan(java.math.BigDecimal yuan) {
System.out.println(yuan.toPlainString());
}
}
class PayAdapter implements Pay {
private final LegacyPay old;
PayAdapter(LegacyPay old) { this.old = old; }
public void charge(int cents) {
if (cents < 0) throw new IllegalArgumentException();
old.payYuan(java.math.BigDecimal.valueOf(cents, 2));
}
}适用:接入旧库/第三方系统。代价:多一层映射,要处理单位、异常与返回值含义;无法兼容的语义不能靠包装硬装成兼容。
8.2 桥接 Bridge:两个轴各自成长
角色:Abstraction 持有 Implementor;两边分别有扩展类型。例如消息级别普通/紧急,与发送通道邮件/短信独立变化,不必创建四种组合子类。
interface Channel { void send(String text); }
abstract class Message {
protected final Channel channel;
Message(Channel channel) { this.channel = channel; }
abstract void send(String text);
}
class Urgent extends Message {
Urgent(Channel channel) { super(channel); }
void send(String text) { channel.send("[紧急] " + text); }
}适用:已知有两个独立扩展维度。代价:多一组抽象与委托;若只有单一变化轴,用普通组合即可。桥接与策略结构可能相似,但桥接强调两侧维度,策略强调替换算法。
8.9 随堂自测
组合与装饰器:树和层
文件夹里既有文件又有子文件夹,对应组合;奶茶逐层加珍珠、奶盖,对应装饰。边界:奶茶配料可混合,代码包装却有调用顺序,顺序可能改变结果。
9.1 组合 Composite:把“整体”也当节点
角色:Component 统一操作;Leaf 直接执行;Composite 持有子节点并递归委托。适合目录、组织树、菜单树;代价是统一接口可能难以表达叶子独有操作。
interface Node { int total(); }
record FileNode(int bytes) implements Node {
public int total() { return bytes; }
}
record Folder(java.util.List<Node> children) implements Node {
Folder { children = java.util.List.copyOf(children); }
public int total() {
return children.stream().mapToInt(Node::total).sum();
}
}9.2 装饰器 Decorator:一层包一层,合同不变
角色:Component 是同一合同;ConcreteComponent 给出基础能力;Decorator 持有 Component,在委托前后增加行为。适合压缩流、计费附加项。代价是嵌套层多、调试栈长,顺序需要明确。
interface Drink { int cost(); }
record Tea() implements Drink {
public int cost() { return 1000; }
}
record Pearl(Drink inner) implements Drink {
public int cost() { return inner.cost() + 200; }
}
record Foam(Drink inner) implements Drink {
public int cost() { return inner.cost() + 300; }
}
// new Foam(new Pearl(new Tea())).cost() == 15009.9 随堂自测
外观与代理:简化或把关
酒店前台替你协调客房/餐饮,是外观;门禁核实身份后才开门,是代理。边界:前台不自动保证所有服务原子完成,门禁也不能改变房间本身的业务承诺。
10.1 外观 Facade:缩小客户需要知道的范围
角色:Facade 编排多个 Subsystem;Client 只调用更贴近任务的入口。适合屏蔽接入复杂度;代价是入口可能膨胀,需按任务拆分。子系统仍可被其他合法客户直接使用。
class OrderFacade {
private final Runnable reserve, create, notifyUser;
OrderFacade(Runnable r, Runnable c, Runnable n) {
reserve = r; create = c; notifyUser = n;
}
void place() {
reserve.run();
create.run();
notifyUser.run();
}
}
// Runnable 仅代替真实子系统,突出编排关系。10.2 代理 Proxy:客户仍面对原合同
角色:Subject 约定业务能力,RealSubject 真正执行,Proxy 同样实现 Subject 并决定是否/何时转发。适合权限、延迟加载、远程访问或缓存。代价是隐藏的延迟、失败与一致性问题。
interface Doc { String read(); }
record TextDoc(String text) implements Doc {
public String read() { return text; }
}
record GuardProxy(Doc target, boolean allowed) implements Doc {
public String read() {
if (!allowed) throw new SecurityException("无权限");
return target.read();
}
}本例 allowed 是固定实验输入,真实系统应在合适的边界核验可信身份。代理 vs 装饰器:结构相像,代理以控制访问为意图,装饰器以叠加职责为意图;不能只凭“内部有对象”判断。
10.9 随堂自测
享元:共享稳定的内部状态
一枚字模能在很多位置印同一个字:字形对应内部状态,纸上坐标对应外部状态。边界:共享字模不是让所有字拥有同一个位置;共享可变位置会把整页文字拖到一起。
11.1 先拆状态,再谈共享
| 状态 | 本例 | 放置位置 |
|---|---|---|
| 内部状态 intrinsic | 字符形状、字体与样式等稳定信息 | 共享 Glyph,尽量不可变 |
| 外部状态 extrinsic | x / y、具体使用上下文 | 由客户传入或放独立上下文 |
| 共享索引 | 字符键到 Glyph 的映射 | 享元工厂;真实键需含所有影响外观的字段 |
record Glyph(char ch) {
void draw(int x, int y) {
System.out.println(ch + " @ " + x + "," + y);
}
}
class GlyphFactory {
private final java.util.Map<Character, Glyph> pool =
new java.util.HashMap<>();
Glyph get(char ch) { return pool.computeIfAbsent(ch, Glyph::new); }
}
// Glyph a = factory.get('A');
// a.draw(10, 20); a.draw(30, 20); // 相同形状,不同坐标11.2 不是所有缓存都叫享元
角色:Flyweight 保存内部状态;Factory 查找/创建共享对象;Context 保存外部状态。适合对象数量极大、重复状态占内存明显、可以拆出外部状态的情况。代价:共享索引、查找成本与状态拆分复杂度;少量轻对象可能不划算。
| 概念 | 复用什么 | 关键区别 |
|---|---|---|
| 享元 | 相同内部状态的对象 | 多个上下文可同时共享 |
| 对象池 | 可借用的昂贵对象 | 常有借出/归还及排他使用 |
| 普通缓存 | 计算或读取结果 | 未必有内部/外部状态拆分 |
11.9 随堂自测
策略与模板方法:换算法或步骤
去学校可选步行/骑车,对应策略;考试固定“发卷→答题→收卷”,各科题目不同,对应模板方法。边界:现实流程可临时改,代码中必须说明哪些步骤不能跳过。
12.1 策略 Strategy:把算法作为对象传入
角色:Context 持有 Strategy,ConcreteStrategy 实现算法;客户或装配层选择策略。适合折扣、排序规则、路线选择。代价:客户要理解策略差异,策略数量与装配复杂度可能增加。
interface Discount { int apply(int cents); }
record Checkout(Discount discount) {
int total(int cents) {
if (cents < 0) throw new IllegalArgumentException();
return discount.apply(cents);
}
}
// new Checkout(c -> c).total(1000); // 1000
// new Checkout(c -> (int)(c * 90L / 100)).total(1000); // 90012.2 模板方法 Template Method:骨架不可跳,步骤可变化
角色:AbstractClass 的模板方法调用若干原语步骤;ConcreteClass 实现步骤,钩子可提供可选扩展。适合导入流程、测试生命周期。代价:继承耦合较强,父流程变更影响所有子类。
abstract class ImportJob {
final String run() { return convert(read()).trim(); }
protected abstract String read();
protected abstract String convert(String input);
}
class CsvJob extends ImportJob {
protected String read() { return "a,b"; }
protected String convert(String input) {
return input.replace(",", " | ");
}
}12.9 随堂自测
观察者与中介者:广播和协调
订阅校园广播是观察者,塔台协调飞机是中介者。订阅者对应监听对象,塔台对应协调中心;边界:广播不天然可靠送达,塔台也不是接管所有飞机内部操作的上帝对象。
13.1 观察者 Observer:发送者不用认识具体接收者
角色:Subject 管理订阅并在变化后通知;Observer 约定回调。调用链:订阅 → 发布 → 遍历订阅快照 → 回调。适合界面更新、领域事件。代价是调用关系隐蔽、退订管理与重入问题。
interface Observer { void update(String event); }
class Subject {
private final java.util.List<Observer> list =
new java.util.ArrayList<>();
void on(Observer o) { if (!list.contains(o)) list.add(o); }
void off(Observer o) { list.remove(o); }
void publish(String event) {
for (Observer o : java.util.List.copyOf(list))
o.update(event);
}
}
// 本例同步、单线程;回调抛错会中断后续通知。13.2 中介者 Mediator:把网状关系收到协调中心
角色:Colleague 只报告事件给 Mediator;中介者决定影响哪些其他组件。适合表单联动、聊天室协调。代价是协调中心可能变成巨大条件分支,需要按交互任务划分。
interface Mediator { void changed(String sender); }
class Field {
String text = "";
private final Mediator mediator;
Field(Mediator mediator) { this.mediator = mediator; }
void input(String value) {
text = value; mediator.changed("field");
}
}
class Dialog implements Mediator {
final Field field = new Field(this);
boolean submitEnabled;
public void changed(String sender) {
if (sender.equals("field"))
submitEnabled = !field.text.isBlank();
}
}示例以 submitEnabled 表示按钮状态,省略 GUI 绘制。辨析:观察者强调通知依赖,中介者强调协调规则;中介者完全可以用观察者机制接收事件。
13.9 随堂自测
命令与备忘录:请求和快照
餐厅点菜单是命令,草稿存档是备忘录。点菜单对应“要做什么”,存档对应“当时是什么”;边界:撤销菜单记录不会自动把已经吃掉的菜恢复,外部副作用通常需要补偿。
14.1 命令 Command:调用者只管触发
角色:Invoker 触发 Command,ConcreteCommand 保存 Receiver 与参数,Receiver 执行真正业务,Client 负责装配。适合队列、按钮绑定、操作历史。代价是命令对象增多,以及历史生命周期管理。
interface Command { void execute(); void undo(); }
class Lamp { boolean on; }
class OnCommand implements Command {
private final Lamp lamp;
private boolean before;
OnCommand(Lamp lamp) { this.lamp = lamp; }
public void execute() { before = lamp.on; lamp.on = true; }
public void undo() { lamp.on = before; }
}
class Remote {
void press(Command command) { command.execute(); }
}
// 历史中的每次执行应使用独立记录;undo 仅在 execute 后调用。14.2 备忘录 Memento:看管者持有令牌,不拆开内部状态
角色:Originator 创建与恢复 Snapshot;Memento 封装状态;Caretaker 保存历史而不修改其内容。适合编辑器、小游戏存档。代价是快照占内存、复制成本与版本兼容性。
class Editor {
private String text = "";
void write(String value) { text = value; }
String read() { return text; }
static final class Snapshot {
private final String text;
private Snapshot(String text) { this.text = text; }
}
Snapshot save() { return new Snapshot(text); }
void restore(Snapshot snapshot) { text = snapshot.text; }
}
// Editor.Snapshot old = editor.save(); // 看管者只持有
// editor.write("新版"); editor.restore(old);可把命令与备忘录组合:命令执行前保存快照,undo 时恢复。需要跨实例使用时应校验快照所属对象;真实文档还需规定光标、选区是否属于恢复范围。
14.9 随堂自测
状态与职责链:迁移和传递
自动售货机投币前后按钮效果不同,是状态;报销按金额交给不同审批人,是职责链。边界:现实机器有并发与硬件故障,示意状态机不会自动解决这些问题。
15.1 状态 State:把行为分散到状态对象
角色:Context 持有 State 并委托事件;ConcreteState 执行状态相关行为,可通过 Context 转移状态。适合对象行为随阶段变化且分支复杂的场景;代价是状态类/转换规则增多。
class Order {
private Status state = Status.NEW;
void pay() { state.pay(this); }
void ship() { state.ship(this); }
enum Status {
NEW {
void pay(Order o) { o.state = PAID; }
},
PAID {
void ship(Order o) { o.state = SHIPPED; }
},
SHIPPED;
void pay(Order o) { throw new IllegalStateException(); }
void ship(Order o) { throw new IllegalStateException(); }
}
}关键是上下文委托状态对象处理,不是“只要有 enum 就是 State 模式”。枚举状态只共享无状态行为,订单专属数据留在 Order;生产系统需另外设计持久化与并发校验。
15.2 职责链 Chain of Responsibility:每站处理或转交
角色:Handler 定义处理入口与后继,ConcreteHandler 决定本次处理/转发,Client 组装链。适合审批、日志级别、过滤流程。代价是链路难追踪、可能无人处理;须规定短路或继续语义。
record Approver(String name, int limit, Approver next) {
String approve(int amount) {
if (amount < 0) throw new IllegalArgumentException();
if (amount <= limit) return name;
if (next != null) return next.approve(amount);
throw new IllegalArgumentException("超出审批范围");
}
}
// new Approver("组长", 1000,
// new Approver("经理", 5000, null)).approve(3000); // 经理15.9 随堂自测
迭代器与访问者:遍历和运算
博物馆导览路线像迭代器;同一批展品交给估价员或修复员检查像访问者。边界:路线不保证展品永远不变,新增一类展品也会让所有专家补充处理知识。
16.1 迭代器 Iterator:每次遍历有自己的游标
角色:Aggregate 提供迭代器,Iterator 约定 hasNext / next,ConcreteIterator 保存遍历状态。适合统一遍历不同集合。代价是游标对象与结构修改规则;多个迭代器不应意外共用同一游标。
class Names implements Iterable<String> {
private final java.util.List<String> data;
Names(java.util.List<String> data) {
this.data = java.util.List.copyOf(data);
}
public java.util.Iterator<String> iterator() {
return new java.util.Iterator<>() {
int index;
public boolean hasNext() { return index < data.size(); }
public String next() {
if (!hasNext()) throw new java.util.NoSuchElementException();
return data.get(index++);
}
};
}
}16.2 访问者 Visitor:结构稳定时,增加新运算
角色:Element.accept 接收 Visitor;具体元素调用 visitor.visit(this);不同 Visitor 实现求值、打印等运算。适合稳定的 AST 或文档节点结构;代价是新增元素类型会影响全部访问者,还可能暴露元素信息。
interface V {
int visit(Num n);
int visit(Add a);
}
interface Node { int accept(V v); }
record Num(int value) implements Node {
public int accept(V v) { return v.visit(this); }
}
record Add(Node left, Node right) implements Node {
public int accept(V v) { return v.visit(this); }
}
class Sum implements V {
public int visit(Num n) { return n.value(); }
public int visit(Add a) {
return a.left().accept(this) + a.right().accept(this);
}
}这里 accept 先由真实节点动态分派;随后在具体节点内部选择正确 visit 重载,再由具体访问者执行。Visitor 不一定负责遍历,遍历也可由外部统一控制;本例由 Sum 递归。
16.9 随堂自测
解释器:把规则变成表达式树
搭积木算式:数字块和变量块是叶子,加法块连接两块并求和。边界:积木拼好了不等于能自动识别文字输入,解析字符串成树是另一个步骤。
17.1 从文法到对象:解释不等于解析
本例文法:Expr := Int | Variable | (Expr + Expr)。角色:AbstractExpression 定义 interpret;TerminalExpression 处理数字/变量;NonterminalExpression 组合子表达式;Context 保存变量值。
interface Expr { int eval(java.util.Map<String, Integer> ctx); }
record Literal(int value) implements Expr {
public int eval(java.util.Map<String, Integer> ctx) { return value; }
}
record Var(String name) implements Expr {
public int eval(java.util.Map<String, Integer> ctx) {
Integer value = ctx.get(name);
if (value == null) throw new IllegalArgumentException("未知变量");
return value;
}
}
record Plus(Expr left, Expr right) implements Expr {
public int eval(java.util.Map<String, Integer> ctx) {
return Math.addExact(left.eval(ctx), right.eval(ctx));
}
}
// new Plus(new Var("x"), new Literal(10))
// .eval(java.util.Map.of("x", 5)); // 1517.2 使用边界
| 适合 | 为何适合 | 不适合的信号 |
|---|---|---|
| 简单筛选/规则表达式 | 文法小、规则可组合 | 规则数量与优先级迅速变多 |
| 教学计算器/配置条件 | AST 与执行关系清楚 | 要求完整语言的类型与错误定位 |
| 受限 DSL | 能控制节点数、深度和可用操作 | 直接执行任意用户代码 |
收益:规则可组合为树,含义直观。代价:文法一复杂就出现大量类,递归有深度与性能成本。复杂语言应考虑成熟的解析与执行方案,而不是强行手写整套解释器。
17.9 随堂自测
订单实战:把模式接起来
搭舞台时灯光、音响、主持各有职责,对应独立变化模块;总导演对应业务编排。边界:大家按职责分工,不代表断电时能自动恢复整场演出,失败恢复必须另外设计。
18.1 需求 → 变化 → 最小模式
| 具体需求 | 变化点 | 可选模式 |
|---|---|---|
| 会员与普通用户计价不同 | 折扣算法 | 策略 |
| 接入旧支付 SDK,计价单位不同 | 外部合同 | 适配器 |
| 只有已支付订单允许发货 | 生命周期行为 | 状态 |
| 支付完成后通知多个模块 | 订阅者集合 | 观察者 |
| 调用者只想完成下单任务 | 子系统协作细节 | 外观 |
这些模式可以分步引入。若只有一个固定计价公式,先不建策略;若只通知一个固定接收者,一次显式调用更好追踪。设计应跟着变化压力成长。
18.2 最小装配:代码只展示合同与顺序
interface Discount { int apply(int cents); }
interface Store { void save(String id, int total); }
record Placed(String id, int total) {}
class PlaceOrder {
private final Discount discount;
private final Store store;
private final java.util.function.Consumer<Placed> events;
PlaceOrder(Discount d, Store s,
java.util.function.Consumer<Placed> e) {
discount = d; store = s; events = e;
}
void run(String id, int cents) {
if (id == null || id.isBlank() || cents < 0)
throw new IllegalArgumentException();
int total = discount.apply(cents);
if (total < 0 || total > cents) // 本例折扣合同
throw new IllegalArgumentException("折扣结果无效");
store.save(id, total);
events.accept(new Placed(id, total));
}
}events 可以接第 13 章的同步通知机制,也可以只打印事件;存储由测试替身或真实实现提供。该片段不包含支付调用,不承诺跨服务事务或可靠投递。支付适配器与订单状态应在对应业务步骤接入,不在创建订单时提前宣告“已支付”。
18.3 用失败案例检查设计
| 验证场景 | 预期行为 | 要暴露的风险 |
|---|---|---|
| 负数金额/空订单号 | 进入存储前拒绝 | 不能把输入责任藏进模式 |
| 策略返回负数或超原价 | 按本课折扣合同拒绝 | 扩展实现也要守合同 |
| 存储失败 | 不发送成功事件 | 先后顺序影响错误事实 |
| 存储成功、通知失败 | 承认订单已存在,设计恢复策略 | 重试可能重复创建或重复通知 |
| 同一请求重复送达 | 按订单号/请求标识去重 | 需要幂等设计,模式不自动保证 |
18.9 随堂自测
23 种模式选型速查
工具箱里锤子、钳子、扳手各有任务,不能因为都带手柄就当成同一工具。变化轴对应要修的问题;边界:同一问题可能有多种合适工具,不存在固定“题目关键词→唯一答案”。
19.1 三问缩小范围
19.2 全部 23 种:问题、关键词与入口
| 模式 | 最核心的隔离点/记忆词 | 章节 |
|---|---|---|
| 单例 Singleton | 唯一身份;明确作用域 | 04 |
| 工厂方法 Factory Method | 由子类扩展产品创建钩子 | 05 |
| 抽象工厂 Abstract Factory | 整体替换产品族 | 06 |
| 建造者 Builder | 分步组装与成品校验 | 07 |
| 原型 Prototype | 从现有样板复制状态 | 07 |
| 适配器 Adapter | 转换已有不兼容合同 | 08 |
| 桥接 Bridge | 两个独立扩展维度 | 08 |
| 组合 Composite | 整体与叶子递归统一 | 09 |
| 装饰器 Decorator | 同一合同逐层叠加职责 | 09 |
| 外观 Facade | 提供简单的子系统入口 | 10 |
| 享元 Flyweight | 共享稳定内部状态 | 11 |
| 代理 Proxy | 以同一合同控制访问 | 10 |
| 职责链 Chain of Responsibility | 沿链处理或转发请求 | 15 |
| 命令 Command | 把请求封装为对象 | 14 |
| 解释器 Interpreter | 组合小文法并递归解释 | 17 |
| 迭代器 Iterator | 封装遍历,游标独立 | 16 |
| 中介者 Mediator | 集中多个组件的交互规则 | 13 |
| 备忘录 Memento | 封装可恢复状态快照 | 14 |
| 观察者 Observer | 管理一对多变化通知 | 13 |
| 状态 State | 当前状态决定行为和迁移 | 15 |
| 策略 Strategy | 组合替换算法 | 12 |
| 模板方法 Template Method | 固定流程,开放步骤 | 12 |
| 访问者 Visitor | 稳定结构上增加运算 | 16 |
19.3 “长得像”不等于同一意图
| 容易混淆的一对 | 问自己什么 | 辨析 |
|---|---|---|
| 策略/状态 | 谁决定切换,为什么切换? | 策略通常由外部选择算法;状态随对象生命周期迁移 |
| 装饰/代理 | 包装的主要目的是? | 叠加职责/控制访问 |
| 适配/外观 | 客户的合同发生什么变化? | 转换不兼容接口/提供更简单入口 |
| 桥接/策略 | 主要拆几个维度? | 两侧独立扩展/替换一组算法 |
| 原型/备忘录 | 复制为了什么? | 创建新实例/恢复原发器过去状态 |
int total(String type, int cents) {
if (type.equals("VIP")) return (int)(cents * 90L / 100);
return cents;
}interface PriceRule { int apply(int cents); }
int total(PriceRule rule, int cents) {
return rule.apply(cents);
}
// 选择逻辑在装配入口;参数与取整合同必须保持一致。19.9 随堂自测
课堂练习与记忆地图
学骑车不是背零件名,而是能起步、转弯、刹车。画图对应认识结构,跟踪调用对应骑行,失败验证对应刹车;边界:软件方案不止一种,作业按理由与行为评分,不按类名评分。
20.1 一张记忆地图
20.2 第一个可独立运行的小实验
把下面代码保存为 PatternLab.java,需要 Java 17+。实验与运行命令会随 Tab 一起切换,检查原价、九折和零金额;验证失败时会明确报错。
public class PatternLab {
interface Discount { int apply(int cents); }
record Checkout(Discount rule) {
int total(int cents) { return rule.apply(cents); }
}
static void check(boolean ok) {
if (!ok) throw new AssertionError("验证失败");
}
public static void main(String[] args) {
Checkout normal = new Checkout(c -> c);
Checkout vip = new Checkout(c -> (int)(c * 90L / 100));
check(normal.total(1000) == 1000);
check(vip.total(1000) == 900);
check(vip.total(0) == 0);
System.out.println("通过:1000 → 900,策略可替换");
}
}javac -encoding UTF-8 PatternLab.java
java PatternLab再试:新增“每单减 100 分,最低 0 分”的策略,并验证 50 分与 1000 分分别得到 0 与 900。这个极简实验只用非负输入;要迁入业务,补上第 12、18 章的参数和结果合同。
20.3 六道课堂任务:先作答,再展开参考
任务 1 · 新增推送通道,但结算业务不变
参考:提取通知合同,通过组合注入推送实现。若要同时通知多人,再引入观察者;不要因为新增一个通道就直接建复杂事件总线。验证新通道不影响结算输出。
任务 2 · 文件与文件夹统一计算大小
参考:组合。画出叶子与容器的 total 合同;验证空目录为 0、嵌套目录求和正确,并说明如何防止环。
任务 3 · 文本编辑支持连续撤销
参考:命令记录操作,必要时用备忘录保存前态。每次执行对应独立历史记录;定义撤销后重新输入时如何清理重做栈,限制历史占用。
任务 4 · 同一报表导出 PDF 与 HTML
参考:先确定变化轴。算法整体替换可用策略;固定“读数据→转换→输出”而步骤变化可用模板方法;若同一构建步骤生成不同复杂表示,也可讨论经典建造者。没有唯一答案,需说明合同与代价。
任务 5 · 渲染一百万个样式重复的字符
参考:评估享元。共享字体/字形等稳定内部状态,坐标与选中状态放上下文。先估算共享收益,再实测索引成本;并发与缓存上限需另外设计。
任务 6 · 观察者回调里退订自己
参考:可基于订阅列表快照分发。本次快照里的观察者仍可能收到本次事件,下次发布不再收到;异常隔离与重入规则须单独说明。
20.4 课堂安排与评分
| 轮次 | 练什么 | 完成标准 |
|---|---|---|
| 第一轮 · 01–03 | 画出依赖与变化边界 | 能区分组合与继承,解释 SOLID |
| 第二轮 · 04–07 | 从相同需求比较创建方案 | 能说明产品族和构建步骤不同 |
| 第三轮 · 08–11 | 画树、包装层和共享状态 | 能预测奶茶演示与共享修改风险 |
| 第四轮 · 12–17 | 跟踪事件、状态与递归 | 能解释退订、非法迁移与双分派 |
| 第五轮 · 18–20 | 完成订单练习与重构 | 至少验证正常、边界、失败三类输入 |
作业评分建议(100 分):变化问题 20,协作图与合同 25,实现与行为验证 30,代价及反例 25。自测答对不等于完成作业,能解释错误方案的后果才算掌握。