四种对象型创建模式：抽象工厂、 build模式、原型ProtoType与单例模式

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

组件框图

1┌─────────────────┐         ┌──────────────────┐
2│   Client        │         │ AbstractFactory  │
3├─────────────────┤         ├──────────────────┤
4│                 │───────>│+createProductA()  │
5│                 │         │+createProductB()  │
6└─────────────────┘         └──────────────────┘
7                                      △
8                     ┌─────────────────┼─────────────────┐
9           ┌──────────┴──────────┐            ┌──────────┴──────────┐
10           │ ConcreteFactory1    │            │ ConcreteFactory2    │
11           ├─────────────────────┤            ├─────────────────────┤
12           │+createProductA()    │            │+createProductA()    │
13           │+createProductB()    │            │+createProductB()    │
14           └─────────────────────┘            └─────────────────────┘
15                     │                                  │
16           ┌─────────┼─────────┐              ┌─────────┼─────────┐
17    ┌──────┴─────┐ ┌─┴──────┐        ┌──────┴─────┐ ┌─┴──────┐
18    │ ProductA1  │ │ProductB1│        │ ProductA2  │ │ProductB2│
19    └────────────┘ └─────────┘        └────────────┘ └─────────┘

详细描述

问题：
需要创建一系列相关或依赖的对象，但不希望指定具体的类。例如，需要创建跨平台的UI组件。

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

效果：

• 优点：保证产品系列的兼容性，易于交换产品系列
• 缺点：难以支持新种类的产品

Python实现

1from abc import ABC, abstractmethod
2
3# 抽象产品A
4class Button(ABC):
5    @abstractmethod
6    def render(self):
7        pass
8
9# 抽象产品B
10class Checkbox(ABC):
11    @abstractmethod
12    def paint(self):
13        pass
14
15# 具体产品A1
16class WindowsButton(Button):
17    def render(self):
18        return "渲染Windows风格按钮"
19
20# 具体产品B1
21class WindowsCheckbox(Checkbox):
22    def paint(self):
23        return "绘制Windows风格复选框"
24
25# 具体产品A2
26class MacButton(Button):
27    def render(self):
28        return "渲染macOS风格按钮"
29
30# 具体产品B2
31class MacCheckbox(Checkbox):
32    def paint(self):
33        return "绘制macOS风格复选框"
34
35# 抽象工厂
36class GUIFactory(ABC):
37    @abstractmethod
38    def create_button(self) -> Button:
39        pass
40    
41    @abstractmethod
42    def create_checkbox(self) -> Checkbox:
43        pass
44
45# 具体工厂1
46class WindowsFactory(GUIFactory):
47    def create_button(self) -> Button:
48        return WindowsButton()
49    
50    def create_checkbox(self) -> Checkbox:
51        return WindowsCheckbox()
52
53# 具体工厂2
54class MacFactory(GUIFactory):
55    def create_button(self) -> Button:
56        return MacButton()
57    
58    def create_checkbox(self) -> Checkbox:
59        return MacCheckbox()
60
61# 客户端代码
62class Application:
63    def __init__(self, factory: GUIFactory):
64        self.factory = factory
65        self.button = None
66        self.checkbox = None
67    
68    def create_ui(self):
69        self.button = self.factory.create_button()
70        self.checkbox = self.factory.create_checkbox()
71    
72    def paint(self):
73        print(self.button.render())
74        print(self.checkbox.paint())
75
76# 使用
77if __name__ == "__main__":
78    print("=== Windows UI ===")
79    windows_factory = WindowsFactory()
80    app1 = Application(windows_factory)
81    app1.create_ui()
82    app1.paint()
83    
84    print("\n=== macOS UI ===")
85    mac_factory = MacFactory()
86    app2 = Application(mac_factory)
87    app2.create_ui()
88    app2.paint()

C++实现

