设计模式
CHAPTER 01 · 建立设计思维

从变化理解设计模式

一句话总览:设计模式为反复出现的协作问题命名:先找变化,再选择让变化局部化的结构。
💡
生活化类比 · 对应关系与边界
食谱是模式,厨房是业务,厨具是语言特性。食谱告诉你如何配合,不替你买菜;模式也不是复制就能运行的万能代码。

1.1 学习目标与路线

适合已理解类、接口、继承、多态的学生。示例支持 Java、Python、C++、C#、TypeScript、Go、Rust、Kotlin、Swift、Dart,默认 Java。点击任意代码区的语言 Tab,整份课程同步切换。除第 20 章完整实验外,每块是独立机制片段,不跨章拼接;图中的类名与方法名用于表达模式角色。金额统一用整数“分”。学完应能说明每种模式的变化点、协作关系和代价。

先问需求,再读结构
发现变化什么总在改?隔离变化接口 + 对象协作验证收益改动是否缩小?
好设计的标准是修改成本、可读性与正确性,而不是模式数量。
家族核心问题本课章节与数量
创建型对象如何产生?调用者要知道多少细节?04–07 · 5 种
结构型对象如何组合,形成可替换的结构?08–11 · 7 种
行为型职责、算法、通知如何分配?12–17 · 11 种
当前示例语言:Java。

1.2 跟踪一次多态调用

读代码:先接口,再持有者,最后调用
Java 17+ · 独立机制片段
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 合同。后续章节会回答:实现由谁创建?能否加日志?能否通知多人?这些是不同变化轴,不应混为同一问题。

⚠ 错误 → 后果 → 正确姿势
看到一个 if 就建立十个策略类 → 概念数量增加,简单需求反而难读 → 先保留清晰分支,等替换、测试或重复变化有明确收益时再抽象。
✓ 记忆锚点
23 个模式,就是 23 个“把谁和谁分开”的办法。
使用说明
左侧按标题及关键词搜索,支持英文模式名。每章可打卡,在当前浏览器保存进度;自测选完显示解析,刷新可重答。三个演示可重置,演示状态不保存。手机上可在图解或演示区域内左右滑动查看完整结构。

1.9 随堂自测

QUIZ 1
新增短信发送方式,最值得检查的变化点是?
把发送能力与具体通道分开,调用者才能复用。改名或堆继承层级不能隔离通道变化。
QUIZ 2
一个从不变化的两分支函数,清晰且易测,应如何处理?
模式有对象数量和理解成本。抽象应回应实际变化,而不是为了凑齐模式。
CHAPTER 02 · 建立设计思维

SOLID:五条设计检查线

一句话总览:SOLID 让变化有边界、替换守合同、依赖朝抽象,并不要求每个类都越小越好。
💡
生活化类比 · 对应关系与边界
学校里教师管教学、财务管收费;岗位说明对应接口,换老师对应替换实现。边界:现实岗位可临时兼任,程序合同却不能依赖临场商量。

2.1 S · 单一职责:按变化原因划边界

SRP:模块对一类变化原因负责。报表计算与 PDF 排版由不同诉求驱动,分开后改字体不用动计费规则。不是“每个类只能有一个方法”。

SRP:计算与排版分开变化
业务规则变ReportCalculator数据结果ReportData版式要求变PdfRenderer
结果数据连接两个职责,计算与排版各有变化边界。

2.2 O · 开闭原则:给已知变化留下扩展点

OCP:对扩展开放,对修改关闭。新增折扣可以增加实现,但装配策略的入口仍可能变化;没有设计能保证永远不改旧代码。

OCP:保持调用者稳定
Checkout依赖 DiscountDiscount 合同约定计价行为新增会员折扣扩展实现
稳定的是结算流程,扩展的是折扣算法。

2.3 L · 里氏替换:行为合同高于继承语法

LSP:子类型应能替换父类型,不加强前置条件、不削弱后置条件、不破坏不变量。父类型承诺可写,子类却总抛异常,仍属于违约。

LSP:替换后仍要兑现承诺
调用者save(data)可写存储合同成功后能读回文件存储守住承诺只读存储冒充拒绝所有写入
只读能力应由 Readable 接口表达,不能冒充可写对象。

2.4 I · 接口隔离:只依赖需要的能力

ISP:只会打印的设备不应被迫实现 scan()。划分 Printer 与 Scanner 后,多功能机可同时实现两个接口。接口按客户需求划分,不按“凑够方法数”划分。

ISP:拆开无关能力
旧设备合同print + scan拆分能力Printer / Scanner普通打印机只实现 Printer
避免不支持的方法变成运行时异常。

2.5 D · 依赖倒置:业务与细节都依赖合同

DIP:高层策略不依赖底层细节,两者依赖抽象。依赖注入是传入依赖的手法;若注入具体数据库类,仍可能没有依赖倒置。

DIP:源码依赖朝向抽象
使用实现订单业务高层策略OrderStore业务所需合同SqlOrderStore存储细节
图示为源码依赖方向;运行时仍由业务调用存储实现。
构造器接收抽象合同
Java 17+ · 独立机制片段
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); }
}
⚠ 错误 → 后果 → 正确姿势
给每个类机械添加同名接口 → 文件翻倍却没有稳定合同 → 先识别需要替换、隔离或测试的边界,再定义能力接口。
✓ 记忆锚点
S 管原因,O 管扩展,L 守承诺,I 分能力,D 倒依赖。

2.9 随堂自测

QUIZ 1
父接口承诺可写,子类每次写入都抛“不支持”,最直接违反?
替换后写入承诺失效。签名兼容不足以保证行为兼容。
QUIZ 2
构造器传入 SqlStore,业务仍调用 SQL 专有方法,说明什么?
注入描述对象怎样传入,依赖倒置描述源码依赖谁,两者不能画等号。
CHAPTER 03 · 建立设计思维

读懂协作图与组合

一句话总览:读图先问谁持有谁、谁调用谁、谁可以替换谁,再看类名。
💡
生活化类比 · 对应关系与边界
主机“有一个”手柄是组合,赛车“是一种”载具是继承。换手柄对应替换协作者;边界:软件对象可被共享,现实物件不足以解释所有权与生命周期。

