来源书籍

秒懂设计模式 2021

Skill 版本:v23 设计模式类 经典原理(高信息浓度 + 高稳定性) 65 张卡片

本书围绕面向对象三大特性、23 种 GoF 设计模式和 SOLID/LoD 原则展开,核心内容不依赖某个 Java 版本或工具链。虽然写法偏入门、生活类比很多,但每章都围绕“为什么需要这种拆分”“如何降低耦合”“适合什么变化场景”展开,例如第1章用 USB 接口解释封装、继承与多态的协作,第12章用动态代理引出 AOP 式横切逻辑,第13章用桥接说明笛卡儿积类爆炸,第25章把所有模式回收到职责、开闭、替换、接口、依赖和最少知识等原则上。这些判断逻辑在 5-10 年后的面向对象设计中仍然可迁移。

刘韬 · 人民邮电出版社 · 2021-11-25 · ISBN 978-7-115-54936-5

类别清单覆盖

7/7

已覆盖 7 补充生成 0 未覆盖 0

全书导读

本书以生活类比和Java示例解释面向对象设计:先认识封装、继承和多态,再分析创建对象、组合结构与安排行为时的变化,最后用设计原则回看取舍。模式是为真实变化提供可替换位置的经验,不是写出更多类型的目标。代码与类比需要区分;本笔记对原文已知错误注明边界,不把教学省略当成可直接运行的完整实现。

全书主线

软件设计先要确定哪些部分应稳定、哪些部分可能改变。面向对象的封装把状态和行为放在可维护的边界内,多态则让使用者通过共同契约接受不同实现。全书用这一基础说明三类变化:创建型模式安排“对象从哪里来”,结构型模式安排“对象如何组合与接入”,行为型模式安排“请求、算法和状态如何协作”。它们是处理不同问题的并列工具,不是一条必须依次执行的流水线。

例如,工厂把创建细节从使用方分离,建造者把多步骤构造从最终表示中分离;装饰器在同一能力外叠加职责,适配器接通不同契约,桥接让两个变化维度独立组合。策略替换算法,状态按处境改变响应,命令把请求作为对象传递,观察者让主题驱动多个响应者。共同接口使调用形式稳定,但每个实现仍需守住业务语义、生命周期和失败边界。

最后一章以设计原则评价这些拆分:职责是否清楚、抽象承诺是否可靠、使用者是否知道过多内部细节,以及新增结构是否值得。理解模式需要同时看到它减少的耦合和新增的间接层,而不是只记类图或追求类的数量。

前言

前言把设计模式的目标归结为分离变化与稳定部分:保留可复用结构,让易变实现通过抽象和多态替换。作者以模块、插件和积木接口说明这种思路,再给出由面向对象基础进入三类模式、最后回看原则的阅读路线。减少重复不是只追求行数最少,抽象也不能保证系统一劳永逸;后续章节要回到具体变化验证其价值。

分离变化与稳定部分

设计模式把反复出现的结构与容易变化的实现分开。稳定部分沉淀为可复用的框架,变化部分通过抽象、接口和多态提供替换位置,减少新增需求时改动整个系统。它不是追求代码最少或一劳永逸:要先识别真实变化方向,抽象本身也有维护成本。

知识卡与原书证据。

原书依据 · 1 处

第1章 初探

封装把相关状态与行为组织成边界,外部通过必要接口协作;继承复用共同特征,多态则让调用者通过相容类型面对不同实现。三者相互配合:仅隐藏内部而没有可用入口无法协作,只统一接口而忽略真实类型关系也不能获得替换能力。

本章先用可乐杯说明接口与内部细节,再以Dog和Husky展示继承、扩展与重写,随后讨论引用类型,最后用USB外设连接模块化与契约。USB是教学类比,物理标准并不等于所有设备天然兼容;书中getData/readData称谓不一致,本文采用“共同契约”的主旨,不将对话当成完整Java接口代码。

封装留接口

封装不是把一切藏起来,而是把内部状态和实现细节圈进边界,只暴露稳定、必要的访问入口。边界能保护内部一致性,接口让外部协作变简单。发散:过度封装会把无关对象硬塞在一起,边界反而变成维护障碍。

知识卡与原书证据。

原书依据 · 1 处

多态降低耦合

多态让高层代码依赖父类或接口,而不是依赖每一种具体实现。调用方只需要相信统一契约,具体行为由运行时对象决定。发散:USB 外设的例子说明,标准接口越稳定,设备替换和扩展越轻。

知识卡与原书证据。

原书依据 · 1 处

继承复用并允许重写

继承让子类复用父类开放的状态与行为,并通过新增成员或重写方法表达差异。书中Dog提供共有属性与bark(),Husky调用super初始化品种,再增加sleighRide()。父类私有字段不能被子类直接访问,但可通过可访问的继承方法间接操作。继承表达类型关系,不等于任意对象之间都适合复用。

结构图:类图(据原书类型与关键方法;继承箭头指向父类,关联箭头表示持有)。

classDiagram
class Dog {
#String breeds
+Dog(String breeds)
+bark() void
+getBreeds() String
}
class Husky {
+Husky()
+sleighRide() void
}
Dog <|-- Husky : 继承

知识卡与原书证据。

原书依据 · 1 处

引用类型限制可用能力

父类或接口引用可以指向相容的子类或实现对象,调用行为可由实际对象决定;引用仍限定编译时可直接使用的成员。把所有引用都改成Object看似通用,却会丢失领域接口提供的约束。书中的Dog与Husky用于解释类型兼容,示例new Dog()与前文带参构造器不一致,不能当作可直接编译的完整代码。

知识卡与原书证据。

原书依据 · 1 处

栈按后进先出访问

栈把元素按进入的先后顺序组织,后压入的元素先被弹出。push表示入栈,pop表示取出栈顶,因而最后进入的元素最先离开。本书用弹夹作类比,只用于理解访问顺序,不能据此判断真实机械结构。栈这个抽象约束的是操作次序,而不是元素自身的类型。

知识卡与原书证据。

原书依据 · 1 处

第2章 单例

单例控制特定范围内的一个共享实例,并提供统一访问入口。Sun例子先私有化构造器,再由静态字段保存实例、getInstance返回它;饿汉与懒汉的区别在创建时机,懒汉还要解决并发线程共同通过判空的问题。

方法级同步能串行创建,但每次访问都竞争同一把锁;双重检查使已有实例的读取绕过锁,未初始化路径在锁内再次判断,并配合volatile正确发布。volatile不单独保证复合操作原子性。原书关于“静态对象永生”的说法与加载/初始化混称均需更正;Spring默认单例也须限定为容器与bean范围,不能推成全进程或跨机器唯一。

单例控制唯一性

单例适合系统中确实只应存在一个实例的对象,并通过统一访问点保持全局行为一致。它的价值不在“省对象”,而在控制唯一状态。发散:若对象并无唯一性约束,单例会制造隐式全局依赖,反而难测试。

知识卡与原书证据。

原书依据 · 1 处

饿汉与懒加载的时机

饿汉方式在类初始化时创建静态实例,访问方法直接返回它;懒加载则把创建推迟到第一次需要时,避免对象未使用就先分配。两者权衡初始化成本与实现复杂度。原书将类加载和初始化混称,并称静态对象永生,这不准确:应区分类初始化和类卸载,不能据static断言对象不可能被回收。

结构图:类图(据原书类型与关键方法;继承箭头指向父类,关联箭头表示持有)。

classDiagram
class Sun {
-Sun sun$
-Sun()
+getInstance() Sun$
}
Sun --> Sun : 静态字段保存单例

知识卡与原书证据。

原书依据 · 1 处

懒加载判空存在竞态

未同步的懒加载把“检查sun为空”与“创建并赋值”分成两步。两个线程可能都先看到空,再各自创建一个实例,后一次赋值还会覆盖前一次引用。这使只想有一个对象的约束失效;单线程测试没有出现重复创建,不能证明并发下仍唯一。原书Sun例子没有资金操作,因此不归为资金安全案例。

知识卡与原书证据。

原书依据 · 1 处

双重检查协调创建与发布

双重检查先在锁外判断是否已有实例,只让未初始化路径进入同一把锁;获得锁后再判空,避免排队线程重复创建。共享引用还需用volatile等正确发布机制,让读线程看到已初始化对象。volatile本身不把判空与创建变成原子操作,唯一创建来自锁内再次判断;不能把可见性直接等同唯一性。

知识卡与原书证据。

原书依据 · 1 处

单例必须明确控制范围

本书以Spring默认托管方式联系单例,但容器单例和类内静态单例的范围不同。Spring singleton通常按容器及bean定义共享实例,不表示同一Java类在所有容器或整个分布式系统中只有一个对象。使用前应明确要控制的是哪个范围,再判断共享状态与生命周期是否合适。

知识卡与原书证据。

原书依据 · 1 处

第3章 原型

原型模式从已有对象复制新实例,适合多个对象共享复杂初始化而只在少量状态上不同的情况。书中先把一次性构造500架敌机改成按需创建,再以克隆复用已准备状态;按需分配解决何时占用资源,原型解决怎样取得副本,二者不能混为一个机制。

EnemyPlane通过Object.clone取得字段副本,工厂再设置个体横坐标。加入Bullet引用后,字段复制仍指向同一子弹,因此要按需要继续复制可变成员。Cloneable是标记接口,并不声明clone方法;类型角色图与Java语言接口需要区分。书中没有提供可复现性能测量,不能把“原型必然更快”或“从此不再卡顿”当成已验证结论。

原型用对象造对象

原型模式绕过复杂构造流程,直接从已有对象复制新对象,适合初始化成本高、实例状态相近的场景。发散:它把“如何创建”从类构造转向对象复制,常能减少重复装配逻辑。

知识卡与原书证据。

原书依据 · 1 处

深浅拷贝边界

浅拷贝复制字段值,基本类型取得各自的值,引用类型仍指向同一对象。深拷贝按所需隔离范围继续复制可变成员:本书EnemyPlane先复制自己,再复制Bullet,避免两架飞机共用一颗可变子弹。需要复制多深取决于对象图与业务语义,并非所有引用都必须复制;隔离收益伴随额外成本。

