GoF设计模式 - 三大类设计模式

GoF设计模式

• 创建型模式：单例、工厂、建造者、原型
• 结构型模式：适配器、门面（外观）、代理
• 行为型模式：迭代器、观察者、状态、策略

设计模式是软件开发中的一种标准解决方案，用于解决在不同情境中反复出现的设计问题。GoF（Gang of Four）设计模式是由四位作者（Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides）在他们的著作《设计模式：可复用面向对象软件的基础》中提出的23种经典设计模式。这些模式分为三大类：创建型模式、结构型模式和行为型模式。以下是每种模式的详细介绍和示例。

1. 创建型模式

1.1 单例模式 (Singleton)

定义：确保一个类只有一个实例，并提供一个全局访问点。

例子：数据库连接池、配置管理器。

class Singleton:
    _instance = None

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

# 使用单例
singleton1 = Singleton()
singleton2 = Singleton()
print(singleton1 is singleton2)  # 输出: True

1.2 工厂模式 (Factory)

定义：定义一个创建对象的接口，但让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

例子：日志记录器可以根据不同的配置文件选择不同的日志记录方式（文件、控制台、远程服务器等）。

class ShapeFactory:
    def get_shape(self, shape_type):
        if shape_type == "Circle":
            return Circle()
        elif shape_type == "Square":
            return Square()
        else:
            return None

class Circle:
    def draw(self):
        print("Drawing a Circle")

class Square:
    def draw(self):
        print("Drawing a Square")

# 使用工厂
factory = ShapeFactory()
shape = factory.get_shape("Circle")
shape.draw()  # 输出: Drawing a Circle

1.3 建造者模式 (Builder)

定义：将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。

例子：构建不同类型的文档（HTML、PDF）或生成器。

class Computer:
    def __init__(self):
        self.cpu = None
        self.ram = None
        self.storage = None

    def __str__(self):
        return f"CPU: {self.cpu}, RAM: {self.ram}, Storage: {self.storage}"

class ComputerBuilder:
    def __init__(self):
        self.computer = Computer()

    def set_cpu(self, cpu):
        self.computer.cpu = cpu

    def set_ram(self, ram):
        self.computer.ram = ram

    def set_storage(self, storage):
        self.computer.storage = storage

    def get_result(self):
        return self.computer

# 使用建造者模式
builder = ComputerBuilder()
builder.set_cpu("Intel i9")
builder.set_ram("32GB")
builder.set_storage("1TB SSD")
computer = builder.get_result()
print(computer)  # 输出: CPU: Intel i9, RAM: 32GB, Storage: 1TB SSD

1.4 原型模式 (Prototype)

定义：用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。

例子：在需要重复创建相似对象时使用，例如游戏开发中的对象克隆。

import copy

class Prototype:
    def __init__(self):
        self.objects = {}

    def register_object(self, name, obj):
        self.objects[name] = obj

    def clone(self, name):
        obj = self.objects.get(name)
        return copy.deepcopy(obj)

# 使用原型模式
class Car:
    def __init__(self, model, color):
        self.model = model
        self.color = color

car = Car("Sedan", "Red")
prototype = Prototype()
prototype.register_object("car1", car)

car_clone = prototype.clone("car1")
print(car_clone.model, car_clone.color)  # 输出: Sedan Red

2. 结构型模式

2.1 适配器模式 (Adapter)

定义：将一个类的接口转换成客户希望的另一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的类可以一起工作。

例子：电源适配器可以将110V转换为220V。

class EuropeanSocket:
    def voltage(self):
        return 230

    def live(self):
        return True

    def neutral(self):
        return True

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

    def voltage(self):
        return 110

    def live(self):
        return self.socket.live()

    def neutral(self):
        return self.socket.neutral()

# 使用适配器
european_socket = EuropeanSocket()
adapter = Adapter(european_socket)
print(adapter.voltage())  # 输出: 110

2.2 门面模式（外观模式） (Facade)

定义：为子系统中的一组接口提供一个一致的接口，外观模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。

例子：操作复杂的子系统时提供简化的接口，比如图形库的简化操作接口。

class CPU:
    def freeze(self):
        print("Freezing CPU")

    def jump(self, position):
        print(f"Jumping to {position}")

    def execute(self):
        print("Executing")

class Memory:
    def load(self, position, data):
        print(f"Loading {data} into position {position}")

