设计模式之创建型设计模式详细解析(含示例)

创建型模式 (Creational Patterns)：关注对象的创建机制，旨在将对象的创建与使用分离，提高系统的灵活性和可复用性。

---

目录

1. 单例模式 (Singleton)
2. 工厂方法模式 (Factory Method)
3. 抽象工厂模式 (Abstract Factory)
4. 建造者模式 (Builder)
5. 原型模式 (Prototype)

---

1. 单例模式 (Singleton)

定义

确保一个类只有一个实例，并提供一个全局访问点来访问这个唯一实例。

核心思想

• 唯一性：控制实例数量，确保全局只有一个实例
• 全局访问：提供统一的访问入口
• 延迟加载：首次使用时才创建实例（可选）

类比理解

公司CEO：

• 一个公司只能有一位CEO
• 所有公民都通过"CEO"这个称谓访问同一个人
• CEO职位是唯一的，但具体人选可以更替

结构

┌─────────────────┐
│   Singleton     │
├─────────────────┤
│ - _instance     │ ← 静态私有实例
│ - __init__()    │ ← 私有构造函数
├─────────────────┤
│ + get_instance()│ ← 静态获取方法
│ + business_logic│
└─────────────────┘

Python 实现

import threading
from typing import Optional

class Singleton:
    _instance: Optional['Singleton'] = None
    _lock: threading.Lock = threading.Lock()

    def __new__(cls, *args, **kwargs):
        if cls._instance is None:
            with cls._lock:
                if cls._instance is None:
                    cls._instance = super().__new__(cls)
                    cls._instance._initialized = False
        return cls._instance

    def __init__(self):
        if self._initialized:
            return
        self._initialized = True
        self.data = "单例数据"
        print("单例实例被创建")

    def do_something(self):
        return f"执行操作，当前数据: {self.data}"


# 使用示例
print("=== 单例模式测试 ===")
s1 = Singleton()
s2 = Singleton()

print(f"s1 和 s2 是同一对象: {s1 is s2}")  # True
print(f"s1 数据: {s1.do_something()}")

# 修改一个实例，影响所有引用
s1.data = "修改后的数据"
print(f"s2 看到的数据: {s2.data}")  # 也是"修改后的数据"

适用场景

• 数据库连接池管理
• 日志记录器
• 配置信息管理
• 线程池、缓存管理

注意事项

• 单例模式可能隐藏类之间的依赖关系
• 在多线程环境中需要特别注意线程安全
• 单元测试时可能带来困难（全局状态）

---

2. 工厂方法模式 (Factory Method)

定义

定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

核心思想

• 解耦：将对象创建与使用分离
• 扩展性：新增产品只需新增工厂，无需修改现有代码（开闭原则）
• 多态性：通过统一的接口创建不同类型的对象

类比理解

餐厅点餐系统：

• 顾客（客户端）说"我要一份主食"（抽象请求）
• 不同的分店（具体工厂）根据当地特色制作：
  • 川菜店 → 宫保鸡丁
  • 粤菜店 → 白切鸡
  • 鲁菜店 → 糖醋鲤鱼
• 顾客无需知道具体菜品如何制作，只需通过"点餐"接口

结构

┌───────────────┐         ┌───────────────┐
│   Creator     │────────→│    Product    │
├───────────────┤         ├───────────────┤
│+ factory_method│         │+ use()        │
│+ operation()  │         └───────────────┘
└───────┬───────┘                △
        │                        │
   ┌────┴────┐              ┌────┴────┐
   ▼         ▼              ▼         ▼
┌───────┐ ┌───────┐    ┌───────┐ ┌───────┐
│Concrete│ │Concrete│    │Concrete│ │Concrete│
│CreatorA│ │CreatorB│    │ProductA│ │ProductB│
└───────┘ └───────┘    └───────┘ └───────┘

Python 实现

from abc import ABC, abstractmethod

# 抽象产品
class Transport(ABC):
    @abstractmethod
    def deliver(self) -> str:
        pass

    @abstractmethod
    def capacity(self) -> str:
        pass

# 具体产品
class Truck(Transport):
    def deliver(self) -> str:
        return "卡车在公路上运输货物"

    def capacity(self) -> str:
        return "载重: 20吨"

class Ship(Transport):
    def deliver(self) -> str:
        return "轮船在海上运输货物"

    def capacity(self) -> str:
        return "载重: 5000吨"

class Airplane(Transport):
    def deliver(self) -> str:
        return "飞机在空中运输货物"

    def capacity(self) -> str:
        return "载重: 100吨"

