设计模式：探索常见设计模式与其实践中的应用

2023-09-10 10:35:41

设计模式：构建优雅代码的宝库

在软件开发领域，设计模式犹如一盏明灯，为我们指明了构建优雅代码的道路。这些模式为各种问题提供了经过验证的解决方案，帮助我们提高代码的可读性、可维护性和可扩展性。

一、单例模式：确保独一无二

单例模式就像一位独一无二的守护者，确保在系统中只有一个特定类实例的存在。它通过创建一个全局访问点来简化实例访问，同时防止多次创建同一对象。

class Singleton:
    _instance = None

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

二、工厂模式：创建对象的魔术棒

工厂模式犹如一间魔法工厂，为我们提供了创建对象的统一接口。它将创建过程从程序的主逻辑中分离出来，使代码更加简洁且易于维护。

class Factory:
    def create_product(self):
        pass

class ConcreteFactory1(Factory):
    def create_product(self):
        return Product1()

class ConcreteFactory2(Factory):
    def create_product(self):
        return Product2()

三、抽象工厂模式：更加抽象的工厂

抽象工厂模式是工厂模式的延伸，它为创建一组相关对象提供了一个统一的接口。该模式允许我们一次性创建一组协调一致的对象。

class AbstractFactory:
    def create_product_a(self):
        pass

    def create_product_b(self):
        pass

class ConcreteFactory1(AbstractFactory):
    def create_product_a(self):
        return ProductA1()

    def create_product_b(self):
        return ProductB1()

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

    def create_product_b(self):
        return ProductB2()

四、建造者模式：分步构建复杂对象

建造者模式就像一位熟练的工匠，它将构建复杂对象的流程分解成更小的步骤。该模式允许我们使用简单的接口逐步创建对象，而无需直接管理对象创建的内部细节。

class Builder:
    def __init__(self):
        self.product = None

    def build_part_a(self):
        pass

    def build_part_b(self):
        pass

    def build_part_c(self):
        pass

    def get_result(self):
        return self.product

class ConcreteBuilder(Builder):
    def build_part_a(self):
        self.product = Product()
        self.product.add_part_a()

    def build_part_b(self):
        self.product.add_part_b()

    def build_part_c(self):
        self.product.add_part_c()

五、原型模式：克隆的魔力

原型模式就像一位魔法师，它通过克隆现有对象的方式创建新对象。这种模式对于需要创建大量相似对象的情况非常有用，它可以节省大量的内存和计算资源。

class Prototype:
    def clone(self):
        pass

class ConcretePrototype1(Prototype):
    def clone(self):
        return ConcretePrototype1()

class ConcretePrototype2(Prototype):
    def clone(self):
        return ConcretePrototype2()

六、策略模式：动态行为选择

策略模式就像一位聪明的顾问，它提供了一个动态选择算法或行为的接口。该模式使我们可以轻松切换系统中的算法或行为，而无需修改程序的主逻辑。

class Strategy:
    def execute(self):
        pass

class ConcreteStrategy1(Strategy):
    def execute(self):
        print("执行算法 1")

class ConcreteStrategy2(Strategy):
    def execute(self):
        print("执行算法 2")

七、适配器模式：兼容性的桥梁

适配器模式犹如一座桥梁，它允许原本无法兼容的类或系统协同工作。该模式将一个接口转换成另一个接口，使原本不能一起工作的对象或系统能够相互通信。

class Adaptee:
    def specific_request(self):
        pass

class Adapter:
    def __init__(self, adaptee):
        self.adaptee = adaptee

    def request(self):
        self.adaptee.specific_request()

八、外观模式：统一的接口

外观模式就像一位优雅的公关经理，它为一系列复杂子系统提供了一个统一的接口。该模式隐藏了子系统内部的复杂性，使客户端代码与单个统一接口交互即可。

class Facade:
    def __init__(self, subsystem1, subsystem2, subsystem3):
        self.subsystem1 = subsystem1
        self.subsystem2 = subsystem2
        self.subsystem3 = subsystem3

    def operation(self):
        self.subsystem1.operation1()
        self.subsystem2.operation2()
        self.subsystem3.operation3()