3.1 本课的图怎样读

符号/布局含义注意
实线箭头 + 调用标签持有引用或调用方向以标签为准,不推断生命周期
虚线 + 实现标签类型实现某接口是契约关系,不代表发送消息
分叉/汇合多个实现或多路协作不自动表示并发
嵌套框包装或包含关系调用顺序须另看箭头

本课主要用协作示意图,不全是正式 UML。正式 UML 的空心三角表示继承/实现,实心菱形表示组合,空心菱形表示聚合,菱形位于整体一端;普通箭头不要误认成继承。

组合:把通知方式从订单类型中分离
继承扩张邮件订单 / 短信订单再加会员身份组合数量继续增加OrderService持有 NotifierEmailNotifier替换对象SmsNotifier替换对象
独立变化轴用组合拆开;不是把所有继承都删掉。

3.2 组合优先,继承有条件

同一个业务对象可换协作者
Java 17+ · 独立机制片段
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.address.region.manager;并非禁止所有链式调用。

3.3 小步重构

先固定行为,再改变结构
记录输入输出覆盖关键行为提取变化点引入最小接口验证行为不变再比较修改成本
重构不改变外部行为;新增功能与结构调整应分别理解。
⚠ 错误 → 后果 → 正确姿势
只为复用几行代码而继承 → 子类被迫接受不合适的父合同 → 先提取协作者或函数,真正“是一种”且守合同才继承。
✓ 记忆锚点
继承说“我是谁”,组合说“我借谁的能力”。

3.9 随堂自测

QUIZ 1
服务持有 Notifier 并能替换邮件/短信实现,主要使用?
业务把通知委托给协作者,通过共同合同调用,不靠派生服务类复用。
QUIZ 2
本课图中一条普通箭头,能否直接认定为继承?
普通协作箭头需要看标签;正式 UML 继承使用空心三角,语义不能混用。
CHAPTER 04 · 创建型:对象怎样出生

单例:唯一实例与边界

一句话总览:单例(Singleton)约束一个作用域内只有一个实例,但不自动保证业务线程安全。
💡
生活化类比 · 对应关系与边界
班级值日表只有一本,大家从同一入口查看。唯一登记本对应唯一实例;边界:多校区可能各有一本,对应不同进程或类加载器,不能宣称全世界只有一个。

4.1 让“创建权”集中起来

角色:Singleton 自己控制创建入口,Client 只能取得同一对象。适合明确需要唯一身份、生命周期稳定的协调对象;若只是共享一份配置,用不可变对象和显式注入常常更简单。

两个调用者得到同一个枚举实例
调用者 AConfig.INSTANCE调用者 BConfig.INSTANCEConfig.INSTANCE同一身份不可变字段env = demo
唯一身份由初始化机制提供;字段是否可安全共享仍需独立设计。
单例:统一配置入口
Java 17+ · 独立机制片段
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); // true

4.2 三种选择,别背成一种

写法创建时机与性质注意
static final 饿汉式类初始化时创建,初始化有 JVM 保证可能提早持有资源
静态内部类 Holder首次使用 Holder 时初始化仍受类加载器作用域限制
enum 枚举枚举常量初始化,由 JVM 管理适合无复杂继承要求的唯一对象

本课选 enum 展示机制。它不能替代数据库锁、分布式协调,也不保证实例方法里修改的集合安全。单例还会隐藏依赖,使测试互相污染;可由应用装配层创建一份普通对象并注入来替代。

⚠ 错误 → 后果 → 正确姿势
在单例中执行 count++ 并以为天然安全 → 并发更新可能丢失 → 优先不可变字段,确需共享修改时另用锁或原子操作,并明确重置与测试隔离。
✓ 记忆锚点
“一个对象”是身份约束,“一起访问安全”是并发约束。

4.9 随堂自测

QUIZ 1
enum 单例中放一个可变 ArrayList,多线程写入是否自动安全?
JVM 保证枚举常量初始化,不替业务方法同步。共享可变集合仍可能数据竞争。
QUIZ 2
两个不同进程各有一个 Config.INSTANCE,是否违背本例保证?
单例有作用域边界。跨进程唯一性属于分布式协调问题。
CHAPTER 05 · 创建型:对象怎样出生

工厂方法:延迟选择产品

一句话总览:工厂方法(Factory Method)让稳定业务流程调用创建钩子,由子类决定具体产品。
💡
生活化类比 · 对应关系与边界
饮品店总部规定“取杯→装饮料→出杯”,各分店决定用哪种杯。总店流程对应 Creator,选杯钩子对应工厂方法;边界:真实分店能随意改流程,代码中应明确哪些步骤允许覆盖。

5.1 先看稳定流程,再看创建钩子

角色:Product 是产品合同;ConcreteProduct 实现合同;Creator 使用产品但把创建交给工厂方法;ConcreteCreator 覆盖创建逻辑。调用顺序:client → deliver() → create() → product.send()。

Creator 的流程不变,子类改变创建结果
调用Delivery.deliver()稳定流程create()可覆盖的创建钩子RoadDelivery创建 TruckSeaDelivery创建 Ship
变化落在创建方法,运输流程通过 Product 合同使用结果。
Creator + 一个具体创建者
Java 17+ · 独立机制片段
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 种之一。

⚠ 错误 → 后果 → 正确姿势
把任何名叫 create 的静态函数都称为 GoF 工厂方法 → 讲不清扩展点在哪 → 检查是否由子类覆盖创建钩子,别只看方法名。
✓ 记忆锚点
工厂方法:流程留在父类,产品交给子类。

5.9 随堂自测

QUIZ 1
给 Delivery 增加空运而保持 deliver 流程不变,合理扩展是?
新增创建者覆盖创建钩子,原流程继续通过 Transport 使用产品。调用者分支会重新传播变化。
QUIZ 2
一个静态函数 switch(type) 返回具体产品,通常属于?
集中分支创建一般称简单工厂。GoF 工厂方法强调通过可覆盖创建方法让子类决定产品。
CHAPTER 06 · 创建型:对象怎样出生