知识卡与原书证据。

原书依据 · 1 处

克隆标记与方法分工

Java的Cloneable是允许Object.clone进行字段复制的标记接口,本身不声明clone方法;具体类仍需提供合适可见性的clone入口并按需要处理复制逻辑。EnemyPlane重写方法,调用super.clone取得副本,复杂成员另行处理。原书把“原型接口声明克隆方法”直接等同Cloneable不准确,应区分模式角色与Java标记接口。

结构图:类图(原书已命名类型与方法;空心三角实线为继承,虚线为接口实现,关联/依赖箭头指向被使用的类型)。

classDiagram
class Cloneable {
<<interface>>
}
class Object {
#clone() Object
}
class EnemyPlane {
-int x
-int y
+clone() EnemyPlane
+setX(int x) void
}
Object <|-- EnemyPlane
Cloneable <|.. EnemyPlane : 标记接口

知识卡与原书证据。

原书依据 · 1 处

克隆工厂重设变化状态

克隆工厂保存已经准备好的原型,每次请求先复制,再改写该实例特有的状态。EnemyPlaneFactory.getInstance(x)复制protoType并设置横坐标,把共同初始化与个体差异分开。副本不会自动取得合理的业务状态,必须明确哪些字段保留、哪些重设;是否比构造更快仍需按实际初始化与复制成本验证。

结构图:类图(原书已命名类型与方法;空心三角实线为继承,虚线为接口实现,关联/依赖箭头指向被使用的类型)。

classDiagram
class EnemyPlaneFactory {
-EnemyPlane protoType$
+getInstance(int x) EnemyPlane$
}
class EnemyPlane {
+clone() EnemyPlane
+setX(int x) void
}
EnemyPlaneFactory --> EnemyPlane : 保存原型并返回副本

知识卡与原书证据。

原书依据 · 1 处

第4章 工厂方法

工厂封装对象构造与初始化,使使用产品的代码不必重复处理生产细节。简单工厂把产品分支集中到create(type),工厂方法则把创建标准抽象出来,让各具体工厂各自实现。这里存在两组多态:产品统一为Enemy,创建者统一为Factory。

飞机与坦克随机初始化横坐标,Boss工厂选择屏幕中央,它们仍可以交付相同的Enemy接口。工厂方法因此隐藏的是具体创建方式,并未消除选择某个工厂的工作。新产品需要新的工厂及装配安排;不能把原书的“不改现有代码”理解成程序任何地方都无需修改。

工厂方法隔离创建

工厂方法把产品创建交给具体工厂:Factory规定create(screenWidth)返回Enemy,TankFactory和AirplaneFactory分别创建具体产品,调用者按Enemy接口使用show。新增产品主要增加产品类及对应工厂,不再向同一个创建分支不断加条件。选择工厂的装配位置仍可能改变,因此“扩展无需修改代码”应限定到受保护的既有创建和使用逻辑。它通过创建职责的拆分支持“开闭原则”。

结构图:类图(保留原书类型和关键方法;实线三角为继承,虚线三角为接口实现,依赖箭头为创建/使用)。

classDiagram
class Factory {
<<interface>>
+create(int screenWidth) Enemy
}
class TankFactory {
+create(int screenWidth) Enemy
}
class AirplaneFactory {
+create(int screenWidth) Enemy
}
class Enemy {
<<abstract>>
+show() void
}
class Tank {
+show() void
}
class Airplane {
+show() void
}
Factory <|.. TankFactory
Factory <|.. AirplaneFactory
Enemy <|-- Tank
Enemy <|-- Airplane
TankFactory ..> Tank : 创建
AirplaneFactory ..> Airplane : 创建

知识卡与原书证据。

原书依据 · 1 处

简单工厂集中创建分支

简单工厂把构造和初始化逻辑从调用方移入一个create(type)入口,按类型选择具体产品。调用者因此少写重复初始化代码,但产品分支集中在工厂中:新增产品仍要修改该判断。它适合产品范围有限且变化可控的场景;工厂方法进一步把各产品创建交给不同实现,不能只因用了工厂类就认为已经隔离所有变化。

结构图:类图(原书已命名类型与方法;空心三角实线为继承,虚线为接口实现,关联/依赖箭头指向被使用的类型)。

classDiagram
class SimpleFactory {
-int screenWidth
+create(String type) Enemy
}
class Enemy {
<<abstract>>
+show() void
}
class Airplane {
+show() void
}
class Tank {
+show() void
}
Enemy <|-- Airplane
Enemy <|-- Tank
SimpleFactory ..> Airplane : 创建
SimpleFactory ..> Tank : 创建

知识卡与原书证据。

原书依据 · 1 处

第5章 抽象工厂

抽象工厂将产品按两个维度组织:族决定一组相关实现,系列决定统一提供哪些能力。本章用人类族与外星族作行、低中高兵种作列,先通过各等级抽象类统一能力,再让每个族工厂提供三条生产方法。

调用者选择HumanFactory或AlienFactory后,调用同一组方法即可获得对应族的产品。增加新族可以扩展新工厂,增加新系列却需要修改制造接口和各族实现。因此它依赖系列相对稳定,而不是对工厂方法的无条件升级。原书攻击数值与示例输出部分不一致,本文保留族系与接口关系,不把示例数值当成验证结果。

抽象工厂管产品族

抽象工厂为一组相关产品定义多条生产接口,并由具体工厂选择同一产品族的实现。书中AbstractFactory按低、中、高等级提供方法,HumanFactory和AlienFactory分别产生各族兵种。替换工厂即可整体换族;新增族较方便,新增产品系列则会影响工厂接口及各实现。它适合产品系列相对稳定而族需要变化的场景,不是工厂方法在所有问题上的高级替代品。下图展示初级产品链及三条工厂方法,其余等级的具体产品遵循同一族系规划。

结构图:类图(保留原书类型和关键方法;实线三角为继承,虚线三角为接口实现,依赖箭头为创建/使用)。

classDiagram
class AbstractFactory {
<<interface>>
+createLowClass() LowClassUnit
+createMidClass() MidClassUnit
+createHighClass() HighClassUnit
}
class HumanFactory {
+createLowClass() LowClassUnit
+createMidClass() MidClassUnit
+createHighClass() HighClassUnit
}
class AlienFactory {
+createLowClass() LowClassUnit
+createMidClass() MidClassUnit
+createHighClass() HighClassUnit
}
class LowClassUnit {
<<abstract>>
+show() void
+attack() void
}
class Marine {
+show() void
+attack() void
}
class Roach {
+show() void
+attack() void
}
AbstractFactory <|.. HumanFactory
AbstractFactory <|.. AlienFactory
LowClassUnit <|-- Marine
LowClassUnit <|-- Roach
HumanFactory ..> Marine : 创建本族初级兵种
AlienFactory ..> Roach : 创建本族初级兵种

知识卡与原书证据。

原书依据 · 1 处

第6章 建造者

建造者针对需要分步装配的产品,把构建步骤的实现与步骤间的流程分离。本章的角色初始化先分配属性再配装备,说明步骤可能有依赖;建筑物案例则把产品简化为地基、墙体和屋顶,通过建造者提供具体工艺,由指导者统一顺序。

Builder定义动作与交付接口,具体建造者持有并组装Building,Director使用Builder组织流程。换建造者可以在同一流程下得到别墅或公寓,它与工厂主要选择何种成品的关注点不同。例子简化了产品状态管理,真实重复建造时仍要决定重设和交付条件。

建造者分离工序

建造者把复杂产品的分步构建与整体流程分开。Builder规定各组件怎么建及如何取得Building,HouseBuilder和ApartmentBuilder实现不同工艺,Director按地基、墙体、屋顶顺序调用。客户端可以替换建造者而复用流程。例子每个建造者持有一个产品,重复调用direct会继续追加组件;需要新成品时应明确何时重设状态,不能把一次演示当作自动支持任意重复建造的保证。

结构图:类图(据本章实际类型与关键方法;接口实现、持有关系与返回产品分别标示)。

classDiagram
class Builder {
<<interface>>
+buildBasement() void
+buildWall() void
+buildRoof() void
+getBuilding() Building
}
class Director {
-Builder builder
+setBuilder(Builder builder) void
+direct() Building
}
class HouseBuilder {
-Building house
+buildBasement() void
+buildWall() void
+buildRoof() void
+getBuilding() Building
}
class ApartmentBuilder {
-Building apartment
+buildBasement() void
+buildWall() void
+buildRoof() void
+getBuilding() Building
}
class Building {
+setBasement(String basement) void
+setWall(String wall) void
+setRoof(String roof) void
}
Builder <|.. HouseBuilder
Builder <|.. ApartmentBuilder
Director --> Builder : 依次调用步骤
HouseBuilder --> Building : 组装产品
ApartmentBuilder --> Building : 组装产品

知识卡与原书证据。

原书依据 · 1 处

第7章 门面

门面为多子系统提供统一的高层入口,使用户不用了解内部所有操作。本章先以相机一键操作解释外部便利,再从亲自买菜、做菜和洗碗,过渡到餐厅门面集中安排资源。调用者获得的是更简单的协作方式,内部复杂性并没有消失。

Facade在初始化时准备子系统,order方法再调度点菜、烹饪、上菜与清理。各子系统仍负责自己的操作,门面负责整合。原书最后以Service协调DAO说明相同思想,并明确还要处理事务;一个update入口本身不能证明多步操作已经原子化。

门面压缩认知

门面把多个子系统的复杂调用收束为高层入口,调用者以较少知识完成任务。本书Facade初始化供货、厨师、服务员和清洁资源,再由order()安排各自操作。复杂性仍留在边界内部管理,子系统职责没有消失;它减少直接依赖,呼应“迪米特法则”。统一入口也不会自动提供事务原子性,原书Service调用多个DAO的例子另需事务处理。

结构图:类图(据本章实际类型与关键方法;接口实现、持有关系与返回产品分别标示)。

