设计模式类型
[python] 设计模式是软件工程中的一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。设计模式可以帮助开发者解决常见的设计问题，提高代码的可维护性和可扩展性。以下是一些常见的设计模式：
创建型模式 (Creational Patterns)
- 单例模式 (Singleton Pattern)：
- 确保一个类只有一个实例，并提供一个全局访问点。
- 工厂方法模式 (Factory Method Pattern)：
- 定义一个用于创建对象的接口，让子类决定实例化哪一个类。
- 抽象工厂模式 (Abstract Factory Pattern)：
- 提供一个接口，用于创建相关或依赖对象的家族，而无需明确指定具体类。
- 生成器模式 (Builder Pattern)：
- 将一个复杂对象的构建过程与其表示分离，使得同样的构建过程可以创建不同的表示。
- 原型模式 (Prototype Pattern)：
- 通过复制现有对象来创建新的对象，避免创建对象时使用繁琐的过程。
结构型模式 (Structural Patterns)
- 适配器模式 (Adapter Pattern)：
- 将一个类的接口转换成客户希望的另一个接口，使得原本由于接口不兼容而不能一起工作的类可以一起工作。
- 装饰器模式 (Decorator Pattern)：
- 动态地给对象添加额外的职责，通过组合而不是继承来扩展对象的功能。
- 代理模式 (Proxy Pattern)：
- 为其他对象提供一种代理以控制对这个对象的访问。
- 桥接模式 (Bridge Pattern)：
- 将抽象部分与实现部分分离，使它们都可以独立变化。
- 外观模式 (Facade Pattern)：
- 为子系统中的一组接口提供一个一致的接口，使得子系统更容易使用。
- 享元模式 (Flyweight Pattern)：
- 运用共享技术有效地支持大量细粒度对象的复用。
行为型模式 (Behavioral Patterns)
- 策略模式 (Strategy Pattern)：
- 定义一系列算法，将每一个算法封装起来，并使它们可以互换。
- 观察者模式 (Observer Pattern)：
- 定义对象间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。
- 命令模式 (Command Pattern)：
- 将请求封装成对象，使得可以用不同的请求、队列或日志参数化对象。
- 责任链模式 (Chain of Responsibility Pattern)：
- 为请求创建一个接收对象的链，每个对象依次检查并处理请求，直到某个对象处理它为止。
- 模板方法模式 (Template Method Pattern)：
- 定义一个操作中的算法骨架，而将一些步骤延迟到子类中，使得子类可以不改变算法结构的情况下重定义算法的某些步骤。
- 状态模式 (State Pattern)：
- 允许一个对象在其内部状态改变时改变其行为，对象看起来好像修改了其类。
- 迭代器模式 (Iterator Pattern)：
- 提供一种方法顺序访问一个聚合对象中的各个元素，而不暴露其内部表示。
- 中介者模式 (Mediator Pattern)：
- 用一个中介对象来封装一系列对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散。
- 备忘录模式 (Memento Pattern)：
- 在不破坏封装性的前提下，捕获并保存对象的内部状态，以便可以在以后将对象恢复到原先的状态。
这些设计模式可以组合使用，根据具体的应用场景选择合适的设计模式是提升代码质量的重要技巧。
创建型模式 (Creational Patterns)
-
单例模式 (Singleton Pattern)：
- 使用场景：日志记录器、数据库连接池、配置管理器等需要保证全局只有一个实例的场景。
class Singleton: _instance = None def __new__(cls): if cls._instance is None: cls._instance = super().__new__(cls) return cls._instance -
工厂方法模式 (Factory Method Pattern)：
- 使用场景：需要创建对象的具体类在编译时未知，或者需要在运行时决定使用哪个类的实例时。
class Animal: def speak(self): pass class Dog(Animal): def speak(self): return "Woof!" class Cat(Animal): def speak(self): return "Meow!" class AnimalFactory: @staticmethod def create_animal(animal_type): if animal_type == "Dog": return Dog() elif animal_type == "Cat": return Cat() return None -
抽象工厂模式 (Abstract Factory Pattern)：
- 使用场景：需要创建一系列相关或依赖的对象时，且无需指定具体类。
class Chair: def sit(self): pass class ModernChair(Chair): def sit(self): return "Sitting on a modern chair." class VictorianChair(Chair): def sit(self): return "Sitting on a Victorian chair." class FurnitureFactory: def create_chair(self): pass class ModernFurnitureFactory(FurnitureFactory): def create_chair(self): return ModernChair() class VictorianFurnitureFactory(FurnitureFactory): def create_chair(self): return VictorianChair() -
生成器模式 (Builder Pattern)：
- 使用场景：需要构建复杂对象，且构建过程需要多个步骤时。
class House: def __init__(self): self.wall = None self.roof = None class HouseBuilder: def __init__(self): self.house = House() def build_wall(self, wall_type): self.house.wall = wall_type return self def build_roof(self, roof_type): self.house.roof = roof_type return self def get_house(self): return self.house -
原型模式 (Prototype Pattern)：
- 使用场景：需要创建对象的副本，且成本较高时。
import copy class Prototype: def clone(self): return copy.deepcopy(self)
结构型模式 (Structural Patterns)
-
适配器模式 (Adapter Pattern)：
- 使用场景：需要将一个类的接口转换成另一个接口，以兼容不同接口的类。
class EuropeanPlug: def connect_european_socket(self): return "Connected to European socket." class Adapter: def __init__(self, plug): self.plug = plug def connect_american_socket(self): return self.plug.connect_european_socket() -
装饰器模式 (Decorator Pattern)：
- 使用场景：需要动态地给对象添加职责，且不改变对象的接口。
class Coffee: def cost(self): return 5 class MilkDecorator: def __init__(self, coffee): self._coffee = coffee def cost(self): return self._coffee.cost() + 2 -
代理模式 (Proxy Pattern)：
- 使用场景：需要控制对某对象的访问，可能是延迟加载、访问控制、日志记录等。
class RealSubject: def request(self): return "Real request." class Proxy: def __init__(self): self._real_subject = RealSubject() def request(self): return self._real_subject.request() -
桥接模式 (Bridge Pattern)：
- 使用场景：需要将抽象部分与实现部分分离，使它们可以独立变化。
class Device: def operation(self): pass class RemoteControl: def __init__(self, device): self._device = device def operate(self): return self._device.operation() -
外观模式 (Facade Pattern)：
- 使用场景：需要为复杂的子系统提供一个简化的接口。
class SubsystemA: def operation_a(self): return "Operation A" class SubsystemB: def operation_b(self): return "Operation B" class Facade: def __init__(self): self._subsystem_a = SubsystemA() self._subsystem_b = SubsystemB() def operation(self): return f"{self._subsystem_a.operation_a()} and {self._subsystem_b.operation_b()}" -
享元模式 (Flyweight Pattern)：
- 使用场景：需要大量细粒度对象，且这些对象的大部分状态可以共享时。
class Flyweight: def __init__(self, shared_state): self.shared_state = shared_state class FlyweightFactory: def __init__(self): self._flyweights = {} def get_flyweight(self, key): if key not in self._flyweights: self._flyweights[key] = Flyweight(key) return self._flyweights[key]
行为型模式 (Behavioral Patterns)
-
策略模式 (Strategy Pattern)：
- 使用场景：需要在运行时选择算法的场景，例如排序算法的选择。
class Strategy: def execute(self, data): pass class ConcreteStrategyA(Strategy): def execute(self, data): return sorted(data) class ConcreteStrategyB(Strategy): def execute(self, data): return sorted(data, reverse=True) class Context: def __init__(self, strategy): self._strategy = strategy def execute_strategy(self, data): return self._strategy.execute(data) -
观察者模式 (Observer Pattern)：
- 使用场景：一个对象的状态变化需要通知其他对象时，例如事件处理系统。
class Observer: def update(self, state): pass class ConcreteObserver(Observer): def update(self, state): print(f"State updated to {state}") class Subject: def __init__(self): self._observers = [] def attach(self, observer): self._observers.append(observer) def notify(self, state): for observer in self._observers: observer.update(state) -
命令模式 (Command Pattern)：
- 使用场景：需要将请求封装成对象以便参数化和记录日志等，例如撤销操作的实现。
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("Action performed.") 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() -
责任链模式 (Chain of Responsibility Pattern)：
- 使用场景：多个对象依次处理请求的场景，例如处理日志记录的不同级别。
class Handler: def set_successor(self, successor): self._successor = successor def handle_request(self, request): pass class ConcreteHandler1(Handler): def handle_request(self, request): if request == 1: print("Handled by Handler 1") elif self._successor: self._successor.handle_request(request) class ConcreteHandler2(Handler): def handle_request(self, request): if request == 2: print("Handled by Handler 2") elif self._successor: self._successor.handle_request(request) -
模板方法模式 (Template Method Pattern)：
- 使用场景：定义一个算法的骨架，将一些步骤延迟到子类实现，例如处理流程的定义。
class AbstractClass: def template_method(self): self.step_one() self.step_two() def step_one(self): pass def step_two(self): pass class ConcreteClass(AbstractClass): def step_one(self): print("Step one implemented.") def step_two(self): print("Step two implemented.") -
状态模式 (State Pattern)：
- 使用场景：一个对象在其内部状态改变时，改变其行为，例如状态
13万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