1#include <iostream>
2#include <memory>
3#include <string>
4
5// 抽象产品A
6class Button {
7public:
8    virtual ~Button() = default;
9    virtual std::string render() = 0;
10};
11
12// 抽象产品B
13class Checkbox {
14public:
15    virtual ~Checkbox() = default;
16    virtual std::string paint() = 0;
17};
18
19// 具体产品A1
20class WindowsButton : public Button {
21public:
22    std::string render() override {
23        return "渲染Windows风格按钮";
24    }
25};
26
27// 具体产品B1
28class WindowsCheckbox : public Checkbox {
29public:
30    std::string paint() override {
31        return "绘制Windows风格复选框";
32    }
33};
34
35// 具体产品A2
36class MacButton : public Button {
37public:
38    std::string render() override {
39        return "渲染macOS风格按钮";
40    }
41};
42
43// 具体产品B2
44class MacCheckbox : public Checkbox {
45public:
46    std::string paint() override {
47        return "绘制macOS风格复选框";
48    }
49};
50
51// 抽象工厂
52class GUIFactory {
53public:
54    virtual ~GUIFactory() = default;
55    virtual std::unique_ptr<Button> createButton() = 0;
56    virtual std::unique_ptr<Checkbox> createCheckbox() = 0;
57};
58
59// 具体工厂1
60class WindowsFactory : public GUIFactory {
61public:
62    std::unique_ptr<Button> createButton() override {
63        return std::make_unique<WindowsButton>();
64    }
65    
66    std::unique_ptr<Checkbox> createCheckbox() override {
67        return std::make_unique<WindowsCheckbox>();
68    }
69};
70
71// 具体工厂2
72class MacFactory : public GUIFactory {
73public:
74    std::unique_ptr<Button> createButton() override {
75        return std::make_unique<MacButton>();
76    }
77    
78    std::unique_ptr<Checkbox> createCheckbox() override {
79        return std::make_unique<MacCheckbox>();
80    }
81};
82
83// 客户端代码
84class Application {
85private:
86    std::unique_ptr<GUIFactory> factory;
87    std::unique_ptr<Button> button;
88    std::unique_ptr<Checkbox> checkbox;
89    
90public:
91    Application(std::unique_ptr<GUIFactory> factory) 
92        : factory(std::move(factory)) {}
93    
94    void createUI() {
95        button = this->factory->createButton();
96        checkbox = this->factory->createCheckbox();
97    }
98    
99    void paint() {
100        std::cout << button->render() << std::endl;
101        std::cout << checkbox->paint() << std::endl;
102    }
103};
104
105// 使用
106int main() {
107    std::cout << "=== Windows UI ===" << std::endl;
108    auto windowsFactory = std::make_unique<WindowsFactory>();
109    Application app1(std::move(windowsFactory));
110    app1.createUI();
111    app1.paint();
112    
113    std::cout << "\n=== macOS UI ===" << std::endl;
114    auto macFactory = std::make_unique<MacFactory>();
115    Application app2(std::move(macFactory));
116    app2.createUI();
117    app2.paint();
118    
119    return 0;
120}

2. 建造者模式 (Builder)

组件框图

1┌─────────────────┐         ┌──────────────────┐
2│   Director      │         │    Builder       │
3├─────────────────┤         ├──────────────────┤
4│+construct()     │───────>│+buildPartA()     │
5│                 │         │+buildPartB()     │
6│                 │         │+getResult()      │
7└─────────────────┘         └──────────────────┘
8                                      △
9                     ┌─────────────────┼─────────────────┐
10           ┌──────────┴──────────┐            ┌──────────┴──────────┐
11           │ ConcreteBuilder1    │            │ ConcreteBuilder2    │
12           ├─────────────────────┤            ├─────────────────────┤
13           │+buildPartA()        │            │+buildPartA()        │
14           │+buildPartB()        │            │+buildPartB()        │
15           │+getResult()         │            │+getResult()         │
16           └─────────────────────┘            └─────────────────────┘
17                     │                                  │
18           ┌─────────┴─────────┐              ┌─────────┴─────────┐
19           │     Product1      │              │     Product2      │
20           └───────────────────┘              └───────────────────┘

详细描述

问题：
创建复杂对象时，构造过程复杂且可能有多个步骤，或者需要创建不同表示的对象。

解决方案：
将复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。

效果：

• 优点：封装了复杂对象的创建过程，可以精细控制构建过程
• 缺点：增加了系统复杂度，需要多个具体建造者类

Python实现