抽象工厂:成套产品一起换

一句话总览:抽象工厂(Abstract Factory)提供一整族相关产品,让调用者整体切换兼容组合。
💡
生活化类比 · 对应关系与边界
买同系列桌椅,商店给出“北欧套装”或“古典套装”。风格对应产品族,桌/椅对应产品种类;边界:现实中能混搭,代码是否禁止混搭要靠装配约束或类型设计。

6.1 两个维度:新增一族,还是新增一种产品

产品矩阵:换一列容易,加一行要修改工厂合同
客户端只认 UiFactoryLightFactory浅色产品族DarkFactory深色产品族LightButtonLightCheckBoxDarkButtonDarkCheckBox
同一工厂产出兼容的一族;新增 Slider 会影响所有工厂实现。
一个合同同时创建两类产品
Java 17+ · 独立机制片段
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 及所有实现横向扩展成本高
客户自己混用不同工厂产品可能打破兼容关系装配处集中选择一套工厂
⚠ 错误 → 后果 → 正确姿势
创建按钮用 DarkFactory,创建勾选框又临时 new LightCheckBox → 成套兼容性失守 → 在装配入口选定同一个工厂;若必须从类型上禁止混搭,再加强产品族类型约束。
✓ 记忆锚点
工厂方法换“一个产品的创建方式”,抽象工厂换“一套产品的家族”。

6.9 随堂自测

QUIZ 1
UiFactory 已有 button 与 checkBox,新增 Slider 的主要代价是?
抽象工厂擅长增加产品族;增加产品种类会扩展工厂接口并影响每个族。
QUIZ 2
此模式最直接隔离哪种变化?
客户端只依赖产品族工厂和产品合同,整体替换一族实现。遍历、状态和日志不是这里的主要变化轴。
CHAPTER 07 · 创建型:对象怎样出生

建造者与原型:组装或复制

一句话总览:建造者分离分步组装,原型通过已有对象复制;它们回答不同的创建问题。
💡
生活化类比 · 对应关系与边界
点套餐时逐项选主食/饮料,对应 Builder;复印一张已填表格再改姓名,对应 Prototype。边界:纸张复印会复制内容,软件浅拷贝却可能仍共用同一个可变子对象。

7.1 建造者 Builder:把有效性检查集中到出口

痛点:参数过多,连续位置参数容易传错。角色:Builder 收集步骤,Product 是成品,可选 Director 编排固定步骤。链式调用是常见写法,并不是模式定义;经典建造者还可用相同构建步骤生成不同表示。

Builder:零散选择先暂存,再一次产出
构建器收集 room / seatsbuild()检查不变量不可变成品Meeting 对象
构建中间态不暴露为成品;无效组合在 build 处被拒绝。
Builder:最小的带校验组装
Java 17+ · 独立机制片段
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 构造器也必须守住不变量。

⚠ 错误 → 后果 → 正确姿势
构建器每次返回同一个可变 Product → 下次修改构建器,已交付成品也变化 → build 创建独立成品,必要时复制集合,并让成品自身验证不变量。

7.2 原型 Prototype:复制的是对象图,而不只是外壳

角色:Prototype 暴露 copy 合同,具体原型决定如何复制;客户从样板产生新实例。适合初始状态复杂或运行时才知道具体类型的对象。复制成本和共享策略必须讲清。

浅拷贝共享可变列表,选择性深拷贝隔离列表
原对象tags 引用浅拷贝对象tags 引用同一份列表修改会互相可见选择性深拷贝复制列表容器另一份列表String 元素可共享
本例元素 String 不可变,复制容器即可;可变元素需要继续定义复制策略。
原型:显式复制独立状态
Java 17+ · 独立机制片段
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.tags
⚠ 错误 → 后果 → 正确姿势
直接复制 List 引用并声称深拷贝 → 修改副本标签会污染原对象 → 复制可变容器;若元素也可变,再逐元素复制。文件句柄、线程等资源不可想当然复制。
✓ 记忆锚点
Builder 从“步骤”造新物;Prototype 从“样板”造新物。

7.9 随堂自测

QUIZ 1
复制 ArrayList<MutableItem> 时只 new ArrayList<>(old),会怎样?
新容器有独立增删结构,但可变元素引用仍共享。是否继续复制取决于需要隔离哪一层。
QUIZ 2
Builder 最值得集中校验的位置是?
build 是由中间态转成品的边界;若可绕过 Builder,Product 自身也应校验。只依赖调用顺序容易漏检。
CHAPTER 08 · 结构型:对象怎样搭配

适配器与桥接:接口和维度

一句话总览:适配器让已有接口能合作,桥接让两个独立维度能分别扩展。
💡
生活化类比 · 对应关系与边界
转换插头把旧接口接到新插座,是适配器;遥控器种类与电视品牌分开组合,是桥接。边界:电压、安全性和行为语义不会因插头能插上就自动匹配。

8.1 适配器 Adapter:把合同翻译完整

角色:Client 认 Target;Adapter 实现 Target 并持有 Adaptee。调用链:客户 → 新接口 → 适配器转换 → 旧接口。对象适配通过组合实现;类适配通常借继承,受语言限制。

Adapter:新合同转为已有 API
客户要 charge单位:分PayAdapter分转元、转方法名LegacyPaypayYuan(BigDecimal)
转换包含数据单位和行为语义,不能只改方法名称。
把整数分转换为精确的元
Java 17+ · 独立机制片段
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));
  }
}

适用:接入旧库/第三方系统。代价:多一层映射,要处理单位、异常与返回值含义;无法兼容的语义不能靠包装硬装成兼容。

⚠ 错误 → 后果 → 正确姿势
直接把 199 分传给接受元的旧接口 → 实际扣成 199 元 → 在适配边界明确单位、精度、异常与幂等语义,覆盖边界值。

8.2 桥接 Bridge:两个轴各自成长