# 抽象工厂
class LogisticsFactory(ABC):
    @abstractmethod
    def create_transport(self) -> Transport:
        pass

    def plan_delivery(self, goods: str) -> str:
        transport = self.create_transport()
        return f"计划配送 '{goods}'：{transport.deliver()}，{transport.capacity()}"

# 具体工厂
class RoadLogistics(LogisticsFactory):
    def create_transport(self) -> Transport:
        print("公路工厂生产卡车...")
        return Truck()

class SeaLogistics(LogisticsFactory):
    def create_transport(self) -> Transport:
        print("海运工厂生产轮船...")
        return Ship()

class AirLogistics(LogisticsFactory):
    def create_transport(self) -> Transport:
        print("航空工厂生产飞机...")
        return Airplane()

# 使用示例
print("=== 工厂方法模式：物流系统 ===")

def client_code(factory: LogisticsFactory, goods: str):
    print(factory.plan_delivery(goods))
    print()

factories = [
    (RoadLogistics(), "电子产品"),
    (SeaLogistics(), "原油"),
    (AirLogistics(), "紧急药品")
]

for factory, goods in factories:
    client_code(factory, goods)

适用场景

• 无法预知需要创建哪种具体对象
• 希望由子类决定创建的对象类型
• 需要扩展产品类型而不影响现有代码

与简单工厂的区别

特性	简单工厂	工厂方法
创建逻辑	集中在一个类中	分散在各个子类
扩展性	修改工厂类（违反开闭原则）	新增子类（符合开闭原则）
复杂度	简单	较复杂

---

3. 抽象工厂模式 (Abstract Factory)

定义

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

核心思想

• 产品族：创建一组相关的产品对象（如UI组件：按钮+文本框+下拉框）
• 一致性：确保同一产品族的对象风格一致
• 隔离性：不同产品族之间互不影响

类比理解

家具品牌套装：

• 现代风格工厂：生产玻璃桌 + 金属椅 + 简约灯
• 古典风格工厂：生产实木桌 + 皮椅 + 水晶灯
• 客户：选择"现代风格"后，获得的所有家具都是现代风格，不会出现混搭

结构

┌─────────────────┐
│ AbstractFactory │
├─────────────────┤
│+ createProductA()│
│+ createProductB()│
└────────┬────────┘
         │
    ┌────┴────┐
    ▼         ▼
┌───────┐ ┌───────┐
│Concrete│ │Concrete│
│Factory1│ │Factory2│
└───┬───┘ └───┬───┘
    │         │
    ▼         ▼
┌───────┐ ┌───────┐
│Product│ │Product│
│ A1+B1 │ │ A2+B2 │ ← 产品族
└───────┘ └───────┘

Python 实现

from abc import ABC, abstractmethod

# 抽象产品族：UI组件
class Button(ABC):
    @abstractmethod
    def render(self) -> str:
        pass

    @abstractmethod
    def on_click(self) -> str:
        pass

class TextField(ABC):
    @abstractmethod
    def render(self) -> str:
        pass

    @abstractmethod
    def input_text(self, text: str) -> str:
        pass

class Checkbox(ABC):
    @abstractmethod
    def render(self) -> str:
        pass

    @abstractmethod
    def toggle(self) -> str:
        pass

# 具体产品：Windows风格
class WinButton(Button):
    def render(self) -> str:
        return "[Windows风格按钮 - 直角边框]"

    def on_click(self) -> str:
        return "Windows按钮被点击（蓝色高亮）"

class WinTextField(TextField):
    def render(self) -> str:
        return "[Windows风格文本框 - 带边框]"

    def input_text(self, text: str) -> str:
        return f"Windows文本框输入: {text}"

class WinCheckbox(Checkbox):
    def render(self) -> str:
        return "[Windows风格复选框 - 方形]"

    def toggle(self) -> str:
        return "Windows复选框切换（显示√）"

# 具体产品：Mac风格
class MacButton(Button):
    def render(self) -> str:
        return "[Mac风格按钮 - 圆角渐变]"

    def on_click(self) -> str:
        return "Mac按钮被点击（弹性动画）"

class MacTextField(TextField):
    def render(self) -> str:
        return "[Mac风格文本框 - 无边框]"

    def input_text(self, text: str) -> str:
        return f"Mac文本框输入: {text}（平滑动画）"