classDiagram
class Facade {
+order() void
}
class VegVendor {
+purchase() void
}
class Chef {
+cook() void
}
class Waiter {
+order() void
+serve() void
}
class Cleaner {
+clean() void
+wash() void
}
Facade --> VegVendor : 准备原料
Facade --> Chef : 烹饪
Facade --> Waiter : 接待与上菜
Facade --> Cleaner : 收拾与洗碗

知识卡与原书证据。

原书依据 · 1 处

第8章 组合

组合模式面对部分与整体形成的层次结构,用一个共同抽象表示复合节点和末端节点。文件系统例子中,Folder能保存其他Node,File不能再分支,客户端可从任何层级开始操作共同的展示接口。树形关系与多态一起减少了遍历时的类型判断。

展示时每个节点先输出自己的名称,文件夹再把缩进加一后传给子节点,叶节点完成显示便终止。统一接口也有代价:File不能真正执行add,需要明确拒绝,而不能把打印错误当作成功操作。章末的自然自相似和海岸线论文帮助建立直觉,属于类比与延伸;自然形态的统计相似不能替代软件树结构的建模。

组合统一层级

组合模式把复合节点与叶节点放到共同接口下。书中Node保留名称及展示入口,Folder保存Node列表,File作为没有子节点的末端。Folder.tree先显示自身,再将层级加一传给每个子节点;子节点按各自实现继续或结束,调用者不用逐级判断类型。无参tree以0启动,隐藏初始缩进参数。适用前提是结构确有部分/整体关系,实际实现仍应避免非法循环破坏递归终止。

结构图:类图(Folder关联指向它保存的Node;使用关联表示集合,不额外假设节点只能有一个所有者)。

classDiagram
class Node {
<<abstract>>
#String name
#add(Node child) void
#tree(int space) void
#tree() void
}
class Folder {
-List~Node~ childrenNodes
#add(Node child) void
+tree(int space) void
}
class File {
#add(Node child) void
+tree(int space) void
}
Node <|-- Folder
Node <|-- File
Folder --> "0..*" Node : 子节点并递归调用

知识卡与原书证据。

原书依据 · 1 处

统一接口与叶节点限制

组合模式若把add等子节点操作放到所有节点的共同接口,调用者就不用区分文件和文件夹,但叶节点本来不能容纳子节点。书中File.add只输出错误,并建议改为抛出异常,让错误被明确处理。共同接口提高一致性,也可能暴露部分对象不支持的能力;不能因对象具有同一父类,就假定每个操作都对它有意义。

知识卡与原书证据。

原书依据 · 1 处

海岸线的统计自相似

本章以Mandelbrot研究海岸线的论文说明统计自相似:局部形态与整体在统计意义上相像,不要求每处都是几何上完全相同的缩小复制。它帮助理解“相似结构可跨层出现”的直觉,但不能证明所有自然对象都严格分形,也不能由此推出组合模式必然适用。软件中的统一接口和递归规则仍需要由模型明确设计。

知识卡与原书证据。

原书依据 · 1 处

第9章 装饰器

装饰器在原对象外层叠加行为,同时保留共同接口,所以一层装饰还可以继续被另一层包装。Showable定义展示动作,Girl提供初始行为,抽象Decorator复用被装饰引用与委托,具体化妆品各自增强一项功能。这里既使用继承复用装饰器公共部分,也使用组合决定运行时包装关系,并非完全不用继承。

调用从外层进入,逐层委托,再逐层返回;口红包粉底与粉底包口红的顺序可以不同。Java输入流是后续实际应用:文件读取、内存缓冲与ZIP格式处理各有职责,组合后还需真正读取和处理条目。功能可组合的收益伴随更长调用链,不能把层数越多当作越好。

装饰器动态增强

装饰器与被装饰对象遵守同一接口,因此包装后的对象仍可被继续包装。书中Showable统一show,Girl提供原行为,Decorator持有Showable并委托,粉底与口红子类在委托前后增加行为。外层包装先接收调用,再进入内层,返回时逐层收尾;调整包装顺序可能改变效果。它让单项能力动态组合,减少为全部组合建子类,代价是调用层次与排查成本增加。

结构图:类图(实际类型与关键方法;空心三角实线为继承,虚线为接口实现,关联指向被使用对象)。

classDiagram
class Showable {
<<interface>>
+show() void
}
class Girl {
+show() void
}
class Decorator {
<<abstract>>
#Showable showable
+Decorator(Showable showable)
+show() void
}
class FoundationMakeup {
+show() void
}
class Lipstick {
+show() void
}
Showable <|.. Girl
Showable <|.. Decorator
Decorator <|-- FoundationMakeup
Decorator <|-- Lipstick
Decorator --> Showable : 包装并委托

知识卡与原书证据。

原书依据 · 1 处

输入流按职责层层包装

书中先创建FileInputStream读取文件,再用BufferedInputStream加入缓冲,最外层以ZipInputStream处理ZIP条目。每层接收已有输入流并提供新的能力,调用者面向组合后的外层操作。包装顺序应符合数据格式与职责,构造对象本身并不表示已把文件解压到磁盘。图中FilterInputStream和InflaterInputStream是官方API补充的中间父类,原书示例没有直接列出。

结构图:类图(原书已命名类型与方法;空心三角实线为继承,虚线为接口实现,关联/依赖箭头指向被使用的类型)。

classDiagram
class InputStream {
<<abstract>>
}
class FileInputStream {
+FileInputStream(File file)
}
class FilterInputStream {
#InputStream in
}
class BufferedInputStream {
+BufferedInputStream(InputStream in)
}
class InflaterInputStream
class ZipInputStream {
+ZipInputStream(InputStream in)
}
InputStream <|-- FileInputStream
InputStream <|-- FilterInputStream
FilterInputStream <|-- BufferedInputStream
FilterInputStream <|-- InflaterInputStream
InflaterInputStream <|-- ZipInputStream
FilterInputStream --> InputStream : 持有输入源

知识卡与原书证据。

原书依据 · 1 处

第10章 适配器

适配器处理的是双方接口不兼容:调用者要求一种契约,已有对象提供另一种契约,由中间对象完成转接。对象适配器实现目标接口并保存被适配引用,因此可以更换不同实现;类适配器则直接继承被适配类型,结构简单但受到父类绑定约束。

本章Adapter与TVAdapter分别展示两条路线。对象适配器角色表把Adapter误写为TVAdapter,本文依照代码区分;所有电源名称仅作软件参数和签名类比。选择方式要看需要适配的类型范围和变化,不能仅按“更灵活”或“代码更少”作绝对判断。

适配器补齐契约

适配器将已有对象的接口转换成调用者期待的目标接口。对象适配器Adapter实现TriplePin并持有DualPin,把三参数调用转给被适配对象的两参数方法;类适配器TVAdapter继承TV并实现TriplePin,转调父类方法。前者可接入不同DualPin实现,后者较简便但绑定具体父类。两种方式都要保持业务语义,不能只使签名兼容;原书插头只用于软件接口类比,不作现实接线方案。

结构图:类图(实际类型与关键方法;空心三角实线为继承,虚线为接口实现,关联指向被使用对象)。

classDiagram
class TriplePin {
<<interface>>
+electrify(int l, int n, int e) void
}
class DualPin {
<<interface>>
+electrify(int l, int n) void
}
class TV {
+electrify(int l, int n) void
}
class Adapter {
-DualPin dualPinDevice
+Adapter(DualPin dualPinDevice)
+electrify(int l, int n, int e) void
}
class TVAdapter {
+electrify(int l, int n, int e) void
}
DualPin <|.. TV
TriplePin <|.. Adapter
Adapter --> DualPin : 对象适配
TV <|-- TVAdapter
TriplePin <|.. TVAdapter : 类适配

知识卡与原书证据。

原书依据 · 1 处

第11章 享元

享元把可共享状态保留在少量对象中,将每次使用的位置等外在状态交给调用者。地图里的同一材质会在很多坐标重复出现,若每次都创建含图片和坐标的Tile,就重复保存了相同资源;改用共享Drawable并传入坐标,才把共享与变化分离。原型复制得到独立副本,享元复用同一实例,两者优化的对象不同。

TileFactory按名称缓存并按需创建材质,使用者负责给出每次绘图位置。书中Road/Stone类名和房屋/房子键名存在不一致,未知键也没有默认分支,不能据其打印输出声称示例已完整运行。“耗时半秒”仅由输出文本模拟,并非实际测量。

享元共享内在态

享元模式把大量对象中可共享的内在状态抽出复用,把随场景变化的外在状态留给调用方传入。发散:它用对象复用换内存效率,前提是能清晰区分共享与不共享的状态。

知识卡与原书证据。

原书依据 · 1 处

享元工厂按键复用对象

享元工厂用键查找共享对象,命中直接返回,未命中才创建并保存。书中TileFactory以图片名管理Drawable,调用者把各次坐标传给draw,避免为每个位置保留一份相同材质。该示例只处理列出的合法键;未知键可能返回null,并未实现并发下的唯一创建。所谓加载半秒是打印文本,不是实际基准测试。

结构图:类图(原书已命名类型与方法;空心三角实线为继承,虚线为接口实现,关联/依赖箭头指向被使用的类型)。

classDiagram
class Drawable {
<<interface>>
+draw(int x, int y) void
}
class River {
-String image
+draw(int x, int y) void
}
class Grass {
-String image
+draw(int x, int y) void
}
class House {
-String image
+draw(int x, int y) void
}
class TileFactory {
-Map images
+getDrawable(String image) Drawable
}
Drawable <|.. River
Drawable <|.. Grass
Drawable <|.. House
TileFactory --> Drawable : 按键缓存共享实例

知识卡与原书证据。

原书依据 · 1 处

第12章 代理

代理在业务接口前增加控制入口,调用者仍使用相同接口,真实对象藏在后面。本章RouterProxy以Internet接收请求,再决定是否交给Modem。它与装饰器可能具有相似结构,区别主要在访问管控与功能组合的目的;内部构造或外部注入目标并不是强制分类标准。关键词过滤只是教学逻辑,不构成完整网络安全方案。

当不同业务接口需要同一过滤规则时,InvocationHandler把方法与参数统一交给处理器,Proxy按接口生成代理实例。示例BlackListFilter仍限定单个字符串参数,不能泛化为任意方法。Spring AOP进一步用切面、切入点和通知表达共同逻辑,但事务是否生效及何时回滚都有条件,不能把原书概述读成所有数据库访问均受控。