角色:Abstraction 持有 Implementor;两边分别有扩展类型。例如消息级别普通/紧急,与发送通道邮件/短信独立变化,不必创建四种组合子类。

Bridge:消息类型 × 发送通道分开扩展
普通消息抽象侧紧急消息抽象侧Channel 接口实现侧桥梁邮件通道具体实现短信通道具体实现
新增消息级别不用复制所有通道;新增通道也不复制消息类。
桥的核心就是持有实现侧合同
Java 17+ · 独立机制片段
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 随堂自测

QUIZ 1
旧库按元收费,新业务按分计价,首先需要?
接口转换必须包含单位语义,分与元相差百倍。模式不能只完成名字翻译。
QUIZ 2
普通/紧急消息与邮件/短信各自扩展,最贴近?
这里有两个独立维度,桥接让两边分别扩展并通过引用组合。
CHAPTER 09 · 结构型:对象怎样搭配

组合与装饰器:树和层

一句话总览:组合让叶子与整体统一操作,装饰器让同一对象按层叠加能力。
💡
生活化类比 · 对应关系与边界
文件夹里既有文件又有子文件夹,对应组合;奶茶逐层加珍珠、奶盖,对应装饰。边界:奶茶配料可混合,代码包装却有调用顺序,顺序可能改变结果。

9.1 组合 Composite:把“整体”也当节点

角色:Component 统一操作;Leaf 直接执行;Composite 持有子节点并递归委托。适合目录、组织树、菜单树;代价是统一接口可能难以表达叶子独有操作。

Composite:同一个 total() 沿树递归
根目录 total()汇总子节点文件 A:10叶子直接返回子目录继续递归文件 B:20叶子直接返回
根目录得到 10 + 20 = 30;客户不需要分辨叶子还是容器。
只把公共读取能力放进节点合同
Java 17+ · 独立机制片段
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();
  }
}
⚠ 错误 → 后果 → 正确姿势
让叶子也实现 addChild 并总抛异常,或允许目录加入自身 → 合同失真或递归不终止 → 公共接口只放共同操作,修改树时检查环;本例用不可变子列表简化结构。

9.2 装饰器 Decorator:一层包一层,合同不变

角色:Component 是同一合同;ConcreteComponent 给出基础能力;Decorator 持有 Component,在委托前后增加行为。适合压缩流、计费附加项。代价是嵌套层多、调试栈长,顺序需要明确。

Decorator:调用向内,结果向外累加
奶盖装饰器外层 +300珍珠装饰器内层 +200基础奶茶返回 1000
cost 调用向内深入,返回时叠加;金额单位均为分。
每层都实现 Drink,可继续被包装
Java 17+ · 独立机制片段
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() == 1500
HANDS-ON DEMO · 动手实验
奶茶包装实验
先预测调用顺序,再添加配料或移除外层。每次重绘展示包装关系与返回时的金额变化(最多 4 层配料)。
⚠ 错误 → 后果 → 正确姿势
认为所有装饰器顺序都无关 → 先打折再加配送费与先加配送费再打折可能金额不同 → 明确包裹顺序及每层的输入输出;本演示只做加法,恰好可交换。
✓ 记忆锚点
组合向“下”长出树,装饰向“外”包成层。

9.9 随堂自测

QUIZ 1
目录与文件都可 total(),目录对孩子递归求和,属于?
整体与叶子通过同一合同处理,整体递归汇总孩子,这是组合。包装单个对象叠加能力属于装饰。
QUIZ 2
装饰器先加费再打折,与先打折再加费,结果?
顺序可能改变输出。当前奶茶演示只累加费用,不代表所有装饰都可交换。
CHAPTER 10 · 结构型:对象怎样搭配

外观与代理:简化或把关

一句话总览:外观提供更简单的子系统入口,代理以同一合同控制目标访问。
💡
生活化类比 · 对应关系与边界
酒店前台替你协调客房/餐饮,是外观;门禁核实身份后才开门,是代理。边界:前台不自动保证所有服务原子完成,门禁也不能改变房间本身的业务承诺。

10.1 外观 Facade:缩小客户需要知道的范围

角色:Facade 编排多个 Subsystem;Client 只调用更贴近任务的入口。适合屏蔽接入复杂度;代价是入口可能膨胀,需按任务拆分。子系统仍可被其他合法客户直接使用。

Facade:客户从多个细节调用收敛到一个任务入口
客户placeOrder()OrderFacade编排下单任务库存服务预留订单服务创建通知服务发送
简化调用不等于获得事务保证;失败恢复仍需业务设计。
把子系统协作封装成任务
Java 17+ · 独立机制片段
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 仅代替真实子系统,突出编排关系。
⚠ 错误 → 后果 → 正确姿势
把多个远程调用放进 Facade 就宣称事务成功 → 第三步失败时前两步可能已提交 → 明确事务边界、补偿与重试策略;外观只负责简化入口。

10.2 代理 Proxy:客户仍面对原合同

角色:Subject 约定业务能力,RealSubject 真正执行,Proxy 同样实现 Subject 并决定是否/何时转发。适合权限、延迟加载、远程访问或缓存。代价是隐藏的延迟、失败与一致性问题。

Proxy:代理先判断,再决定是否转发
客户Doc.read()GuardProxy检查访问权限RealDoc真正读取
代理与真实对象实现同一合同;拒绝与失败语义必须明确。
只读文档的权限代理
Java 17+ · 独立机制片段
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 随堂自测

QUIZ 1
Facade 依次扣库存、建订单、发通知,是否自动具备原子性?
方法编排不会自动回滚已完成的远程副作用。事务和补偿是额外业务机制。
QUIZ 2
Proxy 与 Decorator 最可靠的区分依据是?
两者结构常相似,模式识别要看变化与设计目的,不能仅靠外观结构。
CHAPTER 11 · 结构型:对象怎样搭配

享元:共享稳定的内部状态

一句话总览:享元(Flyweight)把大量相似对象的稳定内部状态共享,把位置等外部状态留给调用者。
💡
生活化类比 · 对应关系与边界
一枚字模能在很多位置印同一个字:字形对应内部状态,纸上坐标对应外部状态。边界:共享字模不是让所有字拥有同一个位置;共享可变位置会把整页文字拖到一起。

