常见的编程设计模式

最新推荐文章于 2024-08-05 11:45:40 发布

阿布西

最新推荐文章于 2024-08-05 11:45:40 发布

阅读量1.2k

点赞数 3

文章标签： python 单例模式观察者模式迭代器模式简单工厂模式

本文链接：https://blog.csdn.net/weixin_45836201/article/details/129689030

版权

编程设计模式是一种被广泛使用的通用解决方案，用于解决在软件设计中常见的问题。以下是一些常见的编程设计模式：

工厂模式（Factory Pattern）：通过一个工厂类来创建对象，可以隐藏对象的实例化过程和具体实现细节，使得客户端代码更加简洁和灵活。
单例模式（Singleton Pattern）：保证一个类只有一个实例，并提供一个全局访问点，可以在需要时方便地获取该实例。
观察者模式（Observer Pattern）：定义一种一对多的依赖关系，当一个对象的状态发生变化时，所有依赖于它的对象都会得到通知并自动更新。
适配器模式（Adapter Pattern）：将一个类的接口转换成客户端所期望的另一种接口，从而使得原本由于接口不兼容而不能在一起工作的类能够协同工作。
策略模式（Strategy Pattern）：定义一系列算法，把它们一个个封装起来，并且使它们可以相互替换，可以在不修改客户端代码的情况下灵活地选择不同的算法。
迭代器模式（Iterator Pattern）：提供一种访问一个聚合对象中各个元素的方法，而不需要暴露该对象的内部表示。
装饰器模式（Decorator Pattern）：动态地给一个对象添加一些额外的职责，而不需要修改其原有的代码，可以在不改变对象结构的情况下，对其功能进行扩展和修改。
组合模式（Composite Pattern）：将对象组合成树形结构以表示“部分-整体”的层次结构，可以让客户端统一处理单个对象和对象组合。
命令模式（Command Pattern）：将一个请求封装成一个对象，从而使得可以使用不同的请求来参数化客户端对象，可以支持请求的排队、记录日志、撤销操作等功能。

模板方法模式（Template Method Pattern）：定义一个操作中的算法骨架，而将一些步骤延迟到子类中，可以使得子类可以不改变一个算法的结构即可重新定义该算法的某些特定步骤

#工厂模式
class Car:
    def drive(self):
        print("Driving a car")

class Truck:
    def drive(self):
        print("Driving a truck")

class VehicleFactory:
    def create_vehicle(self, vehicle_type):
        if vehicle_type == "car":
            return Car()
        elif vehicle_type == "truck":
            return Truck()

factory = VehicleFactory()
car = factory.create_vehicle("car")
car.drive()
truck = factory.create_vehicle("truck")
truck.drive()

单例模式

class Singleton:
    _instance = None

    def __new__(cls):
        if not cls._instance:
            cls._instance = super().__new__(cls)
        return cls._instance

s1 = Singleton()
s2 = Singleton()
print(s1 is s2)  # True

观察者模式

class Subject:
    def __init__(self):
        self.observers = []

    def register_observer(self, observer):
        self.observers.append(observer)

    def remove_observer(self, observer):
        self.observers.remove(observer)

    def notify_observers(self):
        for observer in self.observers:
            observer.update()

class Observer:
    def __init__(self, subject):
        self.subject = subject
        self.subject.register_observer(self)

    def update(self):
        print("Subject state has changed")

subject = Subject()
observer1 = Observer(subject)
observer2 = Observer(subject)
subject.notify_observers()

适配器模式

class Adaptee:
    def specific_request(self):
        return "Adaptee request"

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

    def request(self):
        return f"Adapter {self.adaptee.specific_request()}"

adaptee = Adaptee()
adapter = Adapter(adaptee)
print(adapter.request())

策略模式

class Context:
    def __init__(self, strategy):
        self.strategy = strategy

    def execute_strategy(self):
        self.strategy.execute()

class Strategy:
    def execute(self):
        pass

class StrategyA(Strategy):
    def execute(self):
        print("Strategy A executed")

class StrategyB(Strategy):
    def execute(self):
        print("Strategy B executed")

context = Context(StrategyA())
context.execute_strategy()
context.strategy = StrategyB()
context.execute_strategy()

迭代器模式

class Iterator:
    def __init__(self, data):
        self.index = 0
        self.data = data

    def has_next(self):
        return self.index < len(self.data)

    def next(self):
        value = self.data[self.index]
        self.index += 1
        return value

class Iterable:
    def __init__(self, data):
        self.data = data

    def __iter__(self):
        return Iterator(self.data)

data = [1, 2, 3]
iterable = Iterable(data)
for item in iterable:
    print(item)

装饰器模式

def decorator(func):
    def wrapper():
        print("Before function call")
        func()
        print("After function call")
    return wrapper

@decorator
def say_hello():
    print("Hello!")

say_hello()

组合模式

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

    def operation(self):
        pass

class Composite(Component):
    def __init__(self, name):
        super().__init__(name)
        self.children = []

    def add_child(self, child):
        self.children.append(child)

    def remove_child(self, child):
        self.children.remove(child)

    def operation(self):
        print(f"Composite {self.name} operation")
        for child in self.children:
            child.operation()

class Leaf(Component):
    def operation(self):
        print(f"Leaf {self.name} operation")

root = Composite("root")
root.add_child(Leaf("leaf1"))
root.add_child(Composite("composite1"))
composite2 = Composite("composite2")
composite2.add_child(Leaf("leaf2"))
composite2.add_child(Leaf("leaf3"))
root.add_child(composite2)
root.operation()

命令模式

class Command:
    def execute(self):
        pass

class ConcreteCommand(Command):
    def __init__(self, receiver):
        self.receiver = receiver

    def execute(self):
        self.receiver.action()

class Receiver:
    def action(self):
        print("Receiver action")

class Invoker:
    def __init__(self):
        self.commands = []

    def add_command(self, command):
        self.commands.append(command)

    def execute_commands(self):
        for command in self.commands:
            command.execute()

receiver = Receiver()
command1 = ConcreteCommand(receiver)
command2 = ConcreteCommand(receiver)
invoker = Invoker()
invoker.add_command(command1)
invoker.add_command(command2)
invoker.execute_commands()

模板方法模式

class AbstractClass:
    def template_method(self):
        self.operation1()
        self.operation2()

    def operation1(self):
        pass

    def operation2(self):
        pass

class ConcreteClass1(AbstractClass):
    def operation1(self):
        print("ConcreteClass1 operation1")

    def operation2(self):
        print("ConcreteClass1 operation2")

class ConcreteClass2(AbstractClass):
    def operation1(self):
        print("ConcreteClass2 operation1")

    def operation2(self):
        print("ConcreteClass2 operation2")

concrete_class1 = ConcreteClass1()
concrete_class1.template_method()

concrete_class2 = ConcreteClass2()
concrete_class2.template_method()