代理隔离访问

代理与真实对象遵守同一业务接口,调用者通过代理访问,由代理决定拒绝还是转发。书中RouterProxy与Modem实现Internet,前者持有后者,在httpAccess先按关键字过滤再委托。共享接口提供透明访问,额外控制留在边界中;关键词黑名单只是示例策略,未匹配不等于已证明安全。代理重在访问控制,装饰器重在行为叠加,是否在内部创建目标不是二者的绝对判据。

结构图:类图(实际类型与关键方法;空心三角实线为继承,虚线为接口实现,关联指向被使用对象)。

classDiagram
class Internet {
<<interface>>
+httpAccess(String url) void
}
class Modem {
+httpAccess(String url) void
}
class RouterProxy {
-Internet modem
+httpAccess(String url) void
}
Internet <|.. Modem
Internet <|.. RouterProxy
RouterProxy --> Internet : 控制访问后委托

知识卡与原书证据。

原书依据 · 1 处

动态代理抽横切

JDK动态代理在运行时为指定接口生成代理实例,将方法调用交给InvocationHandler。书中BlackListFilter持有真实对象,在invoke中过滤参数,再通过反射调用原方法,使同一管控逻辑用于Internet和Intranet两个接口。Proxy.newProxyInstance负责生成代理,处理器负责调用策略;它不是可直接代理任意类所有方法的万能工具,具体参数和返回契约仍要保留。

结构图:类图(实际类型与关键方法;空心三角实线为继承,虚线为接口实现,关联指向被使用对象)。

classDiagram
class Proxy {
+newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h) Object$
}
class InvocationHandler {
<<interface>>
+invoke(Object proxy, Method method, Object[] args) Object
}
class BlackListFilter {
-Object origin
+BlackListFilter(Object origin)
+invoke(Object proxy, Method method, Object[] args) Object
}
InvocationHandler <|.. BlackListFilter
Proxy ..> InvocationHandler : 为生成代理配置处理器

知识卡与原书证据。

原书依据 · 1 处

处理器保持调用契约

动态处理器接收方法与参数后,仍须满足原方法的参数、返回值和异常契约。书中BlackListFilter只读取args[0]并转发一个字符串,因此适合示例中的单字符串参数方法,不能据此声称代理任意方法。无参数、多参数或原始类型返回值都需要相应处理;拒绝时返回null适合本例void调用,不能泛化成所有业务结果。

知识卡与原书证据。

原书依据 · 1 处

切面集中表达横切规则

本章以Spring AOP说明如何把重复的日志、过滤或事务处理从业务实现中抽出:切面组织增强逻辑,切入点选择作用位置,通知描述何时执行。代理机制让共同逻辑可以复用,但调用必须进入相应代理,事务回滚还受配置和异常规则约束。不能由“使用AOP”推出所有方法或数据库访问都自动得到事务保护。

知识卡与原书证据。

原书依据 · 1 处

第13章 桥接

桥接把两个独立变化方向分开,让各自实现通过共同接口组合。本章先让画笔同时绑定颜色与三角形,再抽离Ruler表示形状:Pen保留尺子引用,不同颜色画笔与不同形状尺子可以分别增加。两维之间仍有接口依赖和装配工作,所谓解耦并不是完全互不相关。

笛卡儿积说明每种颜色都可配每种形状。7色与10形产生70种搭配,桥接可以用两组共17个具体实现类支持这些组合,但抽象接口等类型另计,潜在搭配数仍为70。产业与经济段落用于按专业分工的类比,不据历史例子宣称当前供应链状态或普遍经济规律。

桥接拆双维度

桥接把两组独立变化的实现拆开,用组合连接。书中Pen持有Ruler,BlackPen与WhitePen负责颜色,SquareRuler等负责形状;draw先确定颜色,再调用ruler.regularize完成形状。增加颜色不必为所有形状重写一组画笔,增加形状也不必改变每种颜色的实现。桥接降低的是维度间的具体依赖,并未消除共同接口或装配关系。

结构图:类图(实际类型与关键方法;空心三角实线为继承,虚线为接口实现,关联指向被使用对象)。

classDiagram
class Pen {
<<abstract>>
#Ruler ruler
+Pen(Ruler ruler)
+draw() void
}
class BlackPen {
+draw() void
}
class WhitePen {
+draw() void
}
class Ruler {
<<interface>>
+regularize() void
}
class SquareRuler {
+regularize() void
}
class TriangleRuler {
+regularize() void
}
class CircleRuler {
+regularize() void
}
Pen <|-- BlackPen
Pen <|-- WhitePen
Ruler <|.. SquareRuler
Ruler <|.. TriangleRuler
Ruler <|.. CircleRuler
Pen --> Ruler : 组合两维能力

知识卡与原书证据。

原书依据 · 1 处

笛卡儿积爆炸

若为每种颜色与形状搭配都建具体子类,所需组合类可随两维数量相乘。桥接把具体颜色与形状分别实现,再在对象层组合:书中7种颜色和10种形状可用17个具体实现支持70种搭配。这个计数没有包含共同抽象等额外类型,也没有把70种潜在组合消掉;它减少的是实现类的重复,而不是改变需求组合数量。

知识卡与原书证据。

原书依据 · 1 处

第14章 模板方法

模板方法把反复出现的流程保留在基类,把不同执行方式交给子类。Mammal的live固定先move再eat,体现基类调用可重写步骤的方式;它是教学模型,不是对所有动物行为顺序的生物学断言。final保护流程不被整体覆盖,步骤本身仍然多态。

PM把同一思想扩展为带返工循环的项目流程:分析、设计、开发,测试不通过再开发,通过后发布。不同项目实现不同步骤,模板只用测试结果组织流程。例子以随机数和字符串模拟质量过程,不能据其输出认为真实测试已通过;实际流程还需要失败、取消与重试边界。

模板方法固流程

模板方法把稳定的算法顺序放在基类,把变化步骤留给子类。书中Mammal.live按顺序调用move和eat,并以final禁止子类重写流程;Whale、Human、Bat分别实现步骤。基类掌握调用次序,子类提供具体行为,从而避免重复流程。需要通用默认行为的步骤也可提供实体实现,再允许子类按需重写;不必将所有步骤一律声明为抽象。

结构图:类图(Mammal.live在原文声明为final;其固定顺序由正文解释,图展示继承和步骤覆盖)。

classDiagram
class Mammal {
<<abstract>>
+move() void
+eat() void
+live() void
}
class Whale {
+move() void
+eat() void
}
class Human {
+move() void
+eat() void
}
class Bat {
+move() void
+eat() void
}
Mammal <|-- Whale
Mammal <|-- Human
Mammal <|-- Bat

知识卡与原书证据。

原书依据 · 1 处

模板分支依据步骤结果

模板不只排列直线步骤,也可依据步骤结果组织分支与循环。书中PM.kickoff先分析和设计,再反复develop和test,测试通过后才release。test返回的是测试是否通过,模板负责据此决定返工或发布;职责由此保持清楚。示例用字符串和随机数模拟缺陷,且没有重试上限,不能把它当成已经验证的生产交付流程。

结构图:类图(原书已命名类型与方法;空心三角实线为继承,虚线为接口实现,关联/依赖箭头指向被使用的类型)。

classDiagram
class PM {
<<abstract>>
+analyze() String
+design(String project) String
+develop(String project) String
+test(String project) boolean
+release(String project) void
#kickoff() void
}
class HRProject {
+develop(String project) String
+test(String project) boolean
}
class APIProject {
+develop(String project) String
+test(String project) boolean
}
PM <|-- HRProject
PM <|-- APIProject

知识卡与原书证据。

原书依据 · 1 处

第15章 迭代器

迭代器把“怎样访问下一个元素”从调用者使用数据的逻辑中分离出来。不同集合可以选择不同存储结构,只要提供相容的迭代契约,就能让调用者通过hasNext和next统一取用。索引循环只是其中一种方式;Set没有位置下标,不表示for语法不能用于它。

行车记录仪例子先用环形数组保留最近10条记录,再用内部Itr记录自己的cursor与loopCount,将存储位置和遍历位置分开。迭代器能够访问共享数据,却不会自动成为快照。原文简化实现没有处理空、未满、耗尽及遍历中写入;自定义Iterator还须与JDK Iterable要求的类型一致,不能直接混用后就声称支持foreach。

迭代器藏结构

迭代器以hasNext和next提供统一遍历,使调用者不必知道集合内部用数组、链表还是树。集合的iterator创建独立遍历状态,书中Itr从当前写入位置复制cursor,再按自己的游标读取,不改变DrivingRecorder的写入index。独立游标不等于复制数据快照,底层数组仍共享;没有位置索引的Set也可通过迭代器遍历,不能把不支持下标误读为不能使用for语句。

结构图:类图(以原书角色和简化泛型展示;若接入JDK Iterable,Iterator必须采用其要求的java.util.Iterator,不能混用不相容的自定义同名接口)。

classDiagram
class Iterable {
<<interface>>
+iterator() Iterator
}
class Iterator {
<<interface>>
+hasNext() boolean
+next() Object
}
class DrivingRecorder {
-int index
-String[] records
+append(String record) void
+iterator() Iterator
}
class Itr {
int cursor
int loopCount
+hasNext() boolean
+next() String
}
Iterable <|.. DrivingRecorder
Iterator <|.. Itr
DrivingRecorder ..> Itr : 创建内部迭代器
Itr --> DrivingRecorder : 访问外围共享记录

知识卡与原书证据。

原书依据 · 1 处

环形覆盖保留最近记录

环形缓存用固定容量循环写入,到达数组末端后回到开头,覆盖最旧位置。书中10个槽写入12条视频后,槽0和槽1存入视频10与11,整体保留视频2至11;物理槽位顺序因此不等于从新到旧的逻辑顺序。遍历需要结合最新位置和有效数量,例子固定读取10条只展示已写满情形,空缓存与未满状态仍需单独处理。

知识卡与原书证据。

原书依据 · 1 处

