罗罗编程学习记录
本页内容 展开查看

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 模式对象在构造中途处于「半初始化」状态,线程不安全。

原理流程

  1. 识别构造参数数量:必填 + 可选字段超过 5 个时问题开始显现。
  2. 对比可读性:重叠构造器需要从左到右数参数位置,builder 用字段名设置。
  3. 判断语言能力:支持命名参数的语言不需要 builder,直接用命名参数。
  4. 需要不可变对象时: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,构造器私有或包级可见。

原理流程

  1. 定义产品类,字段全部 private final,只暴露 getter。
  2. 定义 Builder 类,字段与产品对应,暴露 fluent setter。
  3. build() 方法:校验必填项 → 创建产品实例 → 返回。
  4. 调用方链式调用,最后一步 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() 函数,不破坏既有调用方。

原理流程

  1. 定义配置结构体,字段给合理默认值。
  2. 定义 Option 类型:func(*Config)。
  3. 每个可选项写一个导出函数 WithXxx(v T) Option,返回闭包修改对应字段。
  4. 构造函数:先建默认配置,遍历 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:提供默认值,减少必填字段数量。

原理流程

  1. 定义产品结构体与 Builder 结构体,Builder 字段用 Option<T> 表示可选。
  2. Builder 实现 Default,提供默认值。
  3. setter 接收 mut self,设置字段后返回 self。
  4. 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_builder crate 提供宏自动生成 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 等)更常用。

原理流程

  1. 基础方案:定义 Builder 类,setter 返回 this,build() 检查必填。
  2. 类型安全方案:用泛型 Builder<TSet extends Set<string>> 记录已设置字段。
  3. 每次 setter 交叉类型 TSet | {field: true}。
  4. 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 基础上加运行时类型校验,适合外部输入场景。

原理流程

  1. 定义 dataclass,必填字段无默认值,可选字段给默认值。
  2. 调用方用关键字参数构造对象,不需要 builder。
  3. 需要校验时用 pydantic BaseModel,自动校验字段类型与约束。
  4. 需要分步构造时用普通函数 + 中间变量,不需要 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 的另一种形态——构建查询语句,不是构建领域对象。

原理流程

  1. 简单场景:构造函数 + 命名参数 + 默认值,不需要 builder。
  2. 复杂校验:builder 的 build() 集中校验多个字段的约束关系。
  3. 查询构造器:链式 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 用于「从已有对象出发修改字段」。

原理流程

  1. 定义 record,字段一次性赋值。
  2. 需要新对象时:new Order(...) 从零构造,或 existing with { ... } 基于已有对象修改。
  3. 默认值:用 Default 静态属性或辅助方法提供默认 record 实例。
  4. 需要校验时:在构造器内校验,或用辅助工厂方法。

代码或图示

// 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)时浅不可变即可;字段是可变集合时需要深拷贝。

原理流程

  1. 产品类:所有字段 private final,只暴露 getter。
  2. 构造器:接收 builder 字段,对可变字段做防御性拷贝。
  3. 不暴露任何修改入口:没有 setter,没有 with 方法,没有 clone()。
  4. 继承控制:类声明为 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 原型模式解决什么问题?浅拷贝和深拷贝怎么区分?

一句话结论

原型模式通过克隆已有实例创建新对象,避免重复初始化成本;浅拷贝只复制对象本身,引用字段仍指向同一对象;深拷贝递归复制引用字段,副本与原型完全独立。

概念解释

  • 意图:当对象构造成本高(如从数据库加载、复杂计算)时,复制现有实例比重新构造更快。
  • 浅拷贝:复制对象的字段值,引用字段共享同一对象。
  • 深拷贝:递归复制所有引用字段,副本与原型完全独立。
  • 适用场景:配置模板复制、游戏角色克隆、批量生成状态相似的对象。
  • 不适用:对象构造成本低、字段都是基本类型、或需要深拷贝且循环引用复杂时。

原理流程

  1. 原型对象实现克隆方法,返回自身副本。
  2. 调用方先准备一个原型实例(初始化好)。
  3. 需要新对象时,克隆原型,按需修改差异字段。
  4. 可变引用字段:判断是否需要深拷贝,需要则递归复制。

代码或图示

// 浅拷贝: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:Clone trait 要求显式实现 clone(),默认语义由实现者决定,derive(Clone) 生成浅拷贝。

原理流程

  1. 识别对象的引用字段:哪些是可变的、需要独立副本。
  2. 选择浅拷贝还是深拷贝:引用字段不可变 → 浅拷贝;可变 → 深拷贝。
  3. 按语言惯用法实现:Java 覆盖 clone(),Python 用 copy 模块,JS 用 structuredClone,Rust 实现 Clone trait。
  4. 循环引用:深拷贝时维护已拷贝映射。

代码或图示

// 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,实现者自己决定是浅拷贝还是深拷贝;Copy trait 是更严格的「按位复制」标记,只适用于基本类型。

01.3.2.3-012 原型注册表怎么用?和工厂有什么区别?

一句话结论

原型注册表维护一个「名称 → 原型实例」的映射,需要新对象时按名称取出原型并克隆;它和工厂的区别在于:工厂每次 new 新对象,原型是从已有实例克隆,适合构造成本高或状态模板化的场景。

概念解释

  • 结构:注册表(Map)存原型实例,按名称查找并克隆。
  • 适用:对象初始化成本高(从配置加载、数据库查询),但大部分字段相同,只有少量差异。
  • 与工厂的区别:工厂是「从类创建新实例」,原型是「从实例克隆新实例」。
  • 与建造者的区别:建造者从零构建,原型从模板复制后修改差异。

原理流程

  1. 初始化阶段:准备好原型实例,注册到注册表。
  2. 请求阶段:按名称取原型,克隆出副本。
  3. 调用方在副本上修改差异字段,得到定制化对象。
  4. 原型本身不被修改,保持模板状态。

代码或图示

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 个、没有必填校验、没有多实现、创建只发生一次。

原理流程

  1. 识别变化点:是「换实现」还是「填字段」。
  2. 换实现 → 工厂;填字段 → 建造者。
  3. 两者都有 → 工厂选建造者,建造者组装对象。
  4. 评估成本:引入模式的代码量与理解成本,是否大于未来维护收益。

代码或图示

工厂:选择实现
  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 模式)