Java的23种设计模式

Java 的 23 种设计模式是由《设计模式：可复用面向对象软件的基础》（俗称 “四人组”/GOF）总结的经典设计模式，分为创建型、结构型、行为型三大类，核心目标是提高代码的复用性、可维护性和扩展性。以下是完整分类及核心说明：

一、创建型模式（5 种）

聚焦对象的创建过程，解耦对象创建与使用，隐藏创建细节。

模式名称	核心思想	典型应用场景	示例（伪代码 / 核心类）
单例模式（Singleton）	确保一个类仅有一个实例，并提供全局访问点	配置类、连接池、日志工具	饿汉式 / 懒汉式 / 双重检查锁 / 枚举实现
工厂方法（Factory Method）	定义创建对象的接口，由子类决定实例化哪个类	日志框架（不同日志实现）、数据库驱动	Product + ConcreteProduct + Factory + ConcreteFactory
抽象工厂（Abstract Factory）	提供一个创建一系列相关 / 依赖对象的接口，无需指定具体类	跨平台 UI 组件（Windows/Mac 按钮）	AbstractFactory + 多个产品族的工厂实现
建造者模式（Builder）	将复杂对象的构建与表示分离，逐步构建对象	复杂对象（如 StringBuilder、MyBatis 的 SqlSession）	Builder + Director + Product
原型模式（Prototype）	通过复制已有实例（原型）创建新对象，避免重复初始化	大量相似对象创建（如游戏角色）	实现Cloneable接口，重写clone()方法

单例模式示例（双重检查锁，线程安全）：

java

 

运行

 

 

 

 

public class Singleton {
    private volatile static Singleton instance; // volatile防止指令重排
    private Singleton() {} // 私有构造

