当前位置：首页 > article >正文

【面试】【详解】设计模式

article 2025/1/30 13:55:44

一、设计模式详解

（一）设计模式的定义

设计模式 是对软件开发中常见问题的解决方案，是经过实践验证的经验总结。
优点：
- (1) 提高代码复用性。
- (2) 增强代码的可维护性和可扩展性。
- (3) 提供代码的可读性和团队协作能力。

（二）创建型模式

1. 单例模式

定义：保证一个类仅有一个实例，并提供全局访问点。
应用场景：
- (1) 数据库连接池。
- (2) 日志管理。
代码示例（Python）：

class Singleton:
    _instance = None

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

# 测试
singleton1 = Singleton()
singleton2 = Singleton()
print(singleton1 is singleton2)  # 输出 True

2. 工厂方法模式

定义：定义一个创建对象的接口，让子类决定实例化哪个类。
应用场景：
- (1) 产品分类生产。
- (2) 数据解析工具。
代码示例（Python）：

from abc import ABC, abstractmethod

class Product(ABC):
    @abstractmethod
    def use(self):
        pass

class ConcreteProductA(Product):
    def use(self):
        return "Product A is used"

class ConcreteProductB(Product):
    def use(self):
        return "Product B is used"

class Factory:
    @staticmethod
    def create_product(product_type):
        if product_type == 'A':
            return ConcreteProductA()
        elif product_type == 'B':
            return ConcreteProductB()
        else:
            raise ValueError("Unknown product type")

# 测试
product = Factory.create_product('A')
print(product.use())  # 输出 Product A is used

（三）结构型模式

1. 适配器模式

定义：将一个类的接口转换为用户期望的另一个接口。
应用场景：
- (1) 第三方接口的兼容。
- (2) 系统迁移时的新旧模块对接。
代码示例（Python）：

class OldSystem:
    def old_method(self):
        return "Old system method"

class NewSystem:
    def new_method(self):
        return "New system method"

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

    def new_method(self):
        return self.old_system.old_method()

# 测试
old_system = OldSystem()
adapter = Adapter(old_system)
print(adapter.new_method())  # 输出 Old system method

2. 装饰器模式

定义：动态地为对象添加新功能。
应用场景：
- (1) 日志记录。
- (2) 数据校验。
代码示例（Python）：

def logger(func):
    def wrapper(*args, **kwargs):
        print(f"Function {func.__name__} is called with {args} and {kwargs}")
        return func(*args, **kwargs)
    return wrapper

@logger
def add(a, b):
    return a + b

# 测试
result = add(3, 5)  # 输出 Function add is called with (3, 5) and {}
print(result)       # 输出 8

（四）行为型模式

1. 观察者模式

定义：定义对象间的一对多依赖关系，使得一个对象状态改变时，所有依赖它的对象都得到通知。
应用场景：
- (1) 事件系统。
- (2) 消息广播。
代码示例（Python）：

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):
        raise NotImplementedError

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

# 测试
subject = Subject()
observer1 = ConcreteObserver()
observer2 = ConcreteObserver()
subject.attach(observer1)
subject.attach(observer2)
subject.notify("Hello Observers!")
# 输出 Observer received: Hello Observers!（两次）

2. 策略模式

定义：定义一系列算法，将每个算法封装起来，使它们可以互换。
应用场景：
- (1) 不同支付方式的选择。
- (2) 日志策略切换。
代码示例（Python）：

class PaymentStrategy:
    def pay(self, amount):
        raise NotImplementedError

class CreditCardPayment(PaymentStrategy):
    def pay(self, amount):
        print(f"Paid {amount} using Credit Card")

class PayPalPayment(PaymentStrategy):
    def pay(self, amount):
        print(f"Paid {amount} using PayPal")

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

    def execute_payment(self, amount):
        self.strategy.pay(amount)

# 测试
payment_method = PayPalPayment()
context = Context(payment_method)
context.execute_payment(100)  # 输出 Paid 100 using PayPal