设计模式之创建模式篇

君败红颜2024-11-23 18:03

设计模式是一种在软件设计中经常使用的、经过验证的解决方案，可以帮助开发者解决在设计和实现软件时常见的问题。在众多设计模式中，创建模式（Creational Patterns）是一类特别关注对象创建的模式。这些模式可以简化对象的创建过程，提高代码的灵活性和可维护性。本文将介绍几种常见的创建模式：单例模式（Singleton）、工厂模式（Factory）、抽象工厂模式（Abstract Factory）、建造者模式（Builder）和原型模式（Prototype）。

+-------------------+-------------------+-------------------+-------------------+-------------------+
|      模式         |      单例模式     |     工厂模式      |   抽象工厂模式     |     建造者模式     |     原型模式      |
+-------------------+-------------------+-------------------+-------------------+-------------------+-------------------+
|      目的         | 确保一个类只有   | 提供创建对象的     | 提供创建一系列相   | 将复杂对象的构建   | 通过复制现有对象   |
|                   | 一个实例          | 接口              | 关或依赖对象的接   | 与表示分离         | 来创建新对象       |
|                   |                   |                   | 口                |                   |                   |
+-------------------+-------------------+-------------------+-------------------+-------------------+-------------------+
|      使用场景     | 全局配置、日志记   | 创建对象的逻辑    | 创建多个产品族的   | 构建复杂的对象，   | 创建成本较高的对   |
|                   | 录、数据库连接    | 分散在多个子类中   | 对象需要统一处理   | 且需要不同的表示   | 象，避免重复的初   |
|                   |                   |                   |                   |                   | 始化过程           |
+-------------------+-------------------+-------------------+-------------------+-------------------+-------------------+
|      优点         | 确保单个实例，    | 封装对象创建过   | 提高系统结构的可   | 灵活地构建复杂对   | 避免重复的初始化   |
|                   | 简化全局访问点     | 程，减少依赖       | 拓性和可维护性     | 象，提高代码的可   | 过程，提高性能       |
|                   |                   |                   |                   | 维护性和灵活性     |                   |
+-------------------+-------------------+-------------------+-------------------+-------------------+-------------------+
|      缺点         | 单例模式可能导   | 工厂模式需要为   | 抽象工厂模式复杂   | 建造者模式可能导   | 原型模式需要实现   |
|                   | 致全局状态的    | 每个产品类型创   | 度较高，实施困难   | 致更多的类的创   | `clone` 方法，且   |
|                   | 管理问题          | 建具体的工厂类       |                   | 建                | 依赖于具体实现       |
+-------------------+-------------------+-------------------+-------------------+-------------------+-------------------+
1. 单例模式（Singleton）

单例模式确保一个类只有一个实例，并提供一个全局访问点。这种模式在全局配置、日志记录、数据库连接等场景中非常有用。

代码示例
class Singleton:
    _instance = None

    @staticmethod
    def get_instance():
        if Singleton._instance is None:
            Singleton._instance = Singleton()
        return Singleton._instance

    def __init__(self):
        if Singleton._instance is not None:
            raise Exception("This is a singleton class. Use get_instance() to get the single instance.")
        self.value = None

# 使用单例模式
s1 = Singleton.get_instance()
s1.value = "Singleton Value"

s2 = Singleton.get_instance()
print(s2.value)  # 输出: Singleton Value
2. 工厂模式（Factory）

工厂模式提供了一种创建对象的接口，但由子类决定实例化哪个类。工厂模式将对象的创建和使用分离，提高了代码的灵活性。

代码示例
from abc import ABC, abstractmethod

# 抽象产品类
class Product(ABC):
    @abstractmethod
    def operation(self):
        pass

# 具体产品类
class ConcreteProductA(Product):
    def operation(self):
        return "ConcreteProductA"

class ConcreteProductB(Product):
    def operation(self):
        return "ConcreteProductB"

# 工厂类
class Factory:
    def create_product(self, type):
        if type == "A":
            return ConcreteProductA()
        elif type == "B":
            return ConcreteProductB()
        else:
            raise ValueError("Invalid product type")

# 使用工厂模式
factory = Factory()
product_a = factory.create_product("A")
print(product_a.operation())  # 输出: ConcreteProductA

product_b = factory.create_product("B")
print(product_b.operation())  # 输出: ConcreteProductB
3. 抽象工厂模式（Abstract Factory）

抽象工厂模式提供了一种创建一系列相关或依赖对象的接口，而无需指定它们具体的类。这种模式适用于多个产品族（Product Families）的场合。

代码示例
from abc import ABC, abstractmethod

# 抽象产品类
class AbstractProductA(ABC):
    @abstractmethod
    def operation_a(self):
        pass

class AbstractProductB(ABC):
    @abstractmethod
    def operation_b(self):
        pass

# 具体产品类
class ConcreteProductA1(AbstractProductA):
    def operation_a(self):
        return "ConcreteProductA1"

class ConcreteProductA2(AbstractProductA):
    def operation_a(self):
        return "ConcreteProductA2"

class ConcreteProductB1(AbstractProductB):
    def operation_b(self):
        return "ConcreteProductB1"

class ConcreteProductB2(AbstractProductB):
    def operation_b(self):
        return "ConcreteProductB2"

# 抽象工厂类
class AbstractFactory(ABC):
    @abstractmethod
    def create_product_a(self):
        pass

    @abstractmethod
    def create_product_b(self):
        pass

# 具体工厂类
class ConcreteFactory1(AbstractFactory):
    def create_product_a(self):
        return ConcreteProductA1()

    def create_product_b(self):
        return ConcreteProductB1()

class ConcreteFactory2(AbstractFactory):
    def create_product_a(self):
        return ConcreteProductA2()

    def create_product_b(self):
        return ConcreteProductB2()