11.1 先拆状态,再谈共享

Flyweight:多个使用上下文指向同一份字形
使用位置 1A,x=10 y=20使用位置 2A,x=30 y=20使用位置 3A,x=50 y=20共享 Glyph(A)内部状态:字形FlyweightFactory按字符索引
每个位置单独保留,昂贵且相同的字形仅存一份。
状态本例放置位置
内部状态 intrinsic字符形状、字体与样式等稳定信息共享 Glyph,尽量不可变
外部状态 extrinsicx / y、具体使用上下文由客户传入或放独立上下文
共享索引字符键到 Glyph 的映射享元工厂;真实键需含所有影响外观的字段
单线程演示:共享字形,不共享位置
Java 17+ · 独立机制片段
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 保存外部状态。适合对象数量极大、重复状态占内存明显、可以拆出外部状态的情况。代价:共享索引、查找成本与状态拆分复杂度;少量轻对象可能不划算。

概念复用什么关键区别
享元相同内部状态的对象多个上下文可同时共享
对象池可借用的昂贵对象常有借出/归还及排他使用
普通缓存计算或读取结果未必有内部/外部状态拆分
⚠ 错误 → 后果 → 正确姿势
把 x、y 写进共享 Glyph 后每次修改 → 所有使用者互相覆盖位置 → 共享对象只放稳定内部状态,坐标在 draw 时传入;并发时也需保护工厂索引,且限制缓存增长。
✓ 记忆锚点
形状可以共用,位置必须各有。

11.9 随堂自测

QUIZ 1
编辑器有一万个 A,享元最应共享哪项?
字形是稳定内部状态,位置、选中状态与行号属于使用上下文,不能混入共享对象。
QUIZ 2
使用享元后内存是否必然下降?
少量轻对象的索引成本可能超过节省。享元需要大量重复的内部状态才能显示优势。
CHAPTER 12 · 行为型:职责怎样流动

策略与模板方法:换算法或步骤

一句话总览:策略通过组合替换整段算法,模板方法通过继承固定流程并开放步骤。
💡
生活化类比 · 对应关系与边界
去学校可选步行/骑车,对应策略;考试固定“发卷→答题→收卷”,各科题目不同,对应模板方法。边界:现实流程可临时改,代码中必须说明哪些步骤不能跳过。

12.1 策略 Strategy:把算法作为对象传入

角色:Context 持有 Strategy,ConcreteStrategy 实现算法;客户或装配层选择策略。适合折扣、排序规则、路线选择。代价:客户要理解策略差异,策略数量与装配复杂度可能增加。

Strategy:Context 委托一个可替换算法
Checkout结算上下文Discount算法合同原价策略cents → cents九折策略cents → 90%
算法由外部选择,结算对象只调用共同合同。
策略:传入可替换算法
Java 17+ · 独立机制片段
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); // 900
⚠ 错误 → 后果 → 正确姿势
声称用了策略就不再需要选择逻辑 → 选择分支散落到调用者 → 把选择集中在装配/配置入口,Context 专心执行算法;还要统一金额取整与有效输入合同。

12.2 模板方法 Template Method:骨架不可跳,步骤可变化

角色:AbstractClass 的模板方法调用若干原语步骤;ConcreteClass 实现步骤,钩子可提供可选扩展。适合导入流程、测试生命周期。代价:继承耦合较强,父流程变更影响所有子类。

Template Method:外层流程固定,内部步骤可变
run() 模板固定执行顺序read()子类提供输入convert()子类提供转换输出结果模板统一收尾
模板方法固定顺序;扩展点是其中的步骤。
模板方法:固定骨架与可变步骤
Java 17+ · 独立机制片段
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(",", " | ");
  }
}
⚠ 错误 → 后果 → 正确姿势
子类覆盖整个 run 并跳过校验/收尾 → 流程约束失效 → 模板方法按需要设 final,只暴露真实扩展点;资源释放用 try/finally 等明确机制。
✓ 记忆锚点
策略把算法“换进去”,模板把步骤“填进去”。

12.9 随堂自测

QUIZ 1
希望运行时在九折与原价之间选择,优先考虑?
算法可通过组合传入并替换,不必为每种折扣派生业务类。
QUIZ 2
模板方法中最应固定的是?
模板固定算法骨架,子类实现允许变化的步骤;否则流程约束无法成立。
CHAPTER 13 · 行为型:职责怎样流动

观察者与中介者:广播和协调

一句话总览:观察者组织一对多变化通知,中介者集中多个同事之间的交互规则。
💡
生活化类比 · 对应关系与边界
订阅校园广播是观察者,塔台协调飞机是中介者。订阅者对应监听对象,塔台对应协调中心;边界:广播不天然可靠送达,塔台也不是接管所有飞机内部操作的上帝对象。

13.1 观察者 Observer:发送者不用认识具体接收者

角色:Subject 管理订阅并在变化后通知;Observer 约定回调。调用链:订阅 → 发布 → 遍历订阅快照 → 回调。适合界面更新、领域事件。代价是调用关系隐蔽、退订管理与重入问题。

Observer:一次发布扇出到当前订阅者
Subjectpublish(事件)订阅列表快照按本次名单分发库存屏回调邮件模块回调日志模块回调
发送者依赖观察者合同,不必写死每个接收者。
同步观察者:快照迭代 + 显式退订
Java 17+ · 独立机制片段
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);
  }
}
// 本例同步、单线程;回调抛错会中断后续通知。
HANDS-ON DEMO · 动手实验
校园广播订阅实验
三个接收者初始全部订阅。先发布,再退订邮件或库存屏,观察“本次参与名单”。每个接收者旁记录累计收到的次数。
⚠ 错误 → 后果 → 正确姿势
注册后永不退订,或以为回调一定异步可靠 → 对象被长期引用、一个慢回调阻塞发布 → 生命周期结束时退订,明确同步/异步、异常隔离与顺序合同。快照只解决遍历时名单变化,不自动保证线程安全。