class MacCheckbox(Checkbox):
    def render(self) -> str:
        return "[Mac风格复选框 - 圆形]"

    def toggle(self) -> str:
        return "Mac复选框切换（显示●）"

# 抽象工厂
class GUIFactory(ABC):
    @abstractmethod
    def create_button(self) -> Button:
        pass

    @abstractmethod
    def create_text_field(self) -> TextField:
        pass

    @abstractmethod
    def create_checkbox(self) -> Checkbox:
        pass

# 具体工厂
class WindowsFactory(GUIFactory):
    def create_button(self) -> Button:
        print("Windows工厂生产按钮...")
        return WinButton()

    def create_text_field(self) -> TextField:
        print("Windows工厂生产文本框...")
        return WinTextField()

    def create_checkbox(self) -> Checkbox:
        print("Windows工厂生产复选框...")
        return WinCheckbox()

class MacFactory(GUIFactory):
    def create_button(self) -> Button:
        print("Mac工厂生产按钮...")
        return MacButton()

    def create_text_field(self) -> TextField:
        print("Mac工厂生产文本框...")
        return MacTextField()

    def create_checkbox(self) -> Checkbox:
        print("Mac工厂生产复选框...")
        return MacCheckbox()

# 客户端代码
class Application:
    def __init__(self, factory: GUIFactory):
        self.factory = factory
        self.button = factory.create_button()
        self.text_field = factory.create_text_field()
        self.checkbox = factory.create_checkbox()

    def render_ui(self):
        print("渲染UI界面:")
        print(self.button.render())
        print(self.text_field.render())
        print(self.checkbox.render())

    def interact(self):
        print("用户交互:")
        print(self.button.on_click())
        print(self.text_field.input_text("Hello World"))
        print(self.checkbox.toggle())

# 使用示例
print("=== 抽象工厂模式：跨平台UI ===")

print("【配置1：Windows风格】")
app1 = Application(WindowsFactory())
app1.render_ui()
app1.interact()

print()
print("="*50)
print()

print("【配置2：Mac风格】")
app2 = Application(MacFactory())
app2.render_ui()
app2.interact()

适用场景

• 系统需要独立于产品的创建、组合和表示
• 系统需要配置多个产品族中的一个
• 需要强调一系列相关产品对象的设计以便联合使用

工厂方法与抽象工厂对比

维度	工厂方法	抽象工厂
产品数量	单一产品	产品族（多个相关产品）
抽象层次	一个抽象产品	多个抽象产品
复杂度	较低	较高
扩展产品族	容易（新增工厂）	困难（需修改所有工厂）

---

4. 建造者模式 (Builder)

定义

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

核心思想

• 分步构建：复杂对象的创建分解为多个步骤
• 灵活配置：可以按需选择构建步骤
• 隔离复杂性：客户端无需知道内部构建细节

类比理解

定制电脑装机：

• 装机单（Director）：定义装机流程（选CPU→选主板→选内存→组装测试）
• 装机师傅（Builder） ：执行具体装机操作
  • 游戏配置：i9 + RTX4090 + 64GB内存
  • 办公配置：i5 + 核显 + 16GB内存
• 客户：只需说明用途，无需知道如何插内存条

结构

┌─────────┐     ┌─────────────┐     ┌───────────┐
│ Director│────→│   Builder   │←────│  Client   │
├─────────┤     ├─────────────┤     └───────────┘
│ construct│     │+ buildPartA()│
└─────────┘     │+ buildPartB()│
                │+ getResult()  │
                └──────┬──────┘
                       │
              ┌────────┴────────┐
              ▼                 ▼
        ┌───────────┐     ┌───────────┐
        │ Concrete  │     │ Concrete  │
        │ Builder1  │     │ Builder2  │
        └───────────┘     └───────────┘

Python 实现

from abc import ABC, abstractmethod
from typing import Optional, List
from dataclasses import dataclass, field

# 产品：电脑
@dataclass
class Computer:
    cpu: str = ""
    gpu: str = ""
    ram: int = 0
    storage: str = ""
    motherboard: str = ""
    power_supply: str = ""
    case: str = ""
    rgb_lighting: bool = False
    water_cooling: bool = False
    wifi_module: bool = False

    def __str__(self) -> str:
        specs = [
            f"电脑配置清单:",
            f"   CPU: {self.cpu}",
            f"   GPU: {self.gpu}",
            f"   内存: {self.ram}GB",
            f"   存储: {self.storage}",
            f"   主板: {self.motherboard}",
            f"   电源: {self.power_supply}",
            f"   机箱: {self.case}",
            f"   RGB灯效: {'开启' if self.rgb_lighting else '关闭'}",
            f"   水冷散热: {'开启' if self.water_cooling else '关闭'}",
            f"   WiFi模块: {'开启' if self.wifi_module else '关闭'}",
        ]
        return "\n".join(specs)

