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

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

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）	高
建造者	分步构建复杂对象	对象配置多样、步骤复杂	中
原型	通过复制创建对象	创建成本高、需保留状态	低

选择决策树

复制代码

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