13.2 中介者 Mediator:把网状关系收到协调中心

角色:Colleague 只报告事件给 Mediator;中介者决定影响哪些其他组件。适合表单联动、聊天室协调。代价是协调中心可能变成巨大条件分支,需要按交互任务划分。

Mediator:组件报告事件,中介者决定联动
输入框内容变化Dialog 中介者决定提交条件提交按钮启用 / 禁用提示标签显示校验反馈
输入框不直接认识按钮与标签,联动规则由对话框集中维护。
输入组件只报告事件,Dialog 决定 UI 状态
Java 17+ · 独立机制片段
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 绘制。辨析:观察者强调通知依赖,中介者强调协调规则;中介者完全可以用观察者机制接收事件。

⚠ 错误 → 后果 → 正确姿势
把所有业务判断和存储操作都塞进一个 Mediator → 网状复杂度只是搬进巨类 → 按一组紧密交互的组件建立中介者,内部继续委托领域服务。
✓ 记忆锚点
观察者“我变了,通知你”;中介者“你说了,我来协调”。

13.9 随堂自测

QUIZ 1
同步通知时第二个观察者抛异常,当前示例会怎样?
例中没有 catch,异常会中断遍历。观察者模式本身不承诺隔离、异步或可靠投递。
QUIZ 2
表单中输入框变化后统一控制按钮和提示,最直接的协调角色是?
中介者集中组件联动规则;组件不用互相知道对方。事件接收也可以通过观察者实现。
CHAPTER 14 · 行为型:职责怎样流动

命令与备忘录:请求和快照

一句话总览:命令把请求变成对象,备忘录在不泄露内部表示的前提下保存可恢复状态。
💡
生活化类比 · 对应关系与边界
餐厅点菜单是命令,草稿存档是备忘录。点菜单对应“要做什么”,存档对应“当时是什么”;边界:撤销菜单记录不会自动把已经吃掉的菜恢复,外部副作用通常需要补偿。

14.1 命令 Command:调用者只管触发

角色:Invoker 触发 Command,ConcreteCommand 保存 Receiver 与参数,Receiver 执行真正业务,Client 负责装配。适合队列、按钮绑定、操作历史。代价是命令对象增多,以及历史生命周期管理。

Command:触发与执行细节分离
Remote触发请求OnCommand保存灯的引用Lamp执行状态修改
命令可被排队和记录,但撤销能力必须额外实现。
每次执行记录旧值,演示一次撤销
Java 17+ · 独立机制片段
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 保存历史而不修改其内容。适合编辑器、小游戏存档。代价是快照占内存、复制成本与版本兼容性。

Memento:只有原发器解释内部快照
创建保存取回后交还 restoreEditor 原发器save / restoreSnapshot封装私有状态历史看管者持有与取回令牌
看管者负责顺序,原发器负责理解与恢复内容。
备忘录:保存独立快照
Java 17+ · 独立机制片段
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 时恢复。需要跨实例使用时应校验快照所属对象;真实文档还需规定光标、选区是否属于恢复范围。

⚠ 错误 → 后果 → 正确姿势
快照直接保存一个会继续修改的 List 引用 → “旧快照”跟着变,撤销失真 → 对可变状态复制或使用不可变版本;限制历史长度,并对不可逆外部操作设计补偿。
✓ 记忆锚点
命令记“做什么”,备忘录记“曾是什么”。

14.9 随堂自测

QUIZ 1
把同一个可变 List 引用存进每份备忘录,最大的风险是?
多个快照别名指向同一可变数据,后续修改会污染过去。需复制相关状态或使用不可变结构。
QUIZ 2
发送邮件的命令执行后,undo 应如何理解?
模式把请求对象化,不消除外部副作用。已送达消息一般无法像内存变量一样恢复。
CHAPTER 15 · 行为型:职责怎样流动

状态与职责链:迁移和传递

一句话总览:状态让当前状态决定行为和迁移,职责链让请求沿可组合处理者传递。
💡
生活化类比 · 对应关系与边界
自动售货机投币前后按钮效果不同,是状态;报销按金额交给不同审批人,是职责链。边界:现实机器有并发与硬件故障,示意状态机不会自动解决这些问题。

15.1 状态 State:把行为分散到状态对象

角色:Context 持有 State 并委托事件;ConcreteState 执行状态相关行为,可通过 Context 转移状态。适合对象行为随阶段变化且分支复杂的场景;代价是状态类/转换规则增多。

State:合法事件才允许状态迁移
payship跳过支付发货:拒绝,状态不变待支付 NEW可以 pay已支付 PAID可以 ship已发货 SHIPPED终态示例
红色虚线路径表示被拒绝的尝试,不是实际迁移。
状态:由当前状态处理事件
Java 17+ · 独立机制片段
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;生产系统需另外设计持久化与并发校验。

HANDS-ON DEMO · 动手实验
订单状态机实验
先尝试“发货”,再按“支付→发货”操作。取消仅允许在待支付阶段;已支付订单退款属于另一条业务流程,本模型不包含它。
⚠ 错误 → 后果 → 正确姿势
只改状态标签,不检查事件是否合法 → 未支付也能发货或重复扣款 → 状态内定义允许行为,对非法事件拒绝且保持状态;持久化时再加并发与幂等约束。

15.2 职责链 Chain of Responsibility:每站处理或转交

角色:Handler 定义处理入口与后继,ConcreteHandler 决定本次处理/转发,Client 组装链。适合审批、日志级别、过滤流程。代价是链路难追踪、可能无人处理;须规定短路或继续语义。

职责链:本例找到首个可处理者就停止
组长 ≤1000超出则转交经理 ≤5000超出则转交总监 ≤10000超出则拒绝
顺序与阈值决定谁处理;不是所有链都必须只有一个处理者。
明确链尾拒绝,避免请求悄悄丢失
Java 17+ · 独立机制片段
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); // 经理
⚠ 错误 → 后果 → 正确姿势
默认每个 Handler 都会继续,或链尾直接返回空值 → 重复处理或请求静默丢失 → 明确每站“处理后停止/继续”合同,并设计链尾兜底,组装时防环。
✓ 记忆锚点
状态问“我现在是谁”,职责链问“下一站找谁”。