1from abc import ABC, abstractmethod
2from typing import List
3
4# 产品类
5class Computer:
6    def __init__(self):
7        self.parts: List[str] = []
8    
9    def add(self, part: str):
10        self.parts.append(part)
11    
12    def list_parts(self):
13        return f"计算机配置: {', '.join(self.parts)}"
14    
15    def __str__(self):
16        return self.list_parts()
17
18# 抽象建造者
19class ComputerBuilder(ABC):
20    def __init__(self):
21        self.computer = Computer()
22    
23    @abstractmethod
24    def build_cpu(self):
25        pass
26    
27    @abstractmethod
28    def build_memory(self):
29        pass
30    
31    @abstractmethod
32    def build_storage(self):
33        pass
34    
35    @abstractmethod
36    def build_graphics_card(self):
37        pass
38    
39    def get_computer(self) -> Computer:
40        computer = self.computer
41        self.computer = Computer()  # 重置用于下次构建
42        return computer
43
44# 具体建造者 - 游戏电脑
45class GamingComputerBuilder(ComputerBuilder):
46    def build_cpu(self):
47        self.computer.add("Intel i9-13900K CPU")
48    
49    def build_memory(self):
50        self.computer.add("32GB DDR5 RAM")
51    
52    def build_storage(self):
53        self.computer.add("2TB NVMe SSD")
54    
55    def build_graphics_card(self):
56        self.computer.add("NVIDIA RTX 4090")
57
58# 具体建造者 - 办公电脑
59class OfficeComputerBuilder(ComputerBuilder):
60    def build_cpu(self):
61        self.computer.add("Intel i5-12400 CPU")
62    
63    def build_memory(self):
64        self.computer.add("16GB DDR4 RAM")
65    
66    def build_storage(self):
67        self.computer.add("512GB SSD + 1TB HDD")
68    
69    def build_graphics_card(self):
70        self.computer.add("Integrated Graphics")
71
72# 导演类
73class ComputerEngineer:
74    def __init__(self):
75        self.builder: ComputerBuilder = None
76    
77    def set_builder(self, builder: ComputerBuilder):
78        self.builder = builder
79    
80    def build_computer(self):
81        self.builder.build_cpu()
82        self.builder.build_memory()
83        self.builder.build_storage()
84        self.builder.build_graphics_card()
85        return self.builder.get_computer()
86    
87    def build_minimal_computer(self):
88        """构建简化版电脑"""
89        self.builder.build_cpu()
90        self.builder.build_memory()
91        return self.builder.get_computer()
92
93# 使用
94if __name__ == "__main__":
95    engineer = ComputerEngineer()
96    
97    # 构建游戏电脑
98    gaming_builder = GamingComputerBuilder()
99    engineer.set_builder(gaming_builder)
100    gaming_computer = engineer.build_computer()
101    print("=== 游戏电脑 ===")
102    print(gaming_computer)
103    
104    # 构建办公电脑
105    office_builder = OfficeComputerBuilder()
106    engineer.set_builder(office_builder)
107    office_computer = engineer.build_computer()
108    print("\n=== 办公电脑 ===")
109    print(office_computer)
110    
111    # 构建简化版办公电脑
112    minimal_office_computer = engineer.build_minimal_computer()
113    print("\n=== 简化版办公电脑 ===")
114    print(minimal_office_computer)

C++实现