迭代结束对应有效元素

hasNext应表示是否还有可返回的有效元素,next则取得下一个元素。书中固定以10次为终点,没有保存有效记录数,也没有在next中检查耗尽;空记录或不足10条时不能据此保证正确。接入JDK时还要使用相容的Iterator类型,并遵守耗尽后抛NoSuchElementException的契约;一次满缓存示例不能代替边界验证。

知识卡与原书证据。

原书依据 · 1 处

第16章 责任链

责任链把业务处理分散到节点,再把节点按转交规则组织起来。本章先用汽车生产线说明逐站加工,再用报销审批说明按金额权限择一处理:低层不能批时向上转交,末端可以驳回。两种路线都隐藏了内部处理安排,但不是所有请求都一定成功。

Approver持有下一节点,具体角色提供自己的审批规则;客户端装配链后只需向入口提交。setNextApprover返回的是新继任者,因此连续调用逐步延长链条。调用链的终止、断链、环路和结果表达仍须定义,本书用打印代替完整业务结果。本例是软件流程教学,不是现实报销制度;未展开并发、幂等或隔离根因,不作资金安全问题案例。

责任链分段处理

责任链把处理节点连接起来,调用者向入口提交请求,由节点决定继续传递还是终止。本书同时给出逐站加工的生产线与按权限择一处理的报销链;后者Staff、Manager超出权限便转交nextApprover,CFO负责最终通过或驳回。链条隐藏路由,不表示业务必定成功或用户不关心结果;例子用打印模拟终态,真实接口仍须明确结果,装配还要防止断链与环路。

结构图:类图(实际类型与关键方法;空心三角实线为继承,虚线为接口实现,关联指向被使用对象)。

classDiagram
class Approver {
<<abstract>>
#String name
#Approver nextApprover
#setNextApprover(Approver nextApprover) Approver
+approve(int amount) void
}
class Staff {
+approve(int amount) void
}
class Manager {
+approve(int amount) void
}
class CFO {
+approve(int amount) void
}
Approver <|-- Staff
Approver <|-- Manager
Approver <|-- CFO
Approver --> Approver : 下一处理节点

知识卡与原书证据。

原书依据 · 1 处

链式配置取决于返回对象

链式调用的下一步作用于上一步返回的对象。书中setNextApprover设置当前节点的继任者,再返回该继任者,因此专员调用setNextApprover配置经理后返回经理,后续同名调用配置的是经理的继任者CFO。若在同一调用写法下改成返回this,第二步会覆盖Staff的继任者,跳过Manager。返回什么应配合本方法的组装职责,不能只因采用流式语法就一律返回自身。

知识卡与原书证据。

原书依据 · 1 处

第17章 策略

策略把可替换的算法或行为与使用环境分开。书中计算器先把加减法放在自身,再提取Strategy接口及Addition、Subtraction;Calculator只调用共同calculate方法,客户端通过setStrategy改变采用的运算。接口让环境稳定,但必须先配置有效策略,且不同实现都要符合相同的输入输出约束。

USB案例用相同结构解释插件式替换:Computer面向USB.read,KeyBoard、Mouse和Camera各自提供行为。它是教学接口,不是完整USB协议模型。将选择移出环境类有助于扩展,并不表示选择逻辑、装配和兼容要求都已消失,也不能从几种设备推出无限扩展的保证。

策略封装算法

策略把可替换行为放在共同接口后面,由环境对象持有并委托执行。本章Strategy.calculate接收两个整数,Addition和Subtraction实现不同运算;Calculator用setStrategy注入,再由getResult转发。新增算法主要扩展策略实现,选择哪种策略仍须由客户端或装配规则决定,条件选择不一定彻底消失。共同接口保护稳定调用,但也限制了算法必须满足的输入输出契约,支持“开闭原则”。

结构图:类图(实际类型与关键方法;空心三角实线为继承,虚线为接口实现,关联指向被使用对象)。

classDiagram
class Strategy {
<<interface>>
+calculate(int a, int b) int
}
class Addition {
+calculate(int a, int b) int
}
class Subtraction {
+calculate(int a, int b) int
}
class Calculator {
-Strategy strategy
+setStrategy(Strategy strategy) void
+getResult(int a, int b) int
}
Strategy <|.. Addition
Strategy <|.. Subtraction
Calculator --> Strategy : 委托所选算法

知识卡与原书证据。

原书依据 · 1 处

第18章 状态

对象的当前状态会影响它对请求的响应。书中先用灯的开关说明重复操作的校验,再把红、黄、绿交通灯分支提取成具体State,TrafficLight只保存当前状态并转发请求。状态实现获得环境引用后,才能安装下一状态。

这项拆分让规则分布到各状态,而不是让转换规则消失。例子仍以public setState暴露更新入口,只用打印表示持续时间,客户端输出还有没有对应调用的行;本文不把它当作真实安全系统或运行验证。最后比较策略与状态的控制来源:前者常由外部选择方案,后者依据当前状态管理行为与转换,结构相似不代表意图相同。

状态内聚转换

状态模式让环境对象持有当前状态,由具体状态决定请求响应和可执行的转换。书中TrafficLight把自身传入State方法,Red、Yellow、Green据当前规则拒绝或调用setState安装下一状态。原先集中的分支被移到各状态实现中,业务规则并没有消失。公共setState仍可绕过这些入口,打印时长也未实现真实计时,因此例子说明组织方式,不能据此证明真实交通安全或完整状态校验。

结构图:类图(实际类型与关键方法;空心三角实线为继承,虚线为接口实现,关联指向被使用对象)。

classDiagram
class State {
<<interface>>
+switchToGreen(TrafficLight trafficLight) void
+switchToYellow(TrafficLight trafficLight) void
+switchToRed(TrafficLight trafficLight) void
}
class TrafficLight {
State state
+setState(State state) void
+switchToGreen() void
+switchToYellow() void
+switchToRed() void
}
class Red
class Yellow
class Green
State <|.. Red
State <|.. Yellow
State <|.. Green
TrafficLight --> State : 持有当前状态
State ..> TrafficLight : 接收入参以更新环境

本书教学模型的迁移图(不表示现实施工规则或计时控制)。

stateDiagram-v2
[*] --> Red
Red --> Yellow
Yellow --> Red
Yellow --> Green
Green --> Yellow

知识卡与原书证据。

原书依据 · 1 处

策略与状态的选择依据

策略模式把一组算法作为可替换方案,由外部为环境对象选择,以满足不同任务需要。状态模式将对象当前处境与响应放在一起,具体状态可以决定后续转换,并让同一请求随状态不同而得到不同处理。两者常有相似的持有与委托结构;选型应看变化来自外部方案选择,还是来自对象内部的状态规则,不能只凭类图相似就合并为同一种意图。

知识卡与原书证据。

原书依据 · 1 处

第19章 备忘录

备忘录把可恢复状态从持续变化的元对象中提取出来。故事中的文档误删引出History:Doc生成正文快照,Editor在初始化、追加和删除后保存快照,撤销时移动历史位置并让Doc恢复相应正文。元对象负责状态含义,看护者负责历史管理。

本例快照只含String正文,标题不在恢复范围;并非所有字段都必须复制。容量、保存频率与快照体积决定资源成本。书中redo明确留作练习,backup总是追加而不处理撤销后的新分支,所以示例仅展示捕获和回溯机制;save也只是输出提示,没有实现磁盘持久化。

备忘录存快照

备忘录由元对象生成可恢复的历史状态,由外部看护者保存并选择恢复。书中Doc.createHistory只把正文body放入History,Editor持有历史列表和当前位置;undo先检查是否已到初始状态,再回退索引并调用Doc.restoreHistory。快照范围应按恢复目标确定,不必复制整个对象:本例不会恢复标题。无界保存大状态会消耗内存,应明确容量与保留策略。redo在原书中留空,撤销后重新编辑也没有截断旧分支,故不能把示例当成完整撤销重做实现。

结构图:类图(实际类型与关键方法;空心三角实线为继承,虚线为接口实现,关联指向被使用对象)。

classDiagram
class Doc {
-String title
-String body
+createHistory() History
+restoreHistory(History history) void
}
class History {
-String body
+getBody() String
}
class Editor {
-Doc doc
-List~History~ historyRecords
-int historyPosition
+undo() void
+redo() void
}
Doc ..> History : 创建和恢复正文快照
Editor --> Doc
Editor o-- History : 保存历史

知识卡与原书证据。

原书依据 · 1 处

第20章 中介

直接互相引用的对象越多,成员变化时需要同步的关系也越多。书中先让People互持对方引用,再抽取ChatRoom保存成员和转发消息;User只与聊天室建立连接。这样集中协作规则,减少每个用户维护全体成员的负担。

扩展版把ChatRoom改为抽象类,公共聊天室支持广播和指定接收者,两人聊天室限制注册数量,AdminUser通过调用目标logout踢人。它们说明规则可以各自扩展,但不等于规则已经完整:注册失败仍设置用户引用、重复登录和并发遍历没有完整处理,私密聊天室也只是成员数量模型,没有提供安全通信保证。中心化关系的收益必须连同集中维护成本理解。

中介改星形网

中介把同事对象之间的直接协作集中到一个平台。书中User持有ChatRoom,通过login注册、talk发送;ChatRoom保存用户列表并转发给接收者,各User不必维护全体用户引用。公共聊天室和两人聊天室以不同子类实现转发与注册规则,关系由多对多转为围绕中介的连接。协作规则和维护压力也随之集中到中介;这能减少显式依赖,却不自动保证性能、可用性或业务校验完整。

结构图:类图(实际类型与关键方法;空心三角实线为继承,虚线为接口实现,关联指向被使用对象)。

classDiagram
class User {
ChatRoom chatRoom
+login(ChatRoom chatRoom) void
+logout() void
+talk(User to, String msg) void
+listen(User from, User to, String msg) void
}
class AdminUser {
+kick(User user) void
}
class ChatRoom {
<<abstract>>
List~User~ users
+register(User user) void
+deregister(User user) void
+sendMsg(User from, User to, String msg) void
+processMsg(User from, User to, String msg) String
}
class PublicChatRoom
class PrivateChatRoom
User <|-- AdminUser
ChatRoom <|-- PublicChatRoom
ChatRoom <|-- PrivateChatRoom
User --> ChatRoom : 请求协作
ChatRoom --> User : 维护成员并转发

