创建型设计模式是面向对象程序设计中用于处理对象创建机制的设计模式，旨在在不明确指定具体类的情况下创建对象。这些模式增加了程序的灵活性和代码的复用性。

添加图

片注释，不超过 140 字（可选）

1. 单例模式（Singleton Pattern）

单例模式确保一个类只有一个实例，并提供一个全局访问点。

class Singleton:
    _instance = None

    @classmethod
    def getInstance(cls):
        if cls._instance is None:
            cls._instance = Singleton()
        return cls._instance

# 用法
s1 = Singleton.getInstance()
s2 = Singleton.getInstance()
print(s1 == s2)  # 输出 True，s1 和 s2 是同一个实例 

应用价值：

• 资源管理：单例模式常用于管理共享资源，如数据库连接、文件系统等，确保资源在应用程序中只有一个访问点。
• 配置管理：用于应用程序的配置管理，确保配置信息在整个应用中保持一致和同步。
• 性能优化：通过减少对象创建和销毁的次数，减少内存开销，提高性能。

实际示例：

• 在应用程序中，例如日志记录器（logger）通常实现为单例，以确保所有的日志操作都使用同一个日志处理实例。
• 系统的配置管理器，确保应用程序在多个模块和组件间共享同一配置设置。

2. 工厂模式（Factory Pattern）

工厂模式用于创建对象，允许接口创建对象，但由子类决定要实例化的类是哪一个。工厂方法让类的实例化推迟到子类进行。

class Button:
    def paint(self):
        pass

class WindowsButton(Button):
    def paint(self):
        print("Render a button in a Windows style.")

class MacOSButton(Button):
    def paint(self):
        print("Render a button in a MacOS style.")

class ButtonFactory:
    def create_button(self, os_type):
        if os_type == "Windows":
            return WindowsButton()
        elif os_type == "MacOS":
            return MacOSButton()

# 用法
factory = ButtonFactory()
button = factory.create_button("Windows")
button.paint()  # 输出：Render a button in a Windows style.

应用价值：

• 封装创建逻辑：将对象的创建逻辑封装在一个单独的接口或类中，简化客户端代码，使客户端与具体的产品解耦。
• 支持新类型的动态引入：允许在不修改现有代码的情况下引入新的对象类型，增加程序的灵活性。
• 代码复用：通过使用统一的接口创建对象，减少代码重复。

实际示例：

• 一个应用程序支持多种不同类型的数据库连接（如 MySQL、Oracle、PostgreSQL），可以使用工厂模式来创建与特定数据库系统对应的连接对象。
• GUI应用程序中，根据不同操作系统来创建适应各个系统的UI元素

3. 抽象工厂模式（Abstract Factory Pattern）

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

工厂模式专注于单一产品（按钮），而抽象工厂涉及产品族（按钮和滚动条），展示了抽象工厂在管理多种产品类型方面的能力。工厂模式每个工厂类只创建一种产品，而抽象工厂模式的每个工厂类可以创建多个不同种类的产品（产品族）。在工厂模式中，增加新的产品需要增加新的工厂类，适合产品种类较多但是产品类别不频繁增加的情况。而抽象工厂模式易于增加新的产品族，但是增加新的产品功能则需要修改抽象工厂的接口，适合产品族扩展的需求。

class Button:
    def paint(self):
        pass

class ScrollBar:
    def paint(self):
        pass

class WindowsButton(Button):
    def paint(self):
        print("Render a button in a Windows style.")

class MacOSButton(Button):
    def paint(self):
        print("Render a button in a MacOS style.")

class WindowsScrollBar(ScrollBar):
    def paint(self):
        print("Render a scrollbar in a Windows style.")

class MacOSScrollBar(ScrollBar):
    def paint(self):
        print("Render a scrollbar in a MacOS style.")

class GUIFactory:
    def create_button(self):
        pass

    def create_scrollbar(self):
        pass

class WindowsFactory(GUIFactory):
    def create_button(self):
        return WindowsButton()
    
    def create_scrollbar(self):
        return WindowsScrollBar()

class MacOSFactory(GUIFactory):
    def create_button(self):
        return MacOSButton()

    def create_scrollbar(self):
        return MacOSScrollBar()

# 用法
factory = WindowsFactory() if os_type == "Windows" else MacOSFactory()
button = factory.create_button()
scrollbar = factory.create_scrollbar()
button.paint()  # 输出：Render a button in a Windows style.
scrollbar.paint()  # 输出：Render a scrollbar in a Windows style.

应用价值：

• 产品家族的一致性：确保一系列相关的产品设计到一起使用，而不必担心创建错误的对象。
• 系统的分层：允许系统分层，使复杂系统的管理和维护更加模块化。
• 增强程序的可扩展性：提供新的工厂和产品类族，而无需更改现有代码，使得系统更加灵活。

实际示例：

• 跨平台的UI框架，如Qt或wxWidgets，使用抽象工厂模式生成不同操作系统下的窗口和控件。
• 在电子商务应用中，为不同地区或不同类型的用户创建不同的产品组合和促销策略。

4. 原型模式（Prototype Pattern）

原型模式用于创建重复的对象，同时又能保证性能。这种模式实现了一个原型接口，该接口用于创建当前对象的克隆。

class Prototype:
    def __init__(self, name):
        self.name = name

    def clone(self):
        return copy.deepcopy(self)

# 用法
prototype = Prototype("原型")
cloned_prototype = prototype.clone()
print(prototype.name)  # 输出 "原型"
print(cloned_prototype.name)  # 输出 "原型"
print(prototype is cloned_prototype)  # 输出 False

应用价值：

• 性能优化：原型模式允许复制已有的实例，避免了新实例的创建成本，特别是在复杂对象的初始化非常资源密集时尤为有效。
• 动态加载和实例化：对象可以在运行时动态加载并创建其复制品，提高系统的灵活性。
• 减少子类的构造：原型模式减少了子类的构造，因为克隆过程可以替代子类的工作。

实际示例：

• 在游戏开发中，原型模式常用于创建复杂的对象，如游戏中的怪物或NPC，这些对象一旦被定义就可以被多次实例化。
• 文档编辑器中，原型模式可以用于复制和粘贴功能

5. 建造者模式（Builder Pattern）

建造者模式用于创建一种复杂的对象，它的组成部分可以一步步被构造。此模式允许你使用相同的构建过程创建不同的表示。

class Dialog:
    def __init__(self, title, cancelable=False):
        self.title = title
        self.cancelable = cancelable

    def show(self):
        print(f"显示对话框：标题为{self.title}，是否可取消：{self.cancelable}")

class DialogBuilder:
    def __init__(self):
        self.title = ""
        self.cancelable = False

    def set_title(self, title):
        self.title = title
        return self

    def set_cancelable(self, cancelable):
        self.cancelable = cancelable
        return self

    def build(self):
        return Dialog(self.title, self.cancelable)

# 用法
builder = DialogBuilder()
dialog = builder.set_title("我的对话框").set_cancelable(True).build()
dialog.show()  # 显示对话框：标题为我的对话框，是否可取消：True

应用价值：

• 构建复杂对象：允许逐步构建复杂对象，并允许按步骤明确地构造对象的不同部分。
• 控制细节的隐藏：客户端不需要知道内部的构建细节，建造者独立于对象的创建和表示。
• 提供变体：相同的构建过程可以创建不同的表示或设计，提高系统的灵活性。

实际示例：

• 在软件工程中，复杂对象的构建，如HTML或SQL查询构建器，可以利用建造者模式来分步骤构建不同的部分。
• Android开发中，AlertDialog的创建常用建造者模式，允许动态设置标题、内容、按钮等。