此笔记位置已失效,请从目录继续阅读。
全书导读
本书以生活类比和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的判断。
- 关系类型保留决策(计划文件见概览的实践卡进度):计划交付完成,实际抽样决策、源码调查与桌面演练尚未执行。
- 读写封装核查清单(计划文件见概览的实践卡进度):计划交付完成,实际抽样决策、源码调查与桌面演练尚未执行。