class HardDrive:
    def read(self, lba, size):
        return f"Reading {size} bytes from LBA {lba}"

class ComputerFacade:
    def __init__(self):
        self.cpu = CPU()
        self.memory = Memory()
        self.hard_drive = HardDrive()

    def start(self):
        self.cpu.freeze()
        self.memory.load(0, self.hard_drive.read(1024, 4096))
        self.cpu.jump(0)
        self.cpu.execute()

# 使用门面模式
computer = ComputerFacade()
computer.start()

2.3 代理模式 (Proxy)

定义：为其他对象提供一种代理以控制对这个对象的访问。

例子：远程代理控制对远程对象的访问，虚拟代理控制访问创建开销大的对象。

class RealSubject:
    def request(self):
        print("RealSubject: Handling request")

class Proxy:
    def __init__(self, real_subject):
        self.real_subject = real_subject

    def request(self):
        print("Proxy: Logging access")
        self.real_subject.request()

# 使用代理模式
real_subject = RealSubject()
proxy = Proxy(real_subject)
proxy.request()

3. 行为型模式

3.1 迭代器模式 (Iterator)

定义：提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露该对象的内部表示。

例子：可以用于遍历集合、列表、队列等数据结构。

class MyCollection:
    def __init__(self):
        self.items = []
        self.index = 0

    def add(self, item):
        self.items.append(item)

    def __iter__(self):
        return self

    def __next__(self):
        if self.index < len(self.items):
            item = self.items[self.index]
            self.index += 1
            return item
        else:
            raise StopIteration

# 使用迭代器模式
collection = MyCollection()
collection.add(1)
collection.add(2)
collection.add(3)

for item in collection:
    print(item)  # 输出: 1 2 3

3.2 观察者模式 (Observer)

定义：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

例子：GUI框架中，视图观察模型对象的变化。

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

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

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

    def notify(self, message):
        for observer in self.observers:
            observer.update(message)

class Observer:
    def update(self, message):
        pass

class ConcreteObserver(Observer):
    def update(self, message):
        print(f"Received message: {message}")

# 使用观察者模式
subject = Subject()
observer1 = ConcreteObserver()
observer2 = ConcreteObserver()

subject.attach(observer1)
subject.attach(observer2)

subject.notify("Hello, Observers!")  # 输出: Received message: Hello, Observers!
                                    #      Received message: Hello, Observers!

3.3 状态模式 (State)

定义：允许对象在内部状态改变时改变它的行为，对象看起来好像修改了它的类。

例子：电梯状态（上下、静止），每个状态会有不同的行为。

class Context:
    def __init__(self, state):
        self._state = state

    def set_state(self, state):
        self._state = state

    def request(self):
        self._state.handle()

class State:
    def handle(self):
        pass

class ConcreteStateA(State):
    def handle(self):
        print("Handling request in State A")

class ConcreteStateB(State):
    def handle(self):
        print("Handling request in State B")

# 使用状态模式
state_a = ConcreteStateA()
state_b = ConcreteStateB()

context = Context(state_a)
context.request()  # 输出: Handling request in State A

context.set_state(state_b)
context.request()  # 输出: Handling request in State B

3.4 策略模式 (Strategy)

定义：定义一系列算法，把它们一个个封装起来，并且使它们可以相互替换。策略模式使得算法可以在不影响客户端的情况下发生变化。

例子：可插拔的哈希算法，不同的策略实现不同的哈希算法。

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

    def execute_strategy(self, data):
        return self._strategy.do_algorithm(data)

class Strategy:
    def do_algorithm(self, data):
        pass

class ConcreteStrategyA(Strategy):
    def do_algorithm(self, data):
        return sorted(data)

class ConcreteStrategyB(Strategy):
    def do_algorithm(self, data):
        return sorted(data, reverse=True)

# 使用策略模式
data = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3]

context = Context(ConcreteStrategyA())
print(context.execute_strategy(data))  # 输出: [1, 1, 2, 3, 3, 4, 5, 5, 6, 9]

context = Context(ConcreteStrategyB())
print(context.execute_strategy(data))  # 输出: [9, 6, 5, 5, 4, 3, 3, 2, 1, 1]

在这些例子中，设计模式的使用展示了如何组织代码以实现更好的可扩展性、可维护性和灵活性。设计模式帮助开发者更好地理解和应用面向对象设计的原则，从而创建更健壮的应用程序。