知识卡与原书证据。

原书依据 · 1 处

注册结果必须反映成员事实

两人聊天室的register达到容量时只打印提示并返回void,调用者User.login仍继续把chatRoom设为目标聊天室。这会产生引用已设置、成员列表却没有该用户的不一致;talk又只检查引用是否为空,因此不能据此判断已经注册。注册方法的结果应表达是否实际加入,调用者再决定更新登录状态;重复注册、退出、目标成员和并发读写也需要独立规则。这里从原书控制流识别边界,未声称已运行修复代码。

知识卡与原书证据。

原书依据 · 1 处

第21章 命令

直接让开关持有灯泡会把控制器绑到设备接口。引入Command后,控制器只执行命令,SwitchCommand和FlashCommand分别决定如何调用设备,客户端负责装配。命令不仅更换接收者,还能封装一段动作,让按键绑定一组命令形成宏。

这种表达为记录、排队、重放或撤销提供位置,但书中只展示顺序调用。电视例子的宏实际连续调整频道,文字提到的音量并未实现;闪烁线程也没有完整处理并发启动、异常后的标志复位、停止等待和最终灯状态。volatile保证可见性不等于复合判定原子性,反向执行不等于恢复先前状态;原书输出只作为教学说明。

命令对象化请求

命令把请求封装成对象,使它可以作为值被绑定、组合和传递。本章Command统一exe与unexe,SwitchCommand持有Bulb并转调on/off;Keyboard用按键到命令列表的映射顺序调用exe,形成一键宏。记录、排队和撤销可以在这种组织方式上继续实现,但列表顺序执行并不自动提供事务原子性,执行失败后的补偿需要另行设计。

结构图:类图(实际类型与关键方法;空心三角实线为继承,虚线为接口实现,关联指向被使用对象)。

classDiagram
class Command {
<<interface>>
+exe() void
+unexe() void
}
class SwitchCommand {
-Bulb bulb
+exe() void
+unexe() void
}
class Bulb {
+on() void
+off() void
}
class Switcher {
-Command command
+setCommand(Command command) void
+buttonPush() void
+buttonPop() void
}
class Keyboard {
+bindKeyCommand(KeyCode keyCode, List commands) void
+onKeyPressed(KeyCode keyCode) void
}
Command <|.. SwitchCommand
SwitchCommand --> Bulb : 转调设备操作
Switcher --> Command : 触发
Keyboard --> Command : 按键绑定命令列表

知识卡与原书证据。

原书依据 · 1 处

命令解耦发送执行

命令发送者只调用共同命令接口,具体命令再适配执行者的不同方法。书中同一个Switcher可以绑定开关或闪烁命令,同一个Keyboard也可以绑定电视与灯泡的命令。变化被隔离到具体命令与装配处,设备协议、权限和错误处理仍须由相应实现解决;并非任意设备都天然互通。收益是重组和扩展调用的灵活性,代价是额外间接层及命令类数量。

知识卡与原书证据。

原书依据 · 1 处

反向命令不等于精确撤销

书中开关命令的exe调用on,unexe调用off;闪烁命令的unexe只把运行标志设为false。这样的反向动作不一定恢复执行前状态:灯原本已亮时,执行开灯再关灯并没有回到原状;停止闪烁也没有等待线程结束或恢复原状态。若业务需要精确撤销,应先明确恢复目标,保存必要的先前状态并处理并发与不可逆副作用,而不能仅凭接口含有unexe就承诺可回滚。

知识卡与原书证据。

原书依据 · 1 处

第22章 访问者

本章用商品类型相对稳定、优惠算法多变的情境说明访问者。Visitor为Candy、Wine、Fruit分别定义visit重载,DiscountVisitor组织一套处理规则。直接从List取出元素调用visit不能匹配这些签名,于是元素引入Acceptable.accept,将访问者传入后在具体类中调用visit(this)。

这里结合了元素端的动态派发、具体accept内部的编译期重载选择,以及访问者端的实现调用;不是重载在运行时自动识别泛型对象。已核对Java语言规范§15.12.2与§15.12.4,本文据此澄清原书过宽说法。新增操作容易,新增元素种类则常需修改访问者接口和全部实现。商品过期、酒类期限和float价格只是书中业务假设,不能当作通用商业规则或生产计费实现。

参考:JLS方法调用与重载规则(2026-10-24核对)。

访问者分离算法

当元素类型相对稳定、作用于元素的操作不断增加时,可把操作分组到独立访问者。书中Candy等元素实现Acceptable.accept;客户端先调用元素的accept,具体元素再调用visitor.visit(this),使对应商品的处理方法被选中。Visitor为每种元素定义一个重载,DiscountVisitor实现一套优惠算法;新增算法可另写访问者,但元素仍需提供接待能力和可访问数据,并非任何数据对象都应排除业务行为。

结构图:类图(实际类型与关键方法;空心三角实线为继承,虚线为接口实现,关联指向被使用对象)。

classDiagram
class Acceptable {
<<interface>>
+accept(Visitor visitor) void
}
class Candy {
+accept(Visitor visitor) void
}
class Wine
class Fruit
class Product
class Visitor {
<<interface>>
+visit(Candy candy) void
+visit(Wine wine) void
+visit(Fruit fruit) void
}
class DiscountVisitor
Acceptable <|.. Candy
Acceptable <|.. Wine
Acceptable <|.. Fruit
Product <|-- Candy
Product <|-- Wine
Product <|-- Fruit
Visitor <|.. DiscountVisitor
Candy ..> Visitor : accept中调用visit(this)

知识卡与原书证据。

原书依据 · 1 处

访问者怕结构变

访问者把扩展轴偏向新增操作,而非新增元素类型。书中Visitor列出visit(Candy)、visit(Wine)、visit(Fruit),所以新增一种需独立处理的商品时,通常要修改接口并补全各访问者实现,也要为新元素提供accept。只有元素集合较稳定,新增算法的便利才足以抵偿这种耦合。不要把“不推荐数据多变”误解为元素实例的属性值不能变化;这里主要指元素种类与结构契约。

知识卡与原书证据。

原书依据 · 1 处

接待方法桥接双派发

客户端以Acceptable引用调用accept时,动态派发找到具体元素的实现。在Candy.accept内部,this的编译期类型是Candy,因此visit(this)选中visit(Candy)签名,再根据访问者对象调用对应实现。书中List直接visit失败,是可用重载没有接收Product的匹配方法;这不意味着Java重载一概禁止泛型参数。双派发在此是两次调用组合出的设计,不是运行时重新按实参类型选择重载。

知识卡与原书证据。

原书依据 · 1 处

第23章 观察者

本章从买家反复询问商店库存,转向商店保存预订名单并主动通知。Shop在setProduct后遍历Buyer,PhoneFans等具体观察者依自己的规则响应。主动方从多名观察者变为主题,适合用来理解一对多的事件回调。

示例只模拟状态通知,库存被假设为不限量,打印购买不表示发生真实交易。HandChopper片段缺少inform(String product)参数而引用未声明的product,和抽象签名不一致,不能原样视为可编译实现。主题仍直接持有观察者,通知也未实现异步和可靠交付。原书“HTTP无状态所以不能推送”的说法过宽:HTML标准EventSource就支持通过HTTP接收服务端事件,WebSocket不是唯一选择。

外部澄清依据:WHATWG Server-sent events(2026-10-24读取),与原书例子区分。

观察者响应变化

观察者模式由主题保存订阅者,在约定事件发生时调用共同响应接口。书中Shop.register保存Buyer,setProduct先更新商品再调用notifyBuyers,逐一把商品传给inform;PhoneFans按内容过滤。这改变了反复查询的驱动方向。示例每次设置都通知,没有判断值是否真的改变;通知是当前调用栈中的直接方法调用,并未提供异步、重试、持久化或失败隔离。

结构图:类图(实际类型与关键方法;空心三角实线为继承,虚线为接口实现,关联指向被使用对象)。

classDiagram
class Shop {
-String product
-List~Buyer~ buyers
+register(Buyer buyer) void
+setProduct(String product) void
+notifyBuyers() void
}
class Buyer {
<<abstract>>
+inform(String product) void
}
class PhoneFans {
+inform(String product) void
}
Buyer <|-- PhoneFans
Shop --> Buyer : 保存订阅者并通知

知识卡与原书证据。

原书依据 · 1 处

发布订阅降耦

主题依赖观察者的共同接口而不写死每个具体响应,订阅关系让新响应者能够加入。书中Shop仍直接保存Buyer对象并同步调用,因而减少的是对具体实现的依赖,不是完全不认识消费者,也不等同于经过独立消息代理的架构。回调过慢、抛错、重复注册、退订与遍历时成员变化,都需要定义处理规则;不能仅凭发布订阅名称推断交付保证。

知识卡与原书证据。

原书依据 · 1 处

第24章 解释器

解释器为选定语法建立表达式类型,把叶子操作和组合操作放在共同Expression接口后。书中用鼠标脚本说明层次:Move、按下、松开与Delay负责单元行为;LeftKeyClick、Repetition、Sequence组织复合行为,根节点递归调用子节点完成解释。原子性取决于这套语言的语法粒度。

实际代码由客户端直接构造对象树,Parser或Evaluator只被提议,没有完成脚本文本解析。鼠标动作是打印模拟,Delay调用sleep影响当前线程,不是挂起整个进程。Repetition还会消费自身的loopCount,重复执行同一树会改变行为;树的结构可复用不代表求值状态天然可复用。介绍Java编译执行的段落仅作背景类比,本笔记不将其简化为所有实现只能解释执行。

解释器建语法树

解释器将选定语言的规则表示为表达式类,再递归解释组合起来的树。书中客户端手工构建Sequence,内含Move、Repetition及Delay,调用根interpret后逐层执行。示例展示的是表达式对象的求值与动作组织,没有实现从脚本文本生成树的语法分析器,也没有真的驱动鼠标。它适合展示小语言的规则结构,不能据此声称覆盖任意复杂语言的解析。

