五大经典设计模式深度解析与实践

设计模式是软件开发中解决常见问题的最佳实践总结。本文将深入探讨单例模式、工厂模式、观察者模式、装饰器模式和策略模式，分析其核心原理、实现方式及应用场景，并通过代码示例和表格对比帮助理解。

一、单例模式（Singleton Pattern）

1. 定义与核心思想

• 定义：确保一个类仅有一个实例，并提供全局访问点。
• 核心目标：控制实例数量，节约资源，适用于需要全局共享的场景（如数据库连接池、配置中心）。

2. 实现方式

• 懒汉模式：延迟加载，首次使用时创建实例。
• 饿汉模式：类加载时即创建实例，线程安全但可能浪费资源。
• 双重检查锁定：结合懒汉模式和锁机制，保证多线程下的单例安全。

3. 优缺点

4. 代码示例（Java懒汉式）

public class Singleton {
    private static volatile Singleton instance;
    private Singleton() {}
    
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

二、工厂模式（Factory Pattern）

1. 定义与分类

• 定义：将对象创建与使用解耦，通过工厂类统一管理实例化过程。
• 分类：
  • 简单工厂：一个工厂类根据参数生成不同对象（违反开闭原则）。
  • 工厂方法：子类决定实例化对象（符合开闭原则）。
  • 抽象工厂：生产多个产品族（如不同操作系统的UI组件）。

2. 核心角色

• 抽象工厂：定义创建对象的接口。
• 具体工厂：实现工厂接口，生产具体产品。
• 产品：被创建的对象，通常为接口或抽象类。

3. 优缺点

4. 代码示例（简单工厂模式）

// 产品接口
interface Product {
    void use();
}

// 具体产品
class ConcreteProductA implements Product {
    public void use() { System.out.println("Product A in use"); }
}

// 简单工厂
class SimpleFactory {
    public static Product create(String type) {
        switch (type) {
            case "A": return new ConcreteProductA();
            default: throw new IllegalArgumentException();
        }
    }
}

三、观察者模式（Observer Pattern）

1. 定义与核心思想

• 定义：定义对象间一对多的依赖关系，当主体（Subject）状态变化时，所有观察者（Observer）自动更新。
• 别名：发布-订阅模式，常用于事件处理系统（如GUI、消息中间件）。

2. 角色与流程

• Subject（主题）：维护观察者列表，提供register/remove/notify方法。
• Observer（观察者）：实现更新接口，响应主题通知。
• 流程：注册→状态变更→通知→更新。

3. 优缺点

4. 代码示例（Java实现）

// 主题接口
interface Subject {
    void registerObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers();
}

// 具体主题
class ConcreteSubject implements Subject {
    private List<Observer> observers = new ArrayList<>();
    private int state;
    
    public void setState(int state) {
        this.state = state;
        notifyObservers();
    }
    
    @Override
    public void registerObserver(Observer observer) {
        observers.add(observer);
    }
    
    @Override
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update();
        }
    }
}

四、装饰器模式（Decorator Pattern）

1. 定义与核心思想

• 定义：动态扩展对象功能，不影响其他对象，支持功能叠加。
• 核心：通过组合而非继承实现功能增强，保持接口一致性。

2. 角色与结构

• Component：基础接口，所有对象（被装饰者与装饰器）需实现。
• ConcreteComponent：初始对象，提供基础功能。
• Decorator：持有Component引用，实现相同接口，扩展功能。
• ConcreteDecorator：具体装饰器，添加新行为（如加牛奶、加糖）。

3. 优缺点

4. 代码示例（Python咖啡订单）

# 组件接口
class Coffee(ABC):
    @abstractmethod
    def cost(self): pass
    @abstractmethod
    def description(self): pass

# 具体组件
class SimpleCoffee(Coffee):
    def cost(self): return 10
    def description(self): return "基础咖啡"

# 装饰器基类
class CoffeeDecorator(Coffee):
    def __init__(self, coffee): self.coffee = coffee
    def cost(self): return self.coffee.cost()
    def description(self): return self.coffee.description()

# 具体装饰器：加牛奶
class MilkDecorator(CoffeeDecorator):
    def cost(self): return super().cost() + 3
    def description(self): return super().description() + " + 牛奶"

五、策略模式（Strategy Pattern）

1. 定义与核心思想

• 定义：定义一组可互换的算法，封装后使算法可独立于使用它的客户变化。
• 核心：将行为抽象为策略接口，运行时动态切换算法。

2. 角色与结构

• Strategy（策略接口）：定义算法接口。
• ConcreteStrategy（具体策略）：实现具体算法（如美国税法、中国税法）。
• Context（上下文）：持有策略引用，提供客户端调用。

3. 优缺点

4. 代码示例（Python计算策略）

# 策略接口
class Strategy(ABC):
    @abstractmethod
    def execute(self, a, b): pass

# 具体策略：加法
class AddStrategy(Strategy):
    def execute(self, a, b): return a + b

# 上下文类
class Context:
    def __init__(self, strategy: Strategy):
        self.strategy = strategy
    def set_strategy(self, strategy: Strategy):
        self.strategy = strategy
    def execute_strategy(self, a, b):
        return self.strategy.execute(a, b)

六、模式对比与选型建议

1. 关键特征对比表

2. 选型建议

• 需要唯一实例 → 单例模式。
• 隔离对象创建 → 工厂模式（优先工厂方法）。
• 事件驱动系统 → 观察者模式。
• 功能动态扩展 → 装饰器模式。
• 多算法可选 → 策略模式。

结语

五大设计模式各有侧重，实际应用中需根据需求组合使用。例如，工厂模式可创建策略对象，观察者模式可监听策略变更，装饰器可增强策略行为。掌握这些模式的核心思想与实现技巧，能显著提升代码的灵活性和可维护性。