1#include <iostream>
2#include <memory>
3#include <vector>
4#include <string>
5
6// 产品类
7class Computer {
8private:
9    std::vector<std::string> parts;
10    
11public:
12    void addPart(const std::string& part) {
13        parts.push_back(part);
14    }
15    
16    void listParts() const {
17        std::cout << "计算机配置: ";
18        for (size_t i = 0; i < parts.size(); ++i) {
19            std::cout << parts[i];
20            if (i != parts.size() - 1) {
21                std::cout << ", ";
22            }
23        }
24        std::cout << std::endl;
25    }
26};
27
28// 抽象建造者
29class ComputerBuilder {
30protected:
31    std::unique_ptr<Computer> computer;
32    
33public:
34    ComputerBuilder() : computer(std::make_unique<Computer>()) {}
35    virtual ~ComputerBuilder() = default;
36    
37    virtual void buildCPU() = 0;
38    virtual void buildMemory() = 0;
39    virtual void buildStorage() = 0;
40    virtual void buildGraphicsCard() = 0;
41    
42    std::unique_ptr<Computer> getComputer() {
43        auto result = std::move(computer);
44        computer = std::make_unique<Computer>();  // 重置用于下次构建
45        return result;
46    }
47};
48
49// 具体建造者 - 游戏电脑
50class GamingComputerBuilder : public ComputerBuilder {
51public:
52    void buildCPU() override {
53        computer->addPart("Intel i9-13900K CPU");
54    }
55    
56    void buildMemory() override {
57        computer->addPart("32GB DDR5 RAM");
58    }
59    
60    void buildStorage() override {
61        computer->addPart("2TB NVMe SSD");
62    }
63    
64    void buildGraphicsCard() override {
65        computer->addPart("NVIDIA RTX 4090");
66    }
67};
68
69// 具体建造者 - 办公电脑
70class OfficeComputerBuilder : public ComputerBuilder {
71public:
72    void buildCPU() override {
73        computer->addPart("Intel i5-12400 CPU");
74    }
75    
76    void buildMemory() override {
77        computer->addPart("16GB DDR4 RAM");
78    }
79    
80    void buildStorage() override {
81        computer->addPart("512GB SSD + 1TB HDD");
82    }
83    
84    void buildGraphicsCard() override {
85        computer->addPart("Integrated Graphics");
86    }
87};
88
89// 导演类
90class ComputerEngineer {
91private:
92    ComputerBuilder* builder;
93    
94public:
95    void setBuilder(ComputerBuilder* newBuilder) {
96        builder = newBuilder;
97    }
98    
99    std::unique_ptr<Computer> buildComputer() {
100        builder->buildCPU();
101        builder->buildMemory();
102        builder->buildStorage();
103        builder->buildGraphicsCard();
104        return builder->getComputer();
105    }
106    
107    std::unique_ptr<Computer> buildMinimalComputer() {
108        builder->buildCPU();
109        builder->buildMemory();
110        return builder->getComputer();
111    }
112};
113
114// 使用
115int main() {
116    ComputerEngineer engineer;
117    
118    // 构建游戏电脑
119    GamingComputerBuilder gamingBuilder;
120    engineer.setBuilder(&gamingBuilder);
121    auto gamingComputer = engineer.buildComputer();
122    std::cout << "=== 游戏电脑 ===" << std::endl;
123    gamingComputer->listParts();
124    
125    // 构建办公电脑
126    OfficeComputerBuilder officeBuilder;
127    engineer.setBuilder(&officeBuilder);
128    auto officeComputer = engineer.buildComputer();
129    std::cout << "\n=== 办公电脑 ===" << std::endl;
130    officeComputer->listParts();
131    
132    // 构建简化版办公电脑
133    auto minimalOfficeComputer = engineer.buildMinimalComputer();
134    std::cout << "\n=== 简化版办公电脑 ===" << std::endl;
135    minimalOfficeComputer->listParts();
136    
137    return 0;
138}

3. 原型模式 (Prototype)

组件框图

1┌─────────────────┐         ┌──────────────────┐
2│   Client        │         │   Prototype      │
3├─────────────────┤         ├──────────────────┤
4│                 │───────>│+clone()          │
5│                 │         └──────────────────┘
6└─────────────────┘                   △
7                             ┌─────────┴─────────┐
8                   ┌──────────┴──────────┐ ┌─────┴────────┐
9                   │ ConcretePrototype1  │ │ConcretePrototype2│
10                   ├─────────────────────┤ ├────────────────┤
11                   │+clone()             │ │+clone()        │
12                   │-field               │ │-field          │
13                   └─────────────────────┘ └────────────────┘

详细描述

问题：
需要创建的对象成本较高（如数据库操作、网络请求），或者希望避免使用子类来扩展对象创建。

解决方案：
通过复制现有对象来创建新对象，而不是通过新建类实例。

效果：

• 优点：避免重复初始化操作，动态添加或删除产品
• 缺点：复杂对象的克隆可能较困难，需要深拷贝考虑

Python实现