结构图:类图(实际类型与关键方法;空心三角实线为继承,虚线为接口实现,关联指向被使用对象)。

classDiagram
class Expression {
<<interface>>
+interpret() void
}
class Move {
-int x
-int y
+interpret() void
}
class Delay {
-int seconds
+interpret() void
}
class Sequence {
-List~Expression~ expressions
+interpret() void
}
class Repetition {
-int loopCount
-Expression loopBodySequence
+interpret() void
}
class LeftKeyClick {
-Expression leftKeyDown
-Expression leftKeyUp
+interpret() void
}
Expression <|.. Move
Expression <|.. Delay
Expression <|.. Sequence
Expression <|.. Repetition
Expression <|.. LeftKeyClick
Sequence --> Expression : 有序解释
Repetition --> Expression : 重复解释
LeftKeyClick --> Expression : 按下后松开

知识卡与原书证据。

原书依据 · 1 处

表达式分终极非终极

终极表达式负责当前语法中不可再拆的单元,非终极表达式持有子表达式并组合解释。本章Move、LeftKeyDown、LeftKeyUp、Delay是叶节点;LeftKeyClick组织按下与松开,Sequence按列表顺序解释,Repetition重复解释一个子序列。原子性由所选语法粒度决定,不能由现实动作复杂度一概判断;这里借用组合结构,但关注的是每种节点的解释行为。

知识卡与原书证据。

原书依据 · 1 处

表达式复用要区分配置和状态

书中Repetition把loopCount当作字段,在interpret内部不断递减;第一次完整执行后变为0,同一表达式对象再次解释就不再执行循环体。语法树若需要复用,循环次数的配置与本次求值的进度应分开。类似地,解释器是否允许副作用、重复执行、取消和共享,并非共同interpret接口能够自动决定,必须由语言语义和执行上下文明确。

知识卡与原书证据。

原书依据 · 1 处

第25章 终道

最后一章把模式回收到设计原则:单一职责组织变化原因,开闭原则保护稳定部分,里氏替换要求实现满足抽象承诺,接口隔离让使用者只依赖必要能力,依赖倒置隔离高层策略与具体细节,最少知识减少内部结构的外泄。模式是这些目标的具体组织方式,而非应当逐个套用的目录。

书中的灯泡、画笔、鸟类、动物、管理层与游戏手柄类比有助于认识边界,但不能当作普遍业务分类或生物学结论。尤其“不得修改任何旧代码”“接口越细越好”需要结合章节末的适度设计理解:应满足当前和可预估变化,在收益超过间接层、类型数量与维护成本时才增加结构;需要时仍可以重构。

单一职责

单一职责以变化原因组织职责边界,使不属于同一目的的行为不互相牵动。书中把灯泡的通断与外部闪烁控制分开,责任链节点也各负其责。这并非要求一个类只能有一个方法,而是避免不相关变化混在一个模块;边界应由实际需求判断,不能把生活类比当成唯一正确的分类。

知识卡与原书证据。

原书依据 · 1 处

开闭原则

开闭原则希望稳定调用面对可预见的变化时,主要通过新增实现扩展,而少改已有核心逻辑。书中把多变的画笔绘画行为抽象出来,让不同笔触由实现提供。抽象和装配本身仍可能需要变化,修复错误也要修改代码;“对修改关闭”是控制变化传播的设计目标,不是禁止任何维护或为未知未来无限预留接口。

知识卡与原书证据。

原书依据 · 1 处

里氏替换

里氏替换要求具体实现满足抽象向使用者作出的行为承诺,而不只是语法上能赋值。书中把飞行从禽类剥离为Flyable,使不会飞的鸵鸟不必假装实现飞行,有能力的鸟、蝙蝠等再各自提供实现。应先确认抽象承诺是否适用于所有子类,再谈替换;继承声明本身不能证明业务行为兼容。

知识卡与原书证据。

原书依据 · 1 处

接口隔离

接口隔离让使用者只依赖任务所需的能力,避免实现者被迫提供无意义行为。书中将移动、发声拆成独立能力,以按需组合代替全能动物接口;动物故事只是建模类比,兔子并非生理上绝对不能发声。接口粒度应围绕使用者的真实需要,而不是机械拆成越多越好的一方法接口。

知识卡与原书证据。

原书依据 · 1 处

依赖倒置

依赖倒置以稳定抽象约束高层策略与底层实现,而不让业务层直接绑定具体数据源。书中业务层调用数据访问接口,数据库实现和测试替身满足该接口,降低替换时的影响。接口规范仍须包含业务所需语义;仅新增一个接口,或在构造器里注入对象,不足以自动消除具体实现泄漏和行为差异。

知识卡与原书证据。

原书依据 · 1 处

迪米特法则

最少知识原则限制一个模块了解和干预其他模块内部的范围。书中手柄只通过主机接口发送信号,门面窗口替调用者组织内部办理步骤,都在减少对内部结构的依赖。必要接口需要足以表达真实任务,不能为追求零知识层层增加无意义转发;重点是封装变化和控制通信范围。

知识卡与原书证据。

原书依据 · 1 处

适度设计

设计模式服务于可预见的变化,不是越多越好。发散:简单需求被拆成几十个类时,模式就从工具变成负担;真正的成熟是知道何时不用模式。

知识卡与原书证据。

原书依据 · 1 处

跨章综合

“用接口隔离变化”并不意味着所有接口目的相同。工厂接口限制创建职责,策略接口统一算法输入输出,命令接口让请求者不再直接了解设备方法;访问者反而明确列出一组稳定元素类型,用这种耦合换取新增算法的便利。要先判断哪条变化轴频繁,再比较模式的收益,不能因为都持有接口就视为同一种设计。

对象组织与运行保证也应分开。单例的共享范围、原型的拷贝深度、享元的共享状态、备忘录的快照范围,都要求明确“共享或恢复的到底是什么”。同样,责任链的转交、聊天室的注册、观察者的通知和命令的反向操作,各自只提供一种调用结构;业务结果、异常处理、并发和恢复语义仍需显式定义。教学例子暴露的边界正好提醒读者,模式不能代替完整契约。

flowchart TD
  A[识别真实变化与稳定契约] --> B{主要变化在哪里}
  B --> C[创建方式与构造步骤]
  B --> D[组合关系与接口接入]
  B --> E[算法 请求 状态及响应]
  C --> F[比较扩展收益与间接层成本]
  D --> F
  E --> F
  F --> G[明确业务结果 生命周期及失败边界]
  G --> H[按当前与可预估需求选择或简化]

这张图是读者对全书的选择思路整理,不是作者规定的开发流程;没有足够变化证据时,保持直接而清楚的设计同样合理。

读者延伸与实践

本轮保留两个现实问题,修订为可开始的有限计划。第一项利用当前关系计数决定是否需要改进关系说明;低频本身不能证明过度设计。第二项用本批真实CLI操作组织读写封装核查清单,撤回尚未在当前源码验证的历史行号及结论。它们是读者把设计原则应用于现有维护工作的延伸,不是作者对cardbox的判断。

  • 关系类型保留决策(计划文件见概览的实践卡进度):计划交付完成,实际抽样决策、源码调查与桌面演练尚未执行。
  • 读写封装核查清单(计划文件见概览的实践卡进度):计划交付完成,实际抽样决策、源码调查与桌面演练尚未执行。
生成进度与管理记录

秒懂设计模式 2021

类别:设计模式类(2026-09-25 经用户授权新建;此前记为软件设计与复杂性管理类)

本次实际使用规则:book-notes v8(2026-09-25 v8 复核:卡片正文、标题与摘录已合规(39/39 逐字命中),更正类别适配附注中的错误说法;另补主题索引维护),详见 _workflow.md。

整体评级

四象限结论:经典原理(高信息浓度 + 高稳定性)

理由:本书围绕面向对象三大特性、23 种 GoF 设计模式和 SOLID/LoD 原则展开,核心内容不依赖某个 Java 版本或工具链。虽然写法偏入门、生活类比很多,但每章都围绕“为什么需要这种拆分”“如何降低耦合”“适合什么变化场景”展开,例如第1章用 USB 接口解释封装、继承与多态的协作,第12章用动态代理引出 AOP 式横切逻辑,第13章用桥接说明笛卡儿积类爆炸,第25章把所有模式回收到职责、开闭、替换、接口、依赖和最少知识等原则上。这些判断逻辑在 5-10 年后的面向对象设计中仍然可迁移。

历史章节筛选说明(本轮不沿用完成状态)

25 个正文章均为精读:第1章奠定面向对象基础,第2-24章逐章讲解设计模式,第25章总结设计原则。版权、前言、服务与支持及“创建篇/结构篇/行为篇”等分篇页不计入正文追踪。

章节进度追踪表

章节号 章节标题 状态(pending/done) 卡片数
preface 前言 done 1
1 初探 done 5
2 单例 done 5
3 原型 done 4
4 工厂方法 done 2
5 抽象工厂 done 1
6 建造者 done 1
7 门面 done 1
8 组合 done 3
9 装饰器 done 2
10 适配器 done 1
11 享元 done 2
12 代理 done 4
13 桥接 done 2
14 模板方法 done 2
15 迭代器 done 3
16 责任链 done 2
17 策略 done 1
18 状态 done 2
19 备忘录 done 1
20 中介 done 2
21 命令 done 3
22 访问者 done 3
23 观察者 done 2
24 解释器 done 3
25 终道 done 7

历史汇总(非本轮完成证据)

  • 精读章节:25
  • 略读章节:0
  • 已生成卡片:39

实践卡进度

序号 实践标题 实践方式 状态(pending/done) 关联章节 产出
1 关系类型保留决策 决策实践 done 25 计划,当前只读计数已保存
2 读写封装核查清单 真实任务 done 1、25 计划

两项均为计划交付,尚未执行后续抽样、源码调查、决策和演练。原实践全文备份在本轮证据目录,历史数据不再作为当前事实。未采用重复实现23种模式:本轮目的在理解边界,不以重造示例代替成熟实现阅读;未选完整生产实验,当前没有对应目标或需要。动态代理、集合与输入流的成熟接口已在正文以官方文档澄清,不再重复生成同目标研究卡。