# 抽象建造者
class ComputerBuilder(ABC):
    @abstractmethod
    def reset(self):
        pass

    @abstractmethod
    def set_cpu(self, model: str):
        pass

    @abstractmethod
    def set_gpu(self, model: str):
        pass

    @abstractmethod
    def set_ram(self, size: int):
        pass

    @abstractmethod
    def set_storage(self, spec: str):
        pass

    @abstractmethod
    def set_motherboard(self, model: str):
        pass

    @abstractmethod
    def set_power_supply(self, wattage: str):
        pass

    @abstractmethod
    def set_case(self, type: str):
        pass

    @abstractmethod
    def add_rgb_lighting(self):
        pass

    @abstractmethod
    def add_water_cooling(self):
        pass

    @abstractmethod
    def add_wifi_module(self):
        pass

    @abstractmethod
    def get_computer(self) -> Computer:
        pass

# 具体建造者
class GamingComputerBuilder(ComputerBuilder):
    def __init__(self):
        self.reset()

    def reset(self):
        self._computer = Computer()

    def set_cpu(self, model: str):
        self._computer.cpu = model if model else "Intel i9-13900K"
        return self

    def set_gpu(self, model: str):
        self._computer.gpu = model if model else "NVIDIA RTX 4090"
        return self

    def set_ram(self, size: int):
        self._computer.ram = size if size else 64
        return self

    def set_storage(self, spec: str):
        self._computer.storage = spec if spec else "2TB NVMe SSD + 4TB HDD"
        return self

    def set_motherboard(self, model: str):
        self._computer.motherboard = model if model else "ROG Z790-E Gaming"
        return self

    def set_power_supply(self, wattage: str):
        self._computer.power_supply = wattage if wattage else "1000W 80Plus Gold"
        return self

    def set_case(self, type: str):
        self._computer.case = type if type else "全塔侧透钢化玻璃"
        return self

    def add_rgb_lighting(self):
        self._computer.rgb_lighting = True
        print("添加RGB灯效系统")
        return self

    def add_water_cooling(self):
        self._computer.water_cooling = True
        print("安装360mm水冷散热")
        return self

    def add_wifi_module(self):
        self._computer.wifi_module = True
        print("集成WiFi 6E模块")
        return self

    def get_computer(self) -> Computer:
        computer = self._computer
        self.reset()
        return computer

class OfficeComputerBuilder(ComputerBuilder):
    def __init__(self):
        self.reset()

    def reset(self):
        self._computer = Computer()

    def set_cpu(self, model: str):
        self._computer.cpu = model if model else "Intel i5-13400"
        return self

    def set_gpu(self, model: str):
        self._computer.gpu = model if model else "Intel UHD 核显"
        return self

    def set_ram(self, size: int):
        self._computer.ram = size if size else 16
        return self

    def set_storage(self, spec: str):
        self._computer.storage = spec if spec else "512GB SATA SSD"
        return self

    def set_motherboard(self, model: str):
        self._computer.motherboard = model if model else "B660M 商务版"
        return self

    def set_power_supply(self, wattage: str):
        self._computer.power_supply = wattage if wattage else "400W 静音电源"
        return self

    def set_case(self, type: str):
        self._computer.case = type if type else "紧凑型商务机箱"
        return self

    def add_rgb_lighting(self):
        print("办公电脑不建议添加RGB灯效")
        return self

    def add_water_cooling(self):
        print("办公电脑使用风冷即可")
        return self

    def add_wifi_module(self):
        self._computer.wifi_module = True
        print("添加WiFi模块（办公便利）")
        return self

    def get_computer(self) -> Computer:
        computer = self._computer
        self.reset()
        return computer

# 指挥者（Director）
class ComputerDirector:
    def __init__(self, builder: ComputerBuilder):
        self._builder = builder

    def build_minimal(self) -> Computer:
        return (self._builder
                .set_cpu("")
                .set_ram(0)
                .get_computer())

    def build_full_featured(self) -> Computer:
        return (self._builder
                .set_cpu("")
                .set_gpu("")
                .set_ram(0)
                .set_storage("")
                .set_motherboard("")
                .set_power_supply("")
                .set_case("")
                .add_rgb_lighting()
                .add_water_cooling()
                .add_wifi_module()
                .get_computer())

