软件开发基础-设计模式
设计模式在软件开发中非常重要，尤其是在面试中经常被问到。以下是一些常见的设计模式，以及它们的应用案例：
| 模式 | 作用 | 案例 |
|---|---|---|
| 单例模式 | 确保只有一个实例 | 日志管理、数据库连接池 |
| 工厂模式 | 让子类决定实例化 | 解析不同格式的文件（JSON、XML） |
| 适配器模式 | 兼容不同接口 | 旧系统迁移、新 API 适配 |
| 代理模式 | 控制访问 | 权限控制、远程调用 |
| 观察者模式 | 事件触发 | 订阅/发布、GUI 事件 |
| 策略模式 | 动态切换算法 | 支付方式、游戏 AI |
1. 创建型模式（Creational Patterns）
1.1 单例模式（Singleton）
作用：保证某个类只有一个实例，并提供一个全局访问点。
适用场景
- 资源管理（如数据库连接池、线程池）
- 配置管理（如日志记录、全局配置）
class Singleton:
_instance = None
def __new__(cls, *args, **kwargs):
if cls._instance is None:
cls._instance = super().__new__(cls)
return cls._instance
# 测试
obj1 = Singleton()
obj2 = Singleton()
print(obj1 is obj2) # True，两个对象是同一个
1.2 工厂模式（Factory Method）
作用：定义一个接口，让子类决定实例化哪一个类，解耦对象创建过程。
适用场景
- 需要根据不同的条件创建不同类型的对象（如不同类型的数据库连接）
- 避免直接使用
new，提高扩展性
class Animal:
def speak(self):
pass
class Dog(Animal):
def speak(self):
return "汪汪！"
class Cat(Animal):
def speak(self):
return "喵喵！"
class AnimalFactory:
@staticmethod
def get_animal(animal_type):
if animal_type == "dog":
return Dog()
elif animal_type == "cat":
return Cat()
else:
raise ValueError("未知动物类型")
# 测试
animal = AnimalFactory.get_animal("dog")
print(animal.speak()) # "汪汪！"
1.3 原型模式（Prototype）
作用：通过克隆（复制）已有对象来创建新对象，减少 new 操作的开销。
适用场景
- 需要大量创建相似对象（如游戏角色、文档模板）
- 对象创建成本高（如大对象的初始化）
import copy
class Prototype:
def clone(self):
return copy.deepcopy(self)
class Car(Prototype):
def __init__(self, brand, model):
self.brand = brand
self.model = model
# 复制对象
car1 = Car("Tesla", "Model S")
car2 = car1.clone()
print(car1 is car2) # False，不是同一个对象
print(car2.brand) # "Tesla"
2. 结构型模式（Structural Patterns）
2.1 适配器模式（Adapter）
作用：把一个类的接口转换成另一个接口，让不兼容的类可以一起工作。
适用场景
- 需要使用第三方库，但其接口不符合当前项目
- 让老代码适配新系统
class OldSystem: def old_method(self): return "老系统方法" class Adapter: def __init__(self, old_system): self.old_system = old_system def new_method(self): return self.old_system.old_method() # 适配 old_sys = OldSystem() adapter = Adapter(old_sys) print(adapter.new_method()) # "老系统方法"2.2 代理模式（Proxy）
作用：控制对象的访问，在访问目标对象前后进行额外操作（如权限控制、缓存）。
适用场景
- 权限控制（如身份认证）
- 缓存代理（减少数据库访问）
- 远程代理（如 RPC 调用）
-
class RealObject: def request(self): return "真实对象的请求" class Proxy: def __init__(self): self.real_object = RealObject() def request(self): print("代理：检查权限...") return self.real_object.request() # 使用代理 proxy = Proxy() print(proxy.request()) # "代理：检查权限... 真实对象的请求"3. 行为型模式（Behavioral Patterns）
3.1 观察者模式（Observer）
作用：当一个对象的状态发生变化，所有依赖它的对象都会收到通知。
适用场景
- 事件驱动（如 GUI 按钮点击）
- 消息推送（如微博、微信公众号）
class Observer:
def update(self, message):
pass
class User(Observer):
def __init__(self, name):
self.name = name
def update(self, message):
print(f"{self.name} 收到消息: {message}")
class Subject:
def __init__(self):
self.observers = []
def add_observer(self, observer):
self.observers.append(observer)
def notify(self, message):
for observer in self.observers:
observer.update(message)
# 测试
subject = Subject()
user1 = User("Alice")
user2 = User("Bob")
subject.add_observer(user1)
subject.add_observer(user2)
subject.notify("Python 设计模式更新！")
3.2 策略模式（Strategy）
作用：定义一系列策略（算法），并且可以动态切换。
适用场景
- 支付方式选择（微信、支付宝、信用卡）
- 游戏 AI（不同策略应对不同情况）
class PaymentStrategy:
def pay(self, amount):
pass
class Alipay(PaymentStrategy):
def pay(self, amount):
return f"使用支付宝支付 {amount} 元"
class WeChatPay(PaymentStrategy):
def pay(self, amount):
return f"使用微信支付 {amount} 元"
class PaymentContext:
def __init__(self, strategy):
self.strategy = strategy
def execute_payment(self, amount):
return self.strategy.pay(amount)
# 选择支付方式
context = PaymentContext(WeChatPay())
print(context.execute_payment(100)) # "使用微信支付 100 元"
总结
| 模式 | 作用 | 案例 |
|---|---|---|
| 单例模式 | 确保只有一个实例 | 日志管理、数据库连接池 |
| 工厂模式 | 让子类决定实例化 | 解析不同格式的文件（JSON、XML） |
| 适配器模式 | 兼容不同接口 | 旧系统迁移、新 API 适配 |
| 代理模式 | 控制访问 | 权限控制、远程调用 |
| 观察者模式 | 事件触发 | 订阅/发布、GUI 事件 |
| 策略模式 | 动态切换算法 | 支付方式、游戏 AI |
面试技巧
- 了解不同模式的应用场景。
- 能用真实案例解释（如支付系统、消息推送）。
- 面试中尽量用 Python 代码举例，增强说服力。