    public static Singleton getInstance() {
        if (instance == null) { // 第一次检查
            synchronized (Singleton.class) {
                if (instance == null) { // 第二次检查
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

 

二、结构型模式（7 种）

关注类 / 对象的组合结构，通过组合实现更灵活的功能，提升代码复用。

模式名称	核心思想	典型应用场景	示例（伪代码 / 核心类）
适配器模式（Adapter）	将一个类的接口转换成客户期望的另一个接口，兼容不匹配的接口	JDK 的InputStreamReader（字节流转字符流）、SpringMVC 的 HandlerAdapter	类适配器（继承）/ 对象适配器（组合）
装饰器模式（Decorator）	动态给对象添加职责，不改变原有结构	IO 流（BufferedReader装饰Reader）、Spring 的 TransactionDecorator	Component + ConcreteComponent + Decorator
代理模式（Proxy）	为对象提供代理，控制对原对象的访问（如权限、延迟加载）	远程代理（RPC）、静态 / 动态代理（Spring AOP）	静态代理 / 动态代理（JDK/CGLIB）
外观模式（Facade）	为复杂子系统提供统一入口，简化调用	电商下单（整合库存、支付、物流）、MyBatis 的 SqlSession	封装多个子系统接口，提供统一 Facade 类
桥接模式（Bridge）	将抽象与实现分离，二者可独立变化	图形绘制（形状 + 颜色分离）、JDBC 驱动	Abstraction + Implementor 解耦
组合模式（Composite）	将对象组合成树形结构，统一处理单个对象和组合对象	树形结构（菜单 / 文件系统）、MyBatis 的 SqlNode	Component + Leaf + Composite
享元模式（Flyweight）	复用细粒度对象，减少内存消耗	字符串常量池、池化技术（连接池）	FlyweightFactory 管理共享对象

装饰器模式示例（自定义 IO 装饰）：

java

 

运行

 

 

 

 

// 抽象组件
interface Reader {
    void read();
}
// 具体组件
class FileReader implements Reader {
    @Override
    public void read() { System.out.println("读取文件"); }
}
// 装饰器基类
abstract class ReaderDecorator implements Reader {
    protected Reader reader;
    public ReaderDecorator(Reader reader) { this.reader = reader; }
}
// 具体装饰器（添加缓冲功能）
class BufferedReaderDecorator extends ReaderDecorator {
    public BufferedReaderDecorator(Reader reader) { super(reader); }
    @Override
    public void read() {
        System.out.println("添加缓冲");
        reader.read();
    }
}
// 使用
public class Test {
    public static void main(String[] args) {
        Reader reader = new BufferedReaderDecorator(new FileReader());
        reader.read(); // 输出：添加缓冲 → 读取文件
    }
}

 

三、行为型模式（11 种）

关注对象间的交互与职责分配，优化通信方式，提升代码灵活性。

模式名称	核心思想	典型应用场景	示例（伪代码 / 核心类）
策略模式（Strategy）	定义一系列算法，封装并可互相替换，算法独立于使用方	排序算法切换、支付方式选择	Strategy + ConcreteStrategy + Context
模板方法（Template Method）	定义算法骨架，子类实现具体步骤	Spring 的 JdbcTemplate、HttpServlet	父类定骨架，子类重写hook方法
观察者模式（Observer）	一对多依赖，主题状态变化时通知所有观察者	事件监听（GUI）、Spring 的事件机制	Subject + Observer（JDK 的Observable）
迭代器模式（Iterator）	提供遍历聚合对象的方法，隐藏遍历细节	集合框架（Iterator接口）	Iterator + Iterable
责任链模式（Chain of Responsibility）	请求沿链传递，直到有对象处理	过滤器（Servlet Filter）、日志级别	Handler 链表，每个节点判断是否处理
命令模式（Command）	将请求封装为对象，解耦请求发起与处理	撤销 / 重做、MQ 消息、Spring 的 JmsTemplate	Command + Receiver + Invoker
备忘录模式（Memento）	保存对象状态，可恢复到之前状态	撤销操作（编辑器）、快照	Memento + Originator + Caretaker
状态模式（State）	基于对象状态改变行为，将状态封装为独立类	订单状态（待支付 / 已支付 / 已取消）	State + Context（上下文持有状态）
访问者模式（Visitor）	为对象结构中的元素定义新操作，不修改元素类	数据结构遍历（如 AST 解析）	Visitor + Element + Accept方法
中介者模式（Mediator）	封装对象间交互，减少直接耦合	聊天室、Spring 的 DispatcherServlet	Mediator 统一处理对象通信
解释器模式（Interpreter）	定义语言文法，构建解释器解析语句	表达式解析（如 EL 表达式、正则）	Expression + Context

策略模式示例（支付方式切换）：

java

 

运行

 

 

 

 

// 策略接口
interface PayStrategy {
    void pay(double amount);
}
// 具体策略：支付宝
class AliPay implements PayStrategy {
    @Override
    public void pay(double amount) { System.out.println("支付宝支付" + amount + "元"); }
}
// 具体策略：微信
class WxPay implements PayStrategy {
    @Override
    public void pay(double amount) { System.out.println("微信支付" + amount + "元"); }
}
// 上下文（使用策略）
class Order {
    private PayStrategy strategy;
    public Order(PayStrategy strategy) { this.strategy = strategy; }
    public void pay(double amount) { strategy.pay(amount); }
}
// 使用
public class Test {
    public static void main(String[] args) {
        Order order = new Order(new AliPay());
        order.pay(100); // 支付宝支付100元
        order = new Order(new WxPay());
        order.pay(200); // 微信支付200元
    }
}

 

四、核心设计原则（贯穿所有模式）

设计模式的底层遵循以下原则，理解后可灵活运用：

1. 开闭原则：对扩展开放，对修改关闭；
2. 单一职责：一个类只做一件事；
3. 依赖倒置：依赖抽象，而非具体实现；
4. 里氏替换：子类可替换父类且不改变程序逻辑；
5. 接口隔离：细化接口，避免臃肿；
6. 迪米特法则：最少知道原则，减少对象间耦合；
7. 合成复用：优先使用组合 / 聚合，而非继承。

五、使用建议

1. 不要过度设计：只有当代码存在复用 / 扩展痛点时，才引入设计模式；
2. 优先理解原则，再记模式：模式是原则的具体落地；
3. 结合框架学习：Spring、MyBatis 等框架大量使用设计模式（如 Spring 的单例、AOP 的代理、事务的模板方法）。