# 使用示例
print("=== 建造者模式：电脑装机 ===")

print("【配置1：通过Director构建顶配游戏电脑】")
gaming_builder = GamingComputerBuilder()
director = ComputerDirector(gaming_builder)
gaming_pc = director.build_full_featured()
print(gaming_pc)

print()
print("="*50)
print()

print("【配置2：客户端自定义办公电脑】")
office_builder = OfficeComputerBuilder()
office_pc = (office_builder
             .set_cpu("Intel i7-13700")
             .set_ram(32)
             .set_storage("1TB NVMe SSD")
             .add_wifi_module()
             .get_computer())
print(office_pc)

print()
print("="*50)
print()

print("【配置3：自定义高端工作站】")
workstation_builder = GamingComputerBuilder()
workstation = (workstation_builder
               .set_cpu("AMD Ryzen 9 7950X")
               .set_gpu("NVIDIA RTX 4080")
               .set_ram(128)
               .set_storage("4TB NVMe SSD RAID")
               .add_water_cooling()
               .add_wifi_module()
               .get_computer())
print(workstation)

适用场景

• 创建复杂对象，且需要分步骤配置
• 对象有多种配置组合，需要避免"构造函数爆炸"
• 需要创建不同表示的相似对象

与工厂模式的区别

• 工厂模式：关注创建单个产品（是什么）
• 建造者模式：关注创建产品的过程（怎么做），支持分步骤、可配置

---

5. 原型模式 (Prototype)

定义

用原型实例指定创建对象的种类，并通过复制这些原型创建新的对象。

核心思想

• 克隆：通过复制现有对象创建新对象
• 避免子类化：无需通过子类创建对象
• 保留状态：新对象继承原对象的状态

类比理解

文件复印：

• 原版文件（原型）：一份已填写好的表格
• 复印机（克隆机制）：制作完全相同的副本
• 修改副本：可以在复印件上修改，不影响原件
• 效率：比重新填写一份新表格快得多

结构

┌─────────────────┐
│   Prototype     │
├─────────────────┤
│+ clone()        │ ← 克隆方法
└────────┬────────┘
         │
    ┌────┴────┐
    ▼         ▼
┌───────┐ ┌───────┐
│Concrete│ │Concrete│
│PrototypeA│ │PrototypeB│
└───────┘ └───────┘

Python 实现

import copy
from abc import ABC, abstractmethod
from typing import List, Optional, Dict, Any
from dataclasses import dataclass, field

# 抽象原型
class Prototype(ABC):
    @abstractmethod
    def clone(self) -> 'Prototype':
        pass

    @abstractmethod
    def deep_clone(self) -> 'Prototype':
        pass

# 具体原型：文档模板
@dataclass
class DocumentTemplate(Prototype):
    name: str = ""
    content: str = ""
    format_settings: Dict[str, Any] = field(default_factory=dict)
    metadata: Dict[str, Any] = field(default_factory=dict)
    sections: List[str] = field(default_factory=list)

    def __post_init__(self):
        if not self.format_settings:
            self.format_settings = {
                "font": "Arial",
                "font_size": 12,
                "line_spacing": 1.5,
                "margin": "2cm"
            }

    def clone(self) -> 'DocumentTemplate':
        print(f"浅拷贝文档: {self.name}")
        new_doc = copy.copy(self)
        new_doc.name = f"{self.name}_副本"
        return new_doc

    def deep_clone(self) -> 'DocumentTemplate':
        print(f"深拷贝文档: {self.name}")
        new_doc = copy.deepcopy(self)
        new_doc.name = f"{self.name}_深拷贝"
        return new_doc

    def display_info(self):
        print(f"  名称: {self.name}")
        content_preview = self.content[:30] + "..." if len(self.content) > 30 else self.content
        print(f"  内容: {content_preview}")
        print(f"  格式: {self.format_settings}")
        print(f"  章节: {self.sections}")
        print(f"  元数据: {self.metadata}")

# 原型管理器（注册表）
class DocumentRegistry:
    def __init__(self):
        self._prototypes: Dict[str, DocumentTemplate] = {}

    def register(self, key: str, prototype: DocumentTemplate):
        self._prototypes[key] = prototype
        print(f"注册模板: {key}")

    def unregister(self, key: str):
        del self._prototypes[key]
        print(f"注销模板: {key}")

    def create_document(self, key: str, deep: bool = False) -> Optional[DocumentTemplate]:
        prototype = self._prototypes.get(key)
        if prototype is None:
            print(f"未找到模板: {key}")
            return None

        if deep:
            return prototype.deep_clone()
        else:
            return prototype.clone()

    def list_templates(self):
        print("可用模板列表:")
        for key in self._prototypes.keys():
            print(f"   - {key}")

