设计模式简介

likuoelie

853人浏览 · 2025-08-10 11:14:15

likuoelie · 2025-08-10 11:14:15 发布

设计模式（Design Patterns）是软件工程中一种重要的概念，它提供了一种可重用的解决方案，用于解决软件设计中常见的、重复出现的问题。这些模式不是现成的代码，而是描述问题及其解决方案的模板，帮助开发者在面向对象编程（OOP）中构建更灵活、可维护和可扩展的系统。设计模式最早由“四人帮”（Gang of Four，GoF）在1994年的书籍《设计模式：可复用面向对象软件的基础》中提出，包含23种经典模式。

下面，我将用中文详细讲解设计模式的定义、分类、示例、好处以及注意事项。讲解以简单易懂的方式进行，适合初学者。

1. 什么是设计模式？

设计模式是一种经验总结，它描述了在特定上下文中解决问题的最佳实践。简单来说：

问题：软件开发中常见的挑战，如对象创建、结构组织或行为协作。
解决方案：一个通用的模板，包括类、接口、关系和责任分配。
特点：
- 可重用：模式可以应用于不同项目。
- 抽象：不是具体代码，而是指导原则。
- 面向对象：主要基于封装、继承、多态和组合等OOP原则。
为什么需要设计模式？ 它能提高代码的可读性、可维护性和扩展性，避免“意大利面式”代码（纠缠不清的代码）。

设计模式不是万能的，它强调“在合适的地方使用”，过度使用可能导致代码复杂化。

2. 设计模式的分类

GoF将23种设计模式分为三大类：创建型（Creational）、结构型（Structural） 和 行为型（Behavioral）。每类针对不同的问题。

使用表格总结分类，便于理解：

分类	描述	常见模式示例
创建型模式	关注对象的创建过程，提供灵活的创建机制，避免直接使用`new`关键字导致的紧耦合。	单例模式（Singleton）、工厂方法模式（Factory Method）、抽象工厂模式（Abstract Factory）、建造者模式（Builder）、原型模式（Prototype）。
结构型模式	关注类和对象的组合，形成更大的结构，如继承或组合关系。	适配器模式（Adapter）、装饰器模式（Decorator）、代理模式（Proxy）、外观模式（Facade）、桥接模式（Bridge）、组合模式（Composite）、享元模式（Flyweight）。
行为型模式	关注对象间的通信和责任分配，处理算法和行为。	策略模式（Strategy）、观察者模式（Observer）、命令模式（Command）、责任链模式（Chain of Responsibility）、状态模式（State）、访问者模式（Visitor）、解释器模式（Interpreter）、迭代器模式（Iterator）、中介者模式（Mediator）、备忘录模式（Memento）、模板方法模式（Template Method）。

总数：5种创建型 + 7种结构型 + 11种行为型 = 23种。
扩展：除了GoF模式，还有其他模式如MVC（Model-View-Controller）、依赖注入（Dependency Injection）等，在现代框架（如Spring）中广泛使用。

3. 常见设计模式示例

以下挑选三种经典模式进行详细讲解，包括问题、解决方案和Java代码示例（因为设计模式常用Java说明）。

(1) 单例模式（Singleton） - 创建型

问题：确保一个类只有一个实例（如数据库连接池），并提供全局访问点。
解决方案：私有构造器 + 静态方法返回唯一实例。

代码示例（懒汉式，线程安全）：

public class Singleton {
    private static volatile Singleton instance; // volatile确保可见性
    private Singleton() {} // 私有构造器

    public static Singleton getInstance() {
        if (instance == null) { // 双重检查锁定
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

使用：Singleton s = Singleton.getInstance();。
优点：节省资源，避免多次创建。

(2) 观察者模式（Observer） - 行为型

问题：当一个对象状态变化时，需要通知多个依赖对象（如天气变化通知APP）。
解决方案：定义一对多依赖，主题（Subject）维护观察者列表，状态变化时广播通知。

代码示例：

import java.util.ArrayList;
import java.util.List;

// 观察者接口
interface Observer {
    void update(String message);
}

// 主题类
class Subject {
    private List<Observer> observers = new ArrayList<>();
    public void addObserver(Observer o) { observers.add(o); }
    public void removeObserver(Observer o) { observers.remove(o); }
    public void notifyObservers(String message) {
        for (Observer o : observers) {
            o.update(message);
        }
    }
}

// 具体观察者
class ConcreteObserver implements Observer {
    @Override
    public void update(String message) {
        System.out.println("收到通知：" + message);
    }
}

// 测试
public class Test {
    public static void main(String[] args) {
        Subject subject = new Subject();
        Observer obs = new ConcreteObserver();
        subject.addObserver(obs);
        subject.notifyObservers("状态变化了！");
    }
}

输出：收到通知：状态变化了！。
优点：解耦主题和观察者，支持动态添加/移除。

(3) 工厂方法模式（Factory Method） - 创建型

问题：创建对象时不指定具体类，而是由子类决定（如不同类型的按钮工厂）。
解决方案：定义一个创建接口，子类实现具体创建。

代码示例：

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

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

// 工厂接口
interface Factory {
    Product createProduct();
}

// 具体工厂
class ConcreteFactoryA implements Factory {
    @Override
    public Product createProduct() { return new ConcreteProductA(); }
}

// 测试
public class Test {
    public static void main(String[] args) {
        Factory factory = new ConcreteFactoryA();
        Product p = factory.createProduct();
        p.show(); // 输出：产品A
    }
}