01.3.2.3 建造者与原型模式
所属:全栈开发面试题库 / 01 计算机基础与通用工程 / 01.3 设计模式与架构基础 / 01.3.2 常用设计模式多语言详解
覆盖范围
- 重叠构造器(telescoping constructor)问题与痛点
- 链式建造者结构、必填校验与不可变对象产出
- Go functional options:最经典的惯用法,完整片段
- Rust 消耗式 builder(
self链式)与编译期校验 - TypeScript builder 与类型安全、分部可选参数
- Python 关键字参数与 dataclass 如何替代 builder
- PHP 命名参数与 builder 取舍
- C# record 与 with 表达式替代建造者
- 原型模式:浅拷贝与深拷贝的边界
- 各语言 clone 语义:Java Cloneable、C# MemberwiseClone、Python copy/deepcopy、JS structuredClone、Rust Clone trait
- 原型注册表与批量派生
- 原型与工厂的区别、建造者与工厂的取舍
面试题索引
| 编号 | 题目 | 难度 | 状态 | 备注 |
|---|---|---|---|---|
| 01.3.2.3-001 | 什么是重叠构造器(telescoping constructor)问题? | 基础 | 已完成 | 参数爆炸 |
| 01.3.2.3-002 | 链式建造者怎么写?必填校验放在哪一步? | 基础 | 已完成 | Builder 模式 |
| 01.3.2.3-003 | Go functional options 为什么是 Go 最经典的惯用法? | 进阶 | 已完成 | 选项函数 |
| 01.3.2.3-004 | Rust 消耗式 builder 怎么写?和 Java builder 有什么不同? | 高级 | 已完成 | 所有权 |
| 01.3.2.3-005 | TypeScript builder 怎么保证类型安全? | 进阶 | 已完成 | 泛型 builder |
| 01.3.2.3-006 | Python 关键字参数和 dataclass 怎么替代建造者? | 进阶 | 已完成 | 语言级替代 |
| 01.3.2.3-007 | PHP 命名参数出现后,builder 还需要吗? | 进阶 | 已完成 | 命名参数 |
| 01.3.2.3-008 | C# record 与 with 表达式为什么能替代大部分建造者? | 进阶 | 已完成 | 不可变类型 |
| 01.3.2.3-009 | 建造者怎么保证产出对象是不可变的? | 进阶 | 已完成 | 不可变性 |
| 01.3.2.3-010 | 原型模式解决什么问题?浅拷贝和深拷贝怎么区分? | 基础 | 已完成 | 克隆语义 |
| 01.3.2.3-011 | 各语言 clone 语义有什么差异? | 进阶 | 已完成 | 七语言对照 |
| 01.3.2.3-012 | 原型注册表怎么用?和工厂有什么区别? | 进阶 | 已完成 | 模板派生 |
| 01.3.2.3-013 | 建造者和工厂怎么选择?什么时候算过度设计? | 进阶 | 已完成 | 选型判断 |
01.3.2.3-001 什么是重叠构造器(telescoping constructor)问题?
一句话结论
重叠构造器用多个重载构造器层层叠加可选参数,参数一多就难以阅读、容易传错位置;调用方必须记住每个参数的位置与类型,同类型参数顺序错位时编译器不报错,只能靠测试发现。
概念解释
- 问题本质:可选参数组合爆炸,N 个可选字段需要 2^N 个构造器重载。
- 痛点:参数位置依赖记忆,同类型参数传错位(如
String name, String phone)编译器无法识别。 - 解法演进:JavaBean 模式(setter)→ 建造者模式(链式)→ 现代语言命名参数(Python/PHP/C#)。
- 副作用:JavaBean 模式对象在构造中途处于「半初始化」状态,线程不安全。
原理流程
- 识别构造参数数量:必填 + 可选字段超过 5 个时问题开始显现。
- 对比可读性:重叠构造器需要从左到右数参数位置,builder 用字段名设置。
- 判断语言能力:支持命名参数的语言不需要 builder,直接用命名参数。
- 需要不可变对象时:builder 构建完成后产出不可变对象,比 setter 模式更安全。
代码或图示
// 差:重叠构造器,参数位置难记
public class Order {
public Order(String id) { this(id, 0); }
public Order(String id, int amount) { this(id, amount, "pending"); }
public Order(String id, int amount, String status) { /* ... */ }
}
// 调用方:new Order("A1", 100, "pending") —— 第 2、3 个参数位置靠记忆
N 个可选字段 → 2^N 个构造器重载
调用方:数参数位置 → 同类型传错位 → 运行时才发现
常见误区
- 认为参数少也需要 builder:2-3 个字段时构造器最直接,builder 增加了类数量。
- 认为 setter 模式解决了问题:setter 模式对象可被中途修改,无法保证不可变,且构造中途状态不完整。
- 认为命名参数完全替代 builder:命名参数解决了位置问题,但必填校验、分步构造、不可变对象仍需要 builder。
追问
- Java 里 record 怎么解决这个问题?答:record 是全参构造器,所有字段一次性赋值,天然不可变;但可选字段仍需要 builder 或静态工厂方法处理默认值。
- 重叠构造器在哪些语言里不存在?答:Python、PHP、TypeScript、C# 等支持命名参数或默认值的语言,不需要构造器重载。
01.3.2.3-002 链式建造者怎么写?必填校验放在哪一步?
一句话结论
建造者模式:一个 Builder 类暴露字段设置方法并返回 this,链式调用逐步填充字段,最后 build() 方法校验必填项并产出不可变产品对象;校验放在 build() 中,确保不返回半成品。
概念解释
- 角色:产品(最终对象,通常不可变)、建造者(分步设置字段)。
- 链式:每个设置方法返回
this,支持builder.id("A").amount(100).build()。 - 必填校验:
build()内检查必填字段,缺失则抛异常,不返回不完整对象。 - 不可变产出:产品类只有 getter,没有 setter,构造器私有或包级可见。
原理流程
- 定义产品类,字段全部
private final,只暴露 getter。 - 定义 Builder 类,字段与产品对应,暴露 fluent setter。
build()方法:校验必填项 → 创建产品实例 → 返回。- 调用方链式调用,最后一步
build()得到不可变对象。
代码或图示
public final class Order {
private final String id;
private final int amount;
private final String status;
private Order(Builder b) {
this.id = b.id;
this.amount = b.amount;
this.status = b.status == null ? "pending" : b.status;
}
public static Builder builder() { return new Builder(); }
public static class Builder {
private String id;
private int amount;
private String status;
public Builder id(String id) { this.id = id; return this; }
public Builder amount(int a) { this.amount = a; return this; }
public Builder status(String s) { this.status = s; return this; }
public Order build() {
if (id == null || id.isBlank()) {
throw new IllegalStateException("id 必填");
}
if (amount < 0) {
throw new IllegalStateException("amount 不能为负");
}
return new Order(this);
}
}
}
// TypeScript builder
class OrderBuilder {
private id!: string;
private amount = 0;
private status = "pending";
id(id: string): this { this.id = id; return this; }
amount(a: number): this { this.amount = a; return this; }
status(s: string): this { this.status = s; return this; }
build(): Order {
if (!this.id) throw new Error("id 必填");
return new Order(this.id, this.amount, this.status);
}
}
常见误区
- 校验分散在各个 setter 里:应该集中在
build(),否则中途校验时机不一致。 - Builder 字段和产品字段共享引用:Builder 设置后,产品构造时应做防御性拷贝(尤其是集合字段),避免外部修改 Builder 影响产品。
- 产品类暴露 setter:建造者的目标是不可变产品,加了 setter 就等于放弃了这个优势。
追问
- Builder 模式和工厂方法的区别?答:工厂方法决定「造哪一类对象」,一步返回;建造者决定「怎么分步组装一个对象」,字段多、有校验、有默认值时用建造者。
- 怎么处理必填字段必须先设置?答:把必填字段作为
builder()方法的参数,或用编译期类型状态(如 Rust 的 typestate pattern)强制顺序。
01.3.2.3-003 Go functional options 为什么是 Go 最经典的惯用法?
一句话结论
Go functional options 用「接收配置的函数」替代 builder 类:每个选项是一个 func(*Config) 闭包,构造函数接收可变数量的选项函数,依次应用到默认配置上;它解决了 Go 没有构造器重载和命名参数的问题,是 Go 标准库和各大框架的通用做法。
概念解释
- 核心思想:选项函数
type Option func(*Server),每个函数修改配置结构体的一个字段。 - 可变参数:
NewServer(addr string, opts ...Option),调用方按需传入选项。 - 默认值:构造函数内先建默认配置,再逐个应用 opts 覆盖。
- 扩展性:新增可选参数只需加一个
WithXxx()函数,不破坏既有调用方。
原理流程
- 定义配置结构体,字段给合理默认值。
- 定义
Option类型:func(*Config)。 - 每个可选项写一个导出函数
WithXxx(v T) Option,返回闭包修改对应字段。 - 构造函数:先建默认配置,遍历 opts 依次应用,返回配置好的实例。
代码或图示
package server
import "time"
type Server struct {
addr string
readTimeout time.Duration
writeTimeout time.Duration
maxConns int
tlsEnabled bool
}
type Option func(*Server)
func WithReadTimeout(d time.Duration) Option {
return func(s *Server) { s.readTimeout = d }
}
func WithWriteTimeout(d time.Duration) Option {
return func(s *Server) { s.writeTimeout = d }
}
func WithMaxConns(n int) Option {
return func(s *Server) { s.maxConns = n }
}
func WithTLS() Option {
return func(s *Server) { s.tlsEnabled = true }
}
func New(addr string, opts ...Option) *Server {
// 默认配置
s := &Server{
addr: addr,
readTimeout: 5 * time.Second,
writeTimeout: 10 * time.Second,
maxConns: 100,
tlsEnabled: false,
}
// 应用选项
for _, opt := range opts {
opt(s)
}
return s
}
// 调用方
srv := server.New(":8080",
server.WithReadTimeout(3*time.Second),
server.WithMaxConns(500),
server.WithTLS(),
)
常见误区
- 选项函数返回错误:Option 应该是幂等的配置函数,错误应在构造函数最后校验,而不是在每个 Option 里返回。
- 把所有字段都做成 Option:必填字段(如
addr)作为构造函数位置参数,只有可选字段才做 Option。 - Option 函数内部做复杂业务逻辑:Option 只负责修改配置,不做 IO、不做校验,校验集中在
New最后。
追问
- functional options 和 builder 有什么区别?答:builder 是「一个类逐步设置字段」,functional options 是「一组函数修改配置」;Go 没有类,函数式选项更轻量,且天然支持可变参数扩展。
- 怎么在 Go 里做必填校验?答:
New函数在应用完所有选项后,检查必填字段是否合法,不合法返回(*Server, error),而不是 panic。
01.3.2.3-004 Rust 消耗式 builder 怎么写?和 Java builder 有什么不同?
一句话结论
Rust builder 的 setter 接收 self(消耗所有权)并返回 Self,链式调用后 build() 消费 builder 产出产品;这与 Java builder 返回 this(借用)不同,Rust 利用所有权系统在编译期保证 builder 被消耗后不可复用。
概念解释
- 消耗式:
fn id(mut self, id: String) -> Self,每次调用消耗原 builder,返回新 builder。 - 编译期保证:builder 一旦被
build()消费,就不能再用,避免「半成品 builder 被复用」。 - 类型状态模式:可以用不同类型的 builder 阶段强制设置顺序(如
NoIdBuilder→IdSetBuilder)。 - Default trait:提供默认值,减少必填字段数量。
原理流程
- 定义产品结构体与 Builder 结构体,Builder 字段用
Option<T>表示可选。 - Builder 实现
Default,提供默认值。 - setter 接收
mut self,设置字段后返回self。 build()方法消耗self,检查必填项,产出产品。
代码或图示
#[derive(Debug, Clone)]
struct Order {
id: String,
amount: u64,
status: String,
}
#[derive(Debug, Default)]
struct OrderBuilder {
id: Option<String>,
amount: Option<u64>,
status: Option<String>,
}
impl OrderBuilder {
fn new() -> Self {
Self::default()
}
fn id(mut self, id: impl Into<String>) -> Self {
self.id = Some(id.into());
self
}
fn amount(mut self, amount: u64) -> Self {
self.amount = Some(amount);
self
}
fn status(mut self, status: impl Into<String>) -> Self {
self.status = Some(status.into());
self
}
fn build(self) -> Result<Order, String> {
let id = self.id.ok_or("id 必填")?;
let amount = self.amount.unwrap_or(0);
let status = self.status.unwrap_or_else(|| "pending".to_string());
Ok(Order { id, amount, status })
}
}
// 调用
let order = OrderBuilder::new()
.id("A1")
.amount(100)
.build()
.unwrap();
常见误区
- setter 用
&mut self而不是self:这样 builder 可以被复用,不符合 Rust 消耗式 builder 的惯用法,也失去了编译期保证。 build()返回Result而不是 panic:Rust 惯例是可恢复错误返回Result,调用方显式处理。- 认为 Rust builder 和 Java builder 完全一样:核心差异是所有权——Rust builder 消耗后不可复用,Java builder 可以反复 set 再 build。
追问
- Rust 的 typestate pattern 怎么实现?答:用不同的结构体类型表示不同阶段(如
EmptyBuilder、IdSetBuilder),setter 转换类型,build()只在最终阶段类型上可用,编译期强制设置顺序。 derive(Builder)宏了解吗?答:derive_buildercrate 提供宏自动生成 builder,setter 默认返回&mut Self,需要配置finish_fn才能改成消耗式。
01.3.2.3-005 TypeScript builder 怎么保证类型安全?
一句话结论
TypeScript builder 可以用泛型 + 分部类型(Partial)实现「必填字段设置后才允许 build」的类型安全:通过泛型参数记录已设置的字段,build() 只在必填字段都为非空时才类型检查通过。
概念解释
- 基础 builder:和 Java 一样,setter 返回
this,build()内运行时校验。 - 类型安全 builder:用泛型记录已设置字段,
build()签名要求必填字段都已设置。 - 实际权衡:完全类型安全的 builder 代码复杂,项目中常用基础 builder + 运行时校验。
- 替代方案:TypeScript 的接口可选属性 + 工厂函数 + 运行时校验(zod 等)更常用。
原理流程
- 基础方案:定义 Builder 类,setter 返回
this,build()检查必填。 - 类型安全方案:用泛型
Builder<TSet extends Set<string>>记录已设置字段。 - 每次 setter 交叉类型
TSet | {field: true}。 build()要求TSet extends RequiredFields才允许调用。
代码或图示
// 基础 builder(最常用)
class OrderBuilder {
private id: string | null = null;
private amount = 0;
private status = "pending";
id(id: string): this { this.id = id; return this; }
amount(a: number): this { this.amount = a; return this; }
status(s: string): this { this.status = s; return this; }
build(): Order {
if (!this.id) throw new Error("id 必填");
return new Order(this.id, this.amount, this.status);
}
}
// 使用
const order = new OrderBuilder()
.id("A1")
.amount(100)
.build();
// 类型安全 builder:用交叉类型记录已设置字段
interface OrderFields {
id: string;
amount: number;
status: string;
}
function createOrderBuilder() {
const state: Partial<OrderFields> = {};
return {
id(id: string) { state.id = id; return this; },
amount(a: number) { state.amount = a; return this; },
status(s: string) { state.status = s; return this; },
build(): OrderFields {
if (!state.id) throw new Error("id 必填");
return state as OrderFields;
},
};
}
常见误区
- 认为 TypeScript 类型系统能完全替代运行时校验:编译期类型检查不覆盖运行时输入(如 API 响应、表单数据),运行时校验仍需要。
- builder 字段用
!断言非空:private id!: string跳过了空值检查,build()校验失效。 - 过度设计类型安全 builder:项目中 90% 的场景用基础 builder + 运行时校验足够,完全类型安全的 builder 只在框架级库中值得做。
追问
- TypeScript 里还有什么方式替代 builder?答:工厂函数 + 对象字面量:
createOrder({ id: "A1", amount: 100 }),配合接口定义,比 builder 更轻量。 - zod 怎么和 builder 配合?答:zod schema 做运行时校验,builder 收集字段,
parse()后产出类型安全对象,比手写 builder 更简洁。
01.3.2.3-006 Python 关键字参数和 dataclass 怎么替代建造者?
一句话结论
Python 原生支持关键字参数、默认值和可变参数 **kwargs,加上 dataclass / pydantic 的字段定义与校验,大部分 Java builder 场景在 Python 里直接用函数参数 + dataclass 就解决了,不需要 builder 类。
概念解释
- 关键字参数:
create_order(id="A1", amount=100),不需要记住参数位置。 - 默认值:函数参数直接给默认值,等价于 builder 的可选字段。
- dataclass:
@dataclass自动生成__init__,字段有类型注解和默认值。 - pydantic:在 dataclass 基础上加运行时类型校验,适合外部输入场景。
原理流程
- 定义 dataclass,必填字段无默认值,可选字段给默认值。
- 调用方用关键字参数构造对象,不需要 builder。
- 需要校验时用 pydantic BaseModel,自动校验字段类型与约束。
- 需要分步构造时用普通函数 + 中间变量,不需要 builder 类。
代码或图示
from dataclasses import dataclass, field
@dataclass
class Order:
id: str # 必填,无默认值
amount: int = 0 # 可选,默认 0
status: str = "pending" # 可选,默认 pending
tags: list[str] = field(default_factory=list)
# 调用方:关键字参数,等价于 builder
order = Order(id="A1", amount=100)
order2 = Order(id="B2", status="paid", tags=["vip"])
# pydantic:带运行时校验
from pydantic import BaseModel, field_validator
class Order(BaseModel):
id: str
amount: int = 0
status: str = "pending"
@field_validator("amount")
def amount_non_negative(cls, v: int) -> int:
if v < 0:
raise ValueError("amount 不能为负")
return v
常见误区
- Python 里硬套 Java builder:Python 有命名参数和 dataclass,builder 类是多余的,增加了代码量。
- dataclass 的可变默认值:
tags: list = []会被所有实例共享,必须用field(default_factory=list)。 - 认为 dataclass 是不可变的:默认 dataclass 是可变的,需要
@dataclass(frozen=True)才不可变。
追问
- Python 里什么时候还需要 builder?答:构造过程有复杂逻辑(如多步 IO、条件分支)、需要复用构造流程、或者需要链式 API 对外暴露时,才写 builder。
- frozen dataclass 和 Java 不可变对象有什么区别?答:frozen 只是阻止属性赋值,内部的可变对象(如 list)仍可修改;深度不可变需要用 tuple、frozenset 或 pydantic 的不可变配置。
01.3.2.3-007 PHP 命名参数出现后,builder 还需要吗?
一句话结论
PHP 8.0 引入命名参数后,大部分 builder 场景可以用构造函数 + 命名参数替代;但需要必填校验、分步构造、不可变对象产出时,builder 仍然有价值。Laravel 的 fluent 方法链(如 Builder 查询构造器)是另一种 builder 用法。
概念解释
- 命名参数:
new Order(id: "A1", amount: 100),不需要记住位置。 - 默认值:构造函数参数直接给默认值,等价于可选字段。
- builder 仍有价值的场景:多字段校验、构造过程复用、产出不可变对象。
- 查询构造器:Laravel 的
User::where('active', 1)->orderBy('id')->get()是 builder 的另一种形态——构建查询语句,不是构建领域对象。
原理流程
- 简单场景:构造函数 + 命名参数 + 默认值,不需要 builder。
- 复杂校验:builder 的
build()集中校验多个字段的约束关系。 - 查询构造器:链式 API 构建 SQL,和领域对象 builder 是同一思想的不同应用。
代码或图示
// PHP 8 命名参数 + 构造函数
class Order
{
public function __construct(
public readonly string $id,
public int $amount = 0,
public string $status = 'pending',
) {}
}
// 调用方
$order = new Order(id: 'A1', amount: 100);
// Laravel 查询构造器(fluent builder)
$users = User::query()
->where('active', true)
->orderBy('created_at', 'desc')
->limit(10)
->get();
常见误区
- 认为命名参数完全替代 builder:命名参数解决了位置问题,但不解决必填校验、分步构造和不可变产出。
- 把 Laravel 查询构造器和领域对象 builder 混淆:前者构建 SQL,后者构建领域对象,结构相似但意图不同。
readonly属性等于不可变:readonly只能在构造时赋值,不能后续修改,但内部的可变对象仍可修改。
追问
- PHP 里怎么做不可变对象?答:用
readonly属性(PHP 8.1+),或不暴露 setter,构造完成后只读。 - Laravel 的 builder 为什么是链式的?答:查询条件数量不确定,链式调用让调用方按需追加条件,不需要一次性传所有参数。
01.3.2.3-008 C# record 与 with 表达式为什么能替代大部分建造者?
一句话结论
C# record 是内置的不可变引用类型,自动生成全参构造器、值相等比较、with 表达式;with 表达式基于现有对象复制并修改部分字段,等价于「复制 + builder 修改几个字段 + 产出新对象」,比手写 builder 简洁得多。
概念解释
- record:
record Order(string Id, int Amount, string Status),自动生成不可变类型。 with表达式:order with { Amount = 200 },复制原对象并修改指定字段。- 值相等:record 按值比较,两个字段相同的 record 实例相等。
- 替代场景:builder 主要用于「从默认值出发逐步构建」,record + with 用于「从已有对象出发修改字段」。
原理流程
- 定义 record,字段一次性赋值。
- 需要新对象时:
new Order(...)从零构造,或existing with { ... }基于已有对象修改。 - 默认值:用
Default静态属性或辅助方法提供默认 record 实例。 - 需要校验时:在构造器内校验,或用辅助工厂方法。
代码或图示
// record:不可变,自动生成构造器
public record Order(string Id, int Amount, string Status = "pending");
// 从零构造
var order = new Order("A1", 100);
// with 表达式:基于已有对象修改
var paid = order with { Status = "paid", Amount = 200 };
// 默认实例 + with 模式
public static class OrderDefaults
{
public static Order Empty => new("", 0, "pending");
}
var order2 = OrderDefaults.Empty with { Id = "B2", Amount = 50 };
builder:空 → 逐步设置 → build()
record + with:已有对象 → 修改几个字段 → 新对象
常见误区
- record 是引用类型:record 是引用类型,但按值比较;赋值传递的是引用,不是深拷贝。
with是浅拷贝:with只复制 record 本身,引用类型字段仍共享引用,需要深度不可变时字段也要用 record 或不可变集合。- 认为 record 完全替代 builder:builder 适合「字段多、需要校验、分步构造」;record + with 适合「不可变对象复制修改」,场景不同。
追问
- record class 和 record struct 有什么区别?答:record class 是引用类型,record struct 是值类型,分配在栈上;值类型 record 有值语义但不适合大对象。
- C# 9 的 record 和 init-only 属性有什么关系?答:
init访问器允许对象初始化器设置属性,但构造后不可修改;record 隐式使用 init 属性,配合with表达式实现不可变更新。
01.3.2.3-009 建造者怎么保证产出对象是不可变的?
一句话结论
不可变对象的三个条件:所有字段 private final(或语言等价物)、不暴露 setter、构造完成后字段引用不被外部修改(防御性拷贝);builder 产出的对象从创建那一刻起就不能被改变。
概念解释
- 不可变的收益:线程安全(无需同步)、可自由共享、可作为 Map key、避免副作用。
- 破坏不可变的途径:暴露 setter、暴露内部可变集合的引用、构造后字段被外部修改。
- 防御性拷贝:builder 传入的集合字段,在产品构造时复制新集合,而不是直接引用。
- 浅不可变 vs 深不可变:字段是基本类型或不可变类型(String、Integer)时浅不可变即可;字段是可变集合时需要深拷贝。
原理流程
- 产品类:所有字段
private final,只暴露 getter。 - 构造器:接收 builder 字段,对可变字段做防御性拷贝。
- 不暴露任何修改入口:没有 setter,没有
with方法,没有clone()。 - 继承控制:类声明为
final(Java),防止子类破坏不可变约定。
代码或图示
public final class Order {
private final String id;
private final List<String> tags; // 可变字段
private Order(Builder b) {
this.id = b.id;
// 防御性拷贝:外部修改 Builder.tags 不影响 Order
this.tags = List.copyOf(b.tags); // 不可变集合
}
public String getId() { return id; }
public List<String> getTags() { return tags; } // 返回不可变集合
}
// Rust:字段不暴露可变引用,天然不可变
struct Order {
id: String,
tags: Vec<String>,
}
impl Order {
fn id(&self) -> &str { &self.id }
fn tags(&self) -> &[String] { &self.tags }
// 没有 &mut self 方法,外部无法修改
}
常见误区
- getter 直接返回内部可变集合引用:外部拿到
List后可以add(),破坏不可变;应返回不可变视图或拷贝。 - 认为
final字段就等于不可变:final引用不能重新赋值,但引用指向的对象内部仍可修改(如final List tags可以tags.add())。 - 忽略浅不可变的边界:字段是
String、Integer等不可变类型时安全;字段是自定义类或集合时,需要确认它们自身是否不可变。
追问
- 不可变对象一定是线程安全的吗?答:如果所有字段都是不可变类型,是的;如果字段是不可变类型的引用,但引用指向的对象可变,需要额外保护。
- 为什么 Java 的 String 是不可变的?答:String 被广泛共享(字符串常量池),不可变保证线程安全、可以作为 HashMap key、可以安全传递而不需要拷贝。
01.3.2.3-010 原型模式解决什么问题?浅拷贝和深拷贝怎么区分?
一句话结论
原型模式通过克隆已有实例创建新对象,避免重复初始化成本;浅拷贝只复制对象本身,引用字段仍指向同一对象;深拷贝递归复制引用字段,副本与原型完全独立。
概念解释
- 意图:当对象构造成本高(如从数据库加载、复杂计算)时,复制现有实例比重新构造更快。
- 浅拷贝:复制对象的字段值,引用字段共享同一对象。
- 深拷贝:递归复制所有引用字段,副本与原型完全独立。
- 适用场景:配置模板复制、游戏角色克隆、批量生成状态相似的对象。
- 不适用:对象构造成本低、字段都是基本类型、或需要深拷贝且循环引用复杂时。
原理流程
- 原型对象实现克隆方法,返回自身副本。
- 调用方先准备一个原型实例(初始化好)。
- 需要新对象时,克隆原型,按需修改差异字段。
- 可变引用字段:判断是否需要深拷贝,需要则递归复制。
代码或图示
// 浅拷贝:super.clone() 默认是浅拷贝
public class Address {
String city;
}
public class User implements Cloneable {
private String name;
private Address address; // 引用字段
@Override
public User clone() throws CloneNotSupportedException {
User u = (User) super.clone(); // 浅拷贝:address 引用共享
return u;
}
}
# Python:copy 浅拷贝,deepcopy 深拷贝
import copy
class User:
def __init__(self, name: str, address: dict):
self.name = name
self.address = address
original = User("Alice", {"city": "Beijing"})
shallow = copy.copy(original) # address 是同一个 dict
deep = copy.deepcopy(original) # address 是新的 dict
常见误区
- 浅拷贝后修改副本的引用字段:会影响原型和其他浅拷贝对象,典型的「改一个全变」bug。
- 深拷贝忽略循环引用:对象图有循环引用时,深拷贝需要维护「已拷贝对象 → 副本」映射,否则死循环。
- 认为原型模式就是
Cloneable:Cloneable只是 Java 的标记接口,原型模式的核心思想是「通过克隆创建新对象」,实现方式可以是拷贝构造方法、序列化、copy()方法等。
追问
- 深拷贝有哪些实现方式?答:拷贝构造方法(手动复制每个字段)、递归复制、序列化/反序列化(注意版本与性能)、框架工具(如 JSON 序列化)。
- 什么时候不需要深拷贝?答:引用字段指向的对象是不可变的(如 String、Integer、不可变集合),浅拷贝就够了;共享不可变对象没有风险。
01.3.2.3-011 各语言 clone 语义有什么差异?
一句话结论
Java 的 Cloneable 是浅拷贝标记,默认 super.clone() 只复制一层;C# 的 MemberwiseClone 同样是浅拷贝;Python 的 copy.copy / copy.deepcopy 分浅深两层;JavaScript 没有内建深拷贝,structuredClone 是现代标准;Rust 的 Clone trait 要求显式实现,默认是浅语义。
概念解释
- Java:
Cloneable标记接口,super.clone()浅拷贝,深拷贝需要手动覆盖引用字段。 - C#:
object.MemberwiseClone()浅拷贝,ICloneable接口已过时(语义不明确)。 - Python:
copy.copy()浅拷贝,copy.deepcopy()递归深拷贝,自动处理循环引用。 - JavaScript:
Object.assign/ spread 是浅拷贝,structuredClone()是标准深拷贝(不支持函数、Symbol)。 - Rust:
Clonetrait 要求显式实现clone(),默认语义由实现者决定,derive(Clone)生成浅拷贝。
原理流程
- 识别对象的引用字段:哪些是可变的、需要独立副本。
- 选择浅拷贝还是深拷贝:引用字段不可变 → 浅拷贝;可变 → 深拷贝。
- 按语言惯用法实现:Java 覆盖
clone(),Python 用copy模块,JS 用structuredClone,Rust 实现Clonetrait。 - 循环引用:深拷贝时维护已拷贝映射。
代码或图示
// Java:浅拷贝 + 手动深拷贝引用字段
@Override
protected User clone() throws CloneNotSupportedException {
User u = (User) super.clone();
u.address = this.address.clone(); // 手动深拷贝引用字段
return u;
}
// C#:MemberwiseClone 是浅拷贝
public class User
{
public string Name;
public Address Address;
public User ShallowCopy() => (User)MemberwiseClone();
}
// JavaScript:spread 浅拷贝,structuredClone 深拷贝
const original = { name: "Alice", address: { city: "Beijing" } };
const shallow = { ...original }; // address 是同一个对象
const deep = structuredClone(original); // address 是新对象
// Rust:derive(Clone) 生成浅拷贝
#[derive(Debug, Clone)]
struct User {
name: String,
address: Address, // Address 也需要实现 Clone
}
// clone() 是浅拷贝语义,但 String/Vec 内部数据会被复制(Rust 所有权)
let u2 = u1.clone();
常见误区
- Java
Cloneable是「深拷贝」:不是,默认是浅拷贝,Cloneable只是标记super.clone()不会抛异常。 - JavaScript
JSON.parse(JSON.stringify())是万能深拷贝:它会丢失函数、undefined、Date、Symbol、循环引用,只适用于纯数据对象。 - Rust
derive(Clone)是浅拷贝:对于String、Vec这类类型,Clone会复制内部数据;对于Box、Rc这类类型,Clone是增加引用计数(不深拷贝),语义由类型决定。
追问
- Python 的
deepcopy怎么处理循环引用?答:内部维护memo字典(id(original) → copy),遇到已拷贝的对象直接复用,不会死循环。 - Rust 为什么没有
ICloneable这种接口?答:Rust 把Clone做成 trait,实现者自己决定是浅拷贝还是深拷贝;Copytrait 是更严格的「按位复制」标记,只适用于基本类型。
01.3.2.3-012 原型注册表怎么用?和工厂有什么区别?
一句话结论
原型注册表维护一个「名称 → 原型实例」的映射,需要新对象时按名称取出原型并克隆;它和工厂的区别在于:工厂每次 new 新对象,原型是从已有实例克隆,适合构造成本高或状态模板化的场景。
概念解释
- 结构:注册表(Map)存原型实例,按名称查找并克隆。
- 适用:对象初始化成本高(从配置加载、数据库查询),但大部分字段相同,只有少量差异。
- 与工厂的区别:工厂是「从类创建新实例」,原型是「从实例克隆新实例」。
- 与建造者的区别:建造者从零构建,原型从模板复制后修改差异。
原理流程
- 初始化阶段:准备好原型实例,注册到注册表。
- 请求阶段:按名称取原型,克隆出副本。
- 调用方在副本上修改差异字段,得到定制化对象。
- 原型本身不被修改,保持模板状态。
代码或图示
public class PrototypeRegistry {
private final Map<String, User> prototypes = new HashMap<>();
public void register(String name, User prototype) {
prototypes.put(name, prototype);
}
public User create(String name) throws CloneNotSupportedException {
User prototype = prototypes.get(name);
if (prototype == null) throw new IllegalArgumentException(name);
return prototype.clone(); // 克隆原型
}
}
// 初始化
registry.register("vip", new User("default", 1000));
registry.register("normal", new User("default", 100));
// 使用
User vip = registry.create("vip");
vip.setName("Alice"); // 修改差异字段
# Python:字典存原型,copy 模块克隆
import copy
class PrototypeRegistry:
def __init__(self):
self._prototypes: dict[str, object] = {}
def register(self, name: str, prototype: object):
self._prototypes[name] = prototype
def create(self, name: str) -> object:
return copy.deepcopy(self._prototypes[name])
常见误区
- 原型对象被修改:原型是模板,不应在运行时被修改;克隆后修改副本,保持原型不变。
- 浅拷贝导致原型和副本共享状态:注册前确认原型的字段都是不可变的,或克隆时用深拷贝。
- 认为原型注册表就是工厂:结构相似(都是 Map 分发),但创建方式不同——工厂是
new,原型是clone;选择取决于构造成本与状态复用。
追问
- 原型模式在哪些场景常见?答:文档模板(合同模板、邮件模板)、游戏角色(基础角色模板 + 职业差异)、配置预设(默认配置 + 环境差异)。
- 原型和工厂方法可以组合吗?答:可以,工厂方法内部用原型克隆,而不是
new;对外仍是工厂接口,对内优化了创建成本。
01.3.2.3-013 建造者和工厂怎么选择?什么时候算过度设计?
一句话结论
工厂解决「造哪一类对象」(类型选择),建造者解决「怎么分步组装一个对象」(字段填充);两者可以组合——工厂选择建造者,建造者组装对象。只有一个实现、字段少、创建逻辑简单时,直接构造比引入模式更清晰。
概念解释
- 工厂:变化点在「实现选择」,输入类型标识,返回抽象产品。
- 建造者:变化点在「字段填充」,输入多组可选参数,返回完整对象。
- 组合:工厂内部选择 Builder,Builder 分步构建复杂产品。
- 过度设计信号:字段少于 5 个、没有必填校验、没有多实现、创建只发生一次。
原理流程
- 识别变化点:是「换实现」还是「填字段」。
- 换实现 → 工厂;填字段 → 建造者。
- 两者都有 → 工厂选建造者,建造者组装对象。
- 评估成本:引入模式的代码量与理解成本,是否大于未来维护收益。
代码或图示
工厂:选择实现
SenderFactory.create("sms") → SmsSender
关注:多态、实现替换
建造者:分步组装
Order.builder().id("A1").amount(100).build()
关注:多字段、必填校验、不可变产出
组合:
NotificationFactory.create(type) → 内部用 Builder 构建
工厂选类型,Builder 填字段
常见误区
- 字段少也上建造者:2-3 个字段用构造器或命名参数最直接。
- 用建造者在多个实现间切换:类型选择交给工厂,建造者只负责一个产品的字段填充。
- 认为模式越多越好:每个模式都是一层间接,间接层有成本;没有真实变化点时,直接代码最易维护。
追问
- 怎么判断建造者是不是过度设计?答:问「这个对象的字段会经常增加吗?必填校验会变复杂吗?」——如果答案都是否,直接构造就够了。
- 工厂和建造者哪个更常用?答:工厂在业务代码中更常用(因为多实现是常态);建造者在 SDK / 框架 / API 设计中更常用(因为字段多且需要稳定 API)。
跨语言差异对照
| 语言 | 惯用实现 | 差异要点 |
|---|---|---|
| Java | 链式 Builder 类 + build() 校验 |
Builder 是内部静态类,产品不可变;Cloneable 浅拷贝 |
| Go | functional options(Option 函数可变参数) |
没有类与构造器重载,选项函数是最经典惯用法 |
| Python | dataclass / pydantic + 关键字参数 | 命名参数天然替代 builder;copy.copy / deepcopy 分浅深 |
| PHP | 命名参数 + readonly 属性;Laravel fluent 查询构造器 |
PHP 8 命名参数解决位置问题;builder 主要用于查询构建器 |
| C#/.NET | record + with 表达式 |
record 内置不可变与值相等,with 替代大部分 builder 场景 |
| TypeScript | 工厂函数 + 对象字面量;可选接口 + 运行时校验 | 命名参数等价物(对象参数)天然替代 builder;structuredClone 标准深拷贝 |
| Rust | 消耗式 builder(self 链式)+ Clone trait |
所有权决定 builder 消耗后不可复用;Clone 语义由实现者决定 |
跨语言差异
- Go 是唯一没有类的语言,因此发展出了 functional options 这种独特的 builder 写法;它比 Java builder 更轻量,且天然支持可变参数扩展。
- Rust 的消耗式 builder 利用所有权系统在编译期保证 builder 被消耗后不可复用,这是其他语言做不到的。
- C# 的 record + with 表达式是「从已有对象修改字段」场景的最佳解,比手写 builder 简洁一个数量级。
- Python 和 PHP 有命名参数,大部分 builder 场景直接用函数参数就解决了,不需要 builder 类。
- TypeScript 的对象参数 + 接口可选属性是事实上的 builder 替代方案,比类 builder 更轻量。
- Java 是唯一需要手写完整 Builder 类的语言,因为它没有命名参数、没有 record、没有默认参数值。
- 原型模式在各语言的差异主要在 clone 语义:Java 的 Cloneable 是浅拷贝标记,Python 的 deepcopy 自动处理循环引用,Rust 的 Clone trait 语义由类型决定。
待整理清单
- [ ] 补充 Kotlin data class /
copy()与 named parameters 的 builder 替代方案 - [ ] 补充 Rust typestate pattern 实现编译期强制字段设置顺序
- [ ] 补充 Go functional options 的错误处理(返回 error 的选项函数)
- [ ] 补充 Java record 与 Builder 的组合模式(RecordBuilder 模式)