15.9 随堂自测

QUIZ 1
当前待支付,收到发货事件,按本课合同应怎样?
非法事件不应推进状态。演示会解释拒绝原因,持久化与并发控制另行设计。
QUIZ 2
本例审批链超过所有阈值时?
职责链可能无人处理,链尾必须有明确结果。模式本身不保证一定找到处理者。
CHAPTER 16 · 行为型:职责怎样流动

迭代器与访问者:遍历和运算

一句话总览:迭代器把怎样走过集合藏起来,访问者把在稳定结构上做什么运算抽出来。
💡
生活化类比 · 对应关系与边界
博物馆导览路线像迭代器;同一批展品交给估价员或修复员检查像访问者。边界:路线不保证展品永远不变,新增一类展品也会让所有专家补充处理知识。

16.1 迭代器 Iterator:每次遍历有自己的游标

角色:Aggregate 提供迭代器,Iterator 约定 hasNext / next,ConcreteIterator 保存遍历状态。适合统一遍历不同集合。代价是游标对象与结构修改规则;多个迭代器不应意外共用同一游标。

Iterator:相同集合、两个独立游标
集合快照 [A,B,C]不暴露内部存储迭代器 1index = 1迭代器 2index = 0
遍历状态在迭代器中,不在集合上设置唯一“当前元素”。
快照迭代器:复制后遍历固定序列
Java 17+ · 独立机制片段
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++);
      }
    };
  }
}
⚠ 错误 → 后果 → 正确姿势
遍历中随便从原集合删除元素 → 可能跳项或触发并发修改异常 → 使用集合允许的 Iterator.remove 或明确的快照/并发容器合同;fail-fast 只是尽力检测,不是线程安全保证。

16.2 访问者 Visitor:结构稳定时,增加新运算

角色:Element.accept 接收 Visitor;具体元素调用 visitor.visit(this);不同 Visitor 实现求值、打印等运算。适合稳定的 AST 或文档节点结构;代价是新增元素类型会影响全部访问者,还可能暴露元素信息。

Visitor 双分派:先选元素,再选匹配的 visit
element.accept(v)运行时选择元素实现v.visit(this)this 类型决定重载具体 Visitor执行对应运算
Java 中重载由编译期静态类型选择;具体 accept 中的 this 明确了节点类型。
同一棵表达式树,可增加 Sum / Print 等访问者
Java 17+ · 独立机制片段
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 递归。

⚠ 错误 → 后果 → 正确姿势
节点类型经常增加仍坚持 Visitor → 每次新增节点都得修改全部访问者 → 先确认结构稳定且新运算常增加,再选择访问者;小结构直接节点方法往往更清楚。
✓ 记忆锚点
迭代器管“怎么走”,访问者管“走到后做什么”。

16.9 随堂自测

QUIZ 1
同一集合同时开启两次独立遍历,游标应放哪?
每次遍历应持有独立游标,否则嵌套或并行遍历会互相干扰。
QUIZ 2
Visitor 结构下新增一种节点类型,通常会?
访问者擅长在稳定元素结构上增加新运算;新增元素种类会扩展 visit 集合,影响已有访问者。
CHAPTER 17 · 行为型:职责怎样流动

解释器:把规则变成表达式树

一句话总览:解释器(Interpreter)把小语言的文法规则映射为表达式对象,递归解释语法树。
💡
生活化类比 · 对应关系与边界
搭积木算式:数字块和变量块是叶子,加法块连接两块并求和。边界:积木拼好了不等于能自动识别文字输入,解析字符串成树是另一个步骤。

17.1 从文法到对象:解释不等于解析

本例文法:Expr := Int | Variable | (Expr + Expr)。角色:AbstractExpression 定义 interpret;TerminalExpression 处理数字/变量;NonterminalExpression 组合子表达式;Context 保存变量值。

Interpreter:解释 (x + 10),上下文 x=5
Plus.interpret(ctx)递归解释两侧Var("x")ctx 中取出 5Literal(10)直接返回 10结果 155 + 10
树的形状表示语法,递归执行解释其含义;上下文提供变量绑定。
手工建树,再解释;不包含字符串解析器
Java 17+ · 独立机制片段
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)); // 15

17.2 使用边界

适合为何适合不适合的信号
简单筛选/规则表达式文法小、规则可组合规则数量与优先级迅速变多
教学计算器/配置条件AST 与执行关系清楚要求完整语言的类型与错误定位
受限 DSL能控制节点数、深度和可用操作直接执行任意用户代码

收益:规则可组合为树,含义直观。代价:文法一复杂就出现大量类,递归有深度与性能成本。复杂语言应考虑成熟的解析与执行方案,而不是强行手写整套解释器。

⚠ 错误 → 后果 → 正确姿势
把解释器等同于 eval 用户字符串 → 可能执行越权操作、耗尽资源,且错误难定位 → 先解析受限文法,限制节点数/深度,白名单操作;本例只接收已构造的整数表达式树。
✓ 记忆锚点
解析负责“搭树”,解释负责“算树”。

17.9 随堂自测

QUIZ 1
示例 eval 能否直接把字符串 "x+10" 变成语法树?
示例接收已经构造好的 Expr 树。词法与语法解析不由当前 eval 实现。
QUIZ 2
复杂文法导致数百个表达式类时,合理做法是?
解释器适合简单文法。类数量、深度和错误定位成本上升时,应重新评估实现方式。
CHAPTER 18 · 实战:选择、重构与复盘

订单实战:把模式接起来

一句话总览:实战先画业务时序与失败边界,再让每个模式隔离一个已知变化。
💡
生活化类比 · 对应关系与边界
搭舞台时灯光、音响、主持各有职责,对应独立变化模块;总导演对应业务编排。边界:大家按职责分工,不代表断电时能自动恢复整场演出,失败恢复必须另外设计。