# 使用示例
print("=== 原型模式：文档模板系统 ===")

registry = DocumentRegistry()

print("【步骤1：创建并注册原型模板】")
report_template = DocumentTemplate(
    name="季度报告模板",
    content="【季度总结】\n1. 业绩概述\n2. 数据分析\n3. 下季度计划",
    sections=["封面", "目录", "正文", "附录"],
    metadata={"author": "公司模板", "version": "v2.0", "confidential": True}
)
registry.register("quarterly_report", report_template)

contract_template = DocumentTemplate(
    name="劳动合同模板",
    content="【劳动合同】\n甲方：[公司名称]\n乙方：[员工姓名]\n...",
    format_settings={"font": "宋体", "font_size": 14, "line_spacing": 2.0},
    sections=["合同条款", "签字页"],
    metadata={"type": "legal", "reviewed_by": "法务部"}
)
registry.register("employment_contract", contract_template)

registry.list_templates()

print()
print("【步骤2：基于原型创建新文档】")

print("--- 创建Q1报告（浅拷贝）---")
q1_report = registry.create_document("quarterly_report", deep=False)
if q1_report:
    q1_report.content = q1_report.content.replace("季度总结", "2024 Q1总结")
    q1_report.metadata["department"] = "销售部"
    q1_report.display_info()

print()
print("--- 创建Q2报告（深拷贝）---")
q2_report = registry.create_document("quarterly_report", deep=True)
if q2_report:
    q2_report.content = q2_report.content.replace("季度总结", "2024 Q2总结")
    q2_report.metadata["department"] = "技术部"
    q2_report.format_settings["font"] = "Times New Roman"
    q2_report.display_info()

print()
print("【步骤3：验证原型未被修改】")
print("原始模板状态:")
report_template.display_info()

print()
print("【步骤4：深拷贝 vs 浅拷贝对比】")
print("修改Q2报告的格式（深拷贝），观察是否影响Q1:")
print(f"Q1格式字体: {q1_report.format_settings['font']}")
print(f"Q2格式字体: {q2_report.format_settings['font']}")
print(f"原始模板字体: {report_template.format_settings['font']}")

print()
print("【步骤5：创建劳动合同实例】")
contract = registry.create_document("employment_contract", deep=True)
if contract:
    contract.content = contract.content.replace("[公司名称]", "科技创新有限公司")
    contract.content = contract.content.replace("[员工姓名]", "张三")
    contract.metadata["employee_id"] = "EMP2024001"
    contract.display_info()

适用场景

• 创建新对象成本较高（如需要复杂计算或数据库查询）
• 需要复制对象状态而不仅是创建空对象
• 类层次结构复杂，通过子类化创建对象不现实
• 需要避免与产品类层次结构平行的工厂类层次结构

深拷贝 vs 浅拷贝

特性	浅拷贝 (Shallow Copy)	深拷贝 (Deep Copy)
基本类型	复制值	复制值
引用类型	复制引用（共享对象）	递归复制整个对象
性能	快	慢
内存占用	少	多
修改影响	可能意外影响其他对象	完全独立
Python实现	copy.copy()	copy.deepcopy()

---

创建型模式对比总结

模式	核心意图	最佳使用场景	复杂度
单例	唯一实例控制	全局共享资源管理	低
工厂方法	延迟实例化到子类	需要灵活扩展产品类型	中
抽象工厂	创建产品族	需要保证产品一致性（跨平台UI）	高
建造者	分步构建复杂对象	对象配置多样、步骤复杂	中
原型	通过复制创建对象	创建成本高、需保留状态	低

选择决策树

需要控制实例数量？
├─ 是 → 单例模式
└─ 否 → 需要创建复杂对象？
    ├─ 是 → 需要分步配置？
    │   ├─ 是 → 建造者模式
    │   └─ 否 → 原型模式（复制现有）
    └─ 否 → 需要创建多种相关产品？
        ├─ 是 → 需要产品族一致性？
        │   ├─ 是 → 抽象工厂
        │   └─ 否 → 工厂方法
        └─ 否 → 简单工厂或直接创建