类别清单核对(设计模式类,2026-09-25 按新建类别重做)

维度 覆盖状态 关联卡片标题或未覆盖理由
面向对象基础与设计动机 已覆盖 [[封装留接口]]、[[多态降低耦合]]
创建型模式 已覆盖 [[单例控制唯一性]]、[[原型用对象造对象]]、[[深浅拷贝边界]]、[[工厂方法隔离创建]]、[[抽象工厂管产品族]]、[[建造者分离工序]]
结构型模式 已覆盖 [[门面压缩认知]]、[[组合统一层级]]、[[装饰器动态增强]]、[[适配器补齐契约]]、[[享元共享内在态]]、[[代理隔离访问]]、[[动态代理抽横切]]、[[桥接拆双维度]]
行为型模式 已覆盖 [[模板方法固流程]]、[[迭代器藏结构]]、[[责任链分段处理]]、[[策略封装算法]]、[[状态内聚转换]]、[[备忘录存快照]]、[[中介改星形网]]、[[命令对象化请求]]、[[访问者分离算法]]、[[观察者响应变化]]、[[解释器建语法树]]
模式之间的区别与选型 已覆盖 [[笛卡儿积爆炸]](继承与桥接的取舍)、[[发布订阅降耦]](与观察者对比)、[[命令解耦发送执行]]
设计原则与模式的关系 已覆盖 [[单一职责]]、[[开闭原则]]、[[里氏替换]]、[[接口隔离]]、[[依赖倒置]]、[[迪米特法则]]
适用边界、滥用与过度设计 已覆盖 [[适度设计]]、[[访问者怕结构变]]

核对结论:7/7 已覆盖。原“软件设计与复杂性管理类”核对结果(4/7)作废,类别适配问题已按用户授权以新建类别解决。

主题索引维护

本书讲解 GoF 23 种设计模式与设计原则;新建 GoF 设计模式 1 个主题,面向对象特性与设计原则卡同时并入 SOLID 设计原则、继承与组合、模块化等已有主题。

卡片标题 结论 主题文件或原因
封装留接口 已复用 notes/_topics/modularity-information-hiding.md
多态降低耦合 已复用 notes/_topics/inheritance-composition.md
单例控制唯一性 已创建 notes/_topics/gof-design-patterns.md
原型用对象造对象 已创建 notes/_topics/gof-design-patterns.md
深浅拷贝边界 已创建 notes/_topics/gof-design-patterns.md
工厂方法隔离创建 已创建 notes/_topics/gof-design-patterns.md
抽象工厂管产品族 已创建 notes/_topics/gof-design-patterns.md
建造者分离工序 已创建 notes/_topics/gof-design-patterns.md
门面压缩认知 已创建 notes/_topics/gof-design-patterns.md
组合统一层级 已创建 notes/_topics/gof-design-patterns.md
装饰器动态增强 已创建 notes/_topics/gof-design-patterns.md
适配器补齐契约 已创建 notes/_topics/gof-design-patterns.md
享元共享内在态 已创建 notes/_topics/gof-design-patterns.md
代理隔离访问 已创建 notes/_topics/gof-design-patterns.md
动态代理抽横切 已创建 notes/_topics/gof-design-patterns.md
桥接拆双维度 已创建 notes/_topics/gof-design-patterns.md
笛卡儿积爆炸 已创建 notes/_topics/gof-design-patterns.md、notes/_topics/inheritance-composition.md
模板方法固流程 已创建 notes/_topics/gof-design-patterns.md
迭代器藏结构 已创建 notes/_topics/gof-design-patterns.md
责任链分段处理 已创建 notes/_topics/gof-design-patterns.md
策略封装算法 已创建 notes/_topics/gof-design-patterns.md
状态内聚转换 已创建 notes/_topics/gof-design-patterns.md
备忘录存快照 已创建 notes/_topics/gof-design-patterns.md
中介改星形网 已创建 notes/_topics/gof-design-patterns.md
命令对象化请求 已创建 notes/_topics/gof-design-patterns.md
命令解耦发送执行 已创建 notes/_topics/gof-design-patterns.md
访问者分离算法 已创建 notes/_topics/gof-design-patterns.md
访问者怕结构变 已创建 notes/_topics/gof-design-patterns.md
观察者响应变化 已创建 notes/_topics/gof-design-patterns.md
发布订阅降耦 已创建 notes/_topics/gof-design-patterns.md
解释器建语法树 已创建 notes/_topics/gof-design-patterns.md
表达式分终极非终极 已创建 notes/_topics/gof-design-patterns.md
单一职责 已复用 notes/_topics/solid-principles.md
开闭原则 已复用 notes/_topics/solid-principles.md
里氏替换 已复用 notes/_topics/solid-principles.md
接口隔离 已复用 notes/_topics/solid-principles.md
依赖倒置 已复用 notes/_topics/solid-principles.md
迪米特法则 已复用 notes/_topics/solid-principles.md
适度设计 已复用 notes/_topics/architecture-principles-complexity.md

2026-10-24 本轮恢复

执行模式:light

建档进度:done

本轮实际规则:book-workflow v4 / book-notes v23。历史首次版本字段缺失,保留原有v8执行说明,不将本轮版本回填为首次版本。评级沿用经典原理,P1;旧类别和复核记录保留为历史。本轮缺覆盖记录,26项实质正文重新通读;前言含设计论述纳入,不再仅凭名称排除。本轮26项正文全文读取与生成完成;阶段2成果以当前文件和清单为准。

非正文排除

spine项 类型 排除理由
1 封面 标题封面无实质论述
2–3 版权 用于元数据,不生卡
4 内容提要 出版简介,与正文重复
6 服务支持 出版平台操作及联系方式
8、14、22 分篇页 仅创建篇、结构篇、行为篇标题,无实质解释

待关联术语

术语名 出现章节 一句话语境
OR-Mapping 22 将持久化记录与对象关联的背景名词,不是本章单独推导的机制。
POJO 22 本章将数据载体与算法分离的语境,不采纳“POJO必须只有访问器”作为普遍定义。
ArrayList 15 作为已有顺序集合使用,未展开动态数组机制。
HashMap 15 集合类型提名,未展开哈希实现。
HashSet 15 集合类型提名,未展开哈希实现。
调制解调器 10 作为数模转换与接口适配类比,未展开通信实现。
Controller 7 作为调用Service的上层提名,未展开框架实现。
DAO 7 作为数据访问层提名,未展开具体访问模式实现。
事务 7 仅提醒多步数据更新需要事务处理,未展开隔离或并发场景,不补造资金案例。
IoC 2 书中仅将Spring容器与对象托管联系,未展开依赖注入机制。

引用文献

标题 类型(书/论文/框架/源码项目) 出现章节 一句话语境

资金安全问题案例

问题标题 问题卡 解决方案卡(如有) 出现章节 一句话说明

实践候选筛选:done

整书笔记包含导读、全书主线、全部26项正文、跨章综合和实践概述。

本轮汇总:65知识卡(39历史卡保留路径,26新增),26/26正文完成,8项非正文排除;2实践计划,未执行。未执行笔记复核、独立审查及审查结果优化。历史类别与主题维护记录只作历史保留。

笔记版本:schema 1;字节SHA-256:5fbcb19fb1a0e83be04f3b302be67e64df8ea2178a538f4c82dfed9d9a074aec。

相关主题

从本书的主题进入跨书阅读,对照其他书籍的讲解。下方数量包含主题关联的全部卡片与书籍。

主题索引

行为型模式

把算法、职责与对象间通信分配清楚:责任链、命令、解释器、迭代器、中介者、备忘录、观察者、状态、策略、模板方法、访问者。

276 张卡片 · 14 本书

主题索引

架构设计原则与复杂度来源

比较架构要解决的复杂度来源(性能、可用性、扩展、成本、安全、规模)以及合适、简单、演化等设计原则。

228 张卡片 · 40 本书

主题索引

并发任务与同步原语

比较线程/任务抽象、异步结果传递、原子与同步手段的语义差异和生命周期约束。

215 张卡片 · 41 本书

主题索引

模块化与信息隐藏

比较以函数、闭包、包或服务划定模块边界并隐藏实现细节的方法。

209 张卡片 · 51 本书

主题索引

结构型模式

在类与对象的组合方式上做文章:适配器、桥接、组合、装饰、门面、享元、代理,以及包装家族的意图差异。

163 张卡片 · 14 本书

主题索引

创建型模式

把对象创建从使用中隔离出来:单例、工厂方法、抽象工厂、建造者、原型,以及各自的代价与语言差异。

104 张卡片 · 9 本书

主题索引

SOLID设计原则

比较单一职责、开闭、里氏替换、接口隔离、依赖反转五原则的准确含义,及其从类层面扩展到架构层面的用法。

86 张卡片 · 12 本书

主题索引

互斥、条件与死锁

互斥锁与读写锁的适用比例、信号量与 CountDownLatch 的语义差别、条件等待为什么必须持锁并循环复查、锁顺序与可重入导致的死锁,以及粗粒度锁换简单性与细粒度锁换并发的代价。

81 张卡片 · 21 本书

主题索引

内置数据结构的底层实现

比较字符串、数组、切片、哈希表等内置结构的内存布局、扩容与复制代价。

74 张卡片 · 10 本书

主题索引

接口设计与动态分派

比较接口粒度、隐式/显式实现、接口值表示与动态分派的取舍。

66 张卡片 · 18 本书

主题索引

模式语言与选型

模式之间的关系与意图对比、组合用法,以及模式在框架、语言与重构中的适用边界。

64 张卡片 · 15 本书

主题索引

内存模型与原子语义

原子不等于易变、volatile 不等于互斥,读改写为什么必须整体原子,竞态与数据争用的判定,内存屏障与顺序一致,双重检查锁与懒加载的发布问题,以及 Race 检测只覆盖运行路径的局限。

54 张卡片 · 19 本书

主题索引

继承、原型与组合复用

比较类继承、原型继承、函数化构造与组合在代码复用上的取舍。

50 张卡片 · 18 本书