# 使用抽象工厂模式
factory1 = ConcreteFactory1()
product_a1 = factory1.create_product_a()
product_b1 = factory1.create_product_b()
print(product_a1.operation_a())  # 输出: ConcreteProductA1
print(product_b1.operation_b())  # 输出: ConcreteProductB1

factory2 = ConcreteFactory2()
product_a2 = factory2.create_product_a()
product_b2 = factory2.create_product_b()
print(product_a2.operation_a())  # 输出: ConcreteProductA2
print(product_b2.operation_b())  # 输出: ConcreteProductB2
4. 建造者模式（Builder）

建造者模式将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。这种模式适用于构建复杂对象的场合。

代码示例
from abc import ABC, abstractmethod

# 复杂产品类
class Product:
    def __init__(self):
        self.parts = []

    def add(self, part):
        self.parts.append(part)

    def show(self):
        print("Product Parts:")
        for part in self.parts:
            print(part)

# 抽象建造者类
class Builder(ABC):
    @abstractmethod
    def build_part_a(self):
        pass

    @abstractmethod
    def build_part_b(self):
        pass

    @abstractmethod
    def get_result(self):
        pass

# 具体建造者类
class ConcreteBuilder1(Builder):
    def __init__(self):
        self.product = Product()

    def build_part_a(self):
        self.product.add("Part A1")

    def build_part_b(self):
        self.product.add("Part B1")

    def get_result(self):
        return self.product

class ConcreteBuilder2(Builder):
    def __init__(self):
        self.product = Product()

    def build_part_a(self):
        self.product.add("Part A2")

    def build_part_b(self):
        self.product.add("Part B2")

    def get_result(self):
        return self.product

# 导演类
class Director:
    def build(self, builder):
        builder.build_part_a()
        builder.build_part_b()

# 使用建造者模式
director = Director()
builder1 = ConcreteBuilder1()
builder2 = ConcreteBuilder2()

director.build(builder1)
product1 = builder1.get_result()
product1.show()
# 输出:
# Product Parts:
# Part A1
# Part B1

director.build(builder2)
product2 = builder2.get_result()
product2.show()
# 输出:
# Product Parts:
# Part A2
# Part B2
5. 原型模式（Prototype）

原型模式通过复制一个现有对象来创建新对象，而不是通过调用构造函数。这种模式适用于创建成本较高的对象，并且希望避免重复的初始化过程。

代码示例
import copy

# 原型类
class Prototype:
    def clone(self):
        pass

# 具体原型类
class ConcretePrototype1(Prototype):
    def __init__(self, name):
        self.name = name

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

    def __str__(self):
        return f"ConcretePrototype1: {self.name}"

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

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

    def __str__(self):
        return f"ConcretePrototype2: {self.name}"

# 使用原型模式
prototype1 = ConcretePrototype1("Prototype1")
new_prototype1 = prototype1.clone()
print(new_prototype1)  # 输出: ConcretePrototype1: Prototype1

prototype2 = ConcretePrototype2("Prototype2")
new_prototype2 = prototype2.clone()
print(new_prototype2)  # 输出: ConcretePrototype2: Prototype2

总结

创建模式是设计模式中的一种重要类型，它们关注对象的创建过程，提供了一种更灵活、可维护的方式来创建对象。通过使用单例模式、工厂模式、抽象工厂模式、建造者模式和原型模式，我们可以有效地解决在对象创建过程中遇到的多种问题，提高代码的质量和可扩展性。

  • 单例模式：确保一个类只有一个实例，并提供一个全局访问点。
  • 工厂模式：提供创建对象的接口，由子类决定实例化哪个类。
  • 抽象工厂模式：提供创建一系列相关或依赖对象的接口，无需指定具体类。
  • 建造者模式：将复杂对象的构建与表示分离，使同样的构建过程可以创建不同的表示。
  • 原型模式：通过复制现有对象来创建新对象，避免重复的初始化过程。
相关推荐
等一场春雨11 小时前
Java设计模式 九 桥接模式 (Bridge Pattern)
java·设计模式·桥接模式
等一场春雨14 小时前
Java设计模式 十四 行为型模式 (Behavioral Patterns)
java·开发语言·设计模式
小王子102417 小时前
设计模式Python版 单例模式
python·单例模式·设计模式
_DCG_17 小时前
c++常见设计模式之装饰器模式
c++·设计模式·装饰器模式
快乐非自愿17 小时前
「全网最细 + 实战源码案例」设计模式——单例设计模式
java·单例模式·设计模式
阿绵17 小时前
设计模式-模板方法实现
java·开发语言·设计模式
晚秋贰拾伍17 小时前
设计模式的艺术-职责链模式
运维·设计模式·运维开发·责任链模式·开闭原则·单一职责原则
博一波17 小时前
【设计模式-行为型】状态模式
设计模式·状态模式
w(ﾟДﾟ)w吓洗宝宝了17 小时前
设计模式概述 - 设计模式的重要性
c++·设计模式
Cikiss17 小时前
「全网最细 + 实战源码案例」设计模式——工厂方法模式
java·后端·设计模式·工厂方法模式
热门推荐
01centos7 init.d 和system.d02Dell服务器升级ubuntu 22.04失败解决03半导体应用系统一些小知识收集(strip&wafer mapping,EAP&scada)04xgboost: Why not implement distributed XGBoost on top of spark05Windows10安装PCL1.14.0及点云配准06密码学原理技术-第六章-introduction to pulibc-key cryptography07PyTorch AMP 混合精度中grad_scaler.py的scale函数解析08Oracle Scheduler: Calendaring09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明10测试NV GPU SM的时钟是否一致