18.1 需求 → 变化 → 最小模式

具体需求变化点可选模式
会员与普通用户计价不同折扣算法策略
接入旧支付 SDK,计价单位不同外部合同适配器
只有已支付订单允许发货生命周期行为状态
支付完成后通知多个模块订阅者集合观察者
调用者只想完成下单任务子系统协作细节外观

这些模式可以分步引入。若只有一个固定计价公式,先不建策略;若只通知一个固定接收者,一次显式调用更好追踪。设计应跟着变化压力成长。

订单主流程与后续通知分开看
输入校验金额 / 订单号策略计价返回最终金额保存订单明确提交边界发布已创建事件业务事实库存读模型订阅更新邮件模块订阅通知
此图是下单示例;支付与发货是后续状态流程。保存与通知之间的失败窗口需显式处理。

18.2 最小装配:代码只展示合同与顺序

PlaceOrder:策略 + 存储边界 + 事件出口
Java 17+ · 独立机制片段
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 随堂自测

QUIZ 1
保存成功后发布事件失败,能否直接认定整个订单不存在?
普通方法抛异常不会自动撤销已提交的存储。必须区分失败发生在哪个边界。
QUIZ 2
只有一个固定通知接收者,没有扩展压力,首先可以?
直接调用更易追踪且成本低。模式应回应变化,不要求每个可选扩展点立刻实现。
CHAPTER 19 · 实战:选择、重构与复盘

23 种模式选型速查

一句话总览:先用一句话说出变化轴,再选模式;结构相像时,以设计意图判断。
💡
生活化类比 · 对应关系与边界
工具箱里锤子、钳子、扳手各有任务,不能因为都带手柄就当成同一工具。变化轴对应要修的问题;边界:同一问题可能有多种合适工具,不存在固定“题目关键词→唯一答案”。

19.1 三问缩小范围

选型入口:先辨问题属于哪一类
反复出现的变化先写一句需求创建过程变创建型 5 种组合结构变结构型 7 种职责协作变行为型 11 种比较收益与代价必要时保持简单
分类用于缩小范围,最终选择取决于合同、变化频率与团队理解成本。

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 “长得像”不等于同一意图

容易混淆的一对问自己什么辨析
策略/状态谁决定切换,为什么切换?策略通常由外部选择算法;状态随对象生命周期迁移
装饰/代理包装的主要目的是?叠加职责/控制访问
适配/外观客户的合同发生什么变化?转换不兼容接口/提供更简单入口
桥接/策略主要拆几个维度?两侧独立扩展/替换一组算法
原型/备忘录复制为了什么?创建新实例/恢复原发器过去状态
重构前:变化分支藏在业务方法中
Java 17+ · 独立机制片段
int total(String type, int cents) {
  if (type.equals("VIP")) return (int)(cents * 90L / 100);
  return cents;
}
重构后:需要替换时,提取最小算法合同
Java 17+ · 独立机制片段
interface PriceRule { int apply(int cents); }
int total(PriceRule rule, int cents) {
  return rule.apply(cents);
}
// 选择逻辑在装配入口;参数与取整合同必须保持一致。
⚠ 错误 → 后果 → 正确姿势
见到“缓存”就选代理、见到“树”就选组合 → 忽略变化点,结构看似相似却不合任务 → 先写出需要隔离的变化,再验证候选模式的合同、失败路径和额外复杂度。
✓ 记忆锚点
一句需求说不清,就先别急着画十个类。

19.9 随堂自测

QUIZ 1
一个对象随草稿→发布→归档阶段改变可执行操作,最贴近?
行为受内部生命周期阶段约束,状态模式更贴切。策略通常是外部选择可互换算法。
QUIZ 2
为什么不能只凭“类里有一个接口字段”认出桥接?
策略、代理、装饰等都可能持有接口引用。模式由问题与意图共同确定,不由单个语法特征决定。
CHAPTER 20 · 实战:选择、重构与复盘

课堂练习与记忆地图

一句话总览:真正掌握一个模式,是能画图、跟踪一次调用、说出反例并验证行为。
💡
生活化类比 · 对应关系与边界
学骑车不是背零件名,而是能起步、转弯、刹车。画图对应认识结构,跟踪调用对应骑行,失败验证对应刹车;边界:软件方案不止一种,作业按理由与行为评分,不按类名评分。

20.1 一张记忆地图

用三个动词串起课程
造:创建型唯一 / 生产 / 组装 / 复制搭:结构型转换 / 组合 / 包装 / 共享动:行为型算法 / 通知 / 迁移 / 遍历
回忆时先想“造、搭、动”,再说出具体模式隔离的变化。

20.2 第一个可独立运行的小实验

把下面代码保存为 PatternLab.java,需要 Java 17+。实验与运行命令会随 Tab 一起切换,检查原价、九折和零金额;验证失败时会明确报错。

PatternLab.java · 独立运行的策略实验
Java 17+ · 独立机制片段
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,策略可替换");
  }
}
终端运行
Java 17+ · 独立机制片段
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。自测答对不等于完成作业,能解释错误方案的后果才算掌握。

⚠ 错误 → 后果 → 正确姿势
背出类图却说不出不适用场景 → 遇到新需求就机械套模式 → 每学一种模式都补一句“不用它会怎样、用了多付出什么”,用一个反例检验理解。
✓ 记忆锚点
造、搭、动;找变化、守合同、验行为。
术语与阅读说明
本课按 GoF《Design Patterns: Elements of Reusable Object-Oriented Software》的 23 种经典模式组织,以教学示例说明意图,省略了生产环境的完整错误处理、持久化与资源管理。建议回看薄弱章节,而不是按名称一次背完。

20.9 随堂自测

QUIZ 1
作业里类名都对,但新算法仍要求修改每个业务调用者,说明?
设计收益体现在修改范围和合同稳定性,类名并不保证变化被隔离。
QUIZ 2
最能说明学生理解了模式的是?
结构、运行过程、代价与边界共同构成理解。名字与语法形式都不足以证明设计有效。
渝ICP备2026024724号-1