1import copy
2from abc import ABC, abstractmethod
3from typing import List, Dict
4
5# 原型接口
6class Prototype(ABC):
7    @abstractmethod
8    def clone(self):
9        pass
10
11# 具体原型 - 简历
12class Resume(Prototype):
13    def __init__(self, name: str = ""):
14        self.name = name
15        self.work_experience: List[str] = []
16        self.skills: List[str] = []
17        self.personal_info: Dict[str, str] = {}
18    
19    def set_personal_info(self, key: str, value: str):
20        self.personal_info[key] = value
21    
22    def add_work_experience(self, experience: str):
23        self.work_experience.append(experience)
24    
25    def add_skill(self, skill: str):
26        self.skills.append(skill)
27    
28    def clone(self):
29        """深拷贝克隆方法"""
30        return copy.deepcopy(self)
31    
32    def shallow_clone(self):
33        """浅拷贝克隆方法"""
34        return copy.copy(self)
35    
36    def display(self):
37        print(f"\n=== 简历: {self.name} ===")
38        print("个人信息:")
39        for key, value in self.personal_info.items():
40            print(f"  {key}: {value}")
41        
42        print("工作经历:")
43        for exp in self.work_experience:
44            print(f"  - {exp}")
45        
46        print("技能:")
47        for skill in self.skills:
48            print(f"  - {skill}")
49
50# 具体原型 - 图形对象
51class GraphicObject(Prototype):
52    def __init__(self, color: str = "black", x: int = 0, y: int = 0):
53        self.color = color
54        self.x = x
55        self.y = y
56        self.children: List[GraphicObject] = []
57    
58    def add_child(self, child: 'GraphicObject'):
59        self.children.append(child)
60    
61    def clone(self):
62        """深拷贝克隆，包括所有子对象"""
63        return copy.deepcopy(self)
64    
65    def __str__(self):
66        return f"GraphicObject(color={self.color}, position=({self.x},{self.y}), children={len(self.children)})"
67
68# 原型管理器
69class PrototypeManager:
70    def __init__(self):
71        self._prototypes: Dict[str, Prototype] = {}
72    
73    def register_prototype(self, name: str, prototype: Prototype):
74        self._prototypes[name] = prototype
75    
76    def unregister_prototype(self, name: str):
77        if name in self._prototypes:
78            del self._prototypes[name]
79    
80    def clone_prototype(self, name: str) -> Prototype:
81        if name in self._prototypes:
82            return self._prototypes[name].clone()
83        raise ValueError(f"原型 '{name}' 未注册")
84
85# 使用
86if __name__ == "__main__":
87    # 创建原型简历
88    original_resume = Resume("张三")
89    original_resume.set_personal_info("age", "28")
90    original_resume.set_personal_info("email", "[email protected]")
91    original_resume.add_work_experience("ABC公司 - 软件工程师 (2020-2023)")
92    original_resume.add_skill("Python")
93    original_resume.add_skill("C++")
94    
95    print("=== 原始简历 ===")
96    original_resume.display()
97    
98    # 克隆简历并修改
99    cloned_resume = original_resume.clone()
100    cloned_resume.name = "李四"
101    cloned_resume.set_personal_info("email", "[email protected]")
102    cloned_resume.add_work_experience("XYZ公司 - 高级工程师 (2023-至今)")
103    cloned_resume.add_skill("Java")
104    
105    print("\n=== 克隆并修改后的简历 ===")
106    cloned_resume.display()
107    
108    # 原型管理器使用
109    print("\n=== 原型管理器示例 ===")
110    manager = PrototypeManager()
111    manager.register_prototype("standard_resume", original_resume)
112    
113    # 快速创建多个相似简历
114    resume1 = manager.clone_prototype("standard_resume")
115    resume1.name = "王五"
116    resume1.display()
117    
118    # 图形对象克隆
119    print("\n=== 图形对象克隆 ===")
120    original_graphic = GraphicObject("red", 10, 20)
121    child1 = GraphicObject("blue", 5, 5)
122    child2 = GraphicObject("green", 15, 15)
123    original_graphic.add_child(child1)
124    original_graphic.add_child(child2)
125    
126    cloned_graphic = original_graphic.clone()
127    cloned_graphic.color = "yellow"
128    cloned_graphic.x = 30
129    
130    print(f"原始对象: {original_graphic}")
131    print(f"克隆对象: {cloned_graphic}")