Java 设计模式全解析：23 种模式分类与实战代码指南
设计模式是面向对象编程中解决重复问题的成熟方案，Java 作为 OOP 典范语言，其生态对设计模式的落地尤为典型。本文将 23 种经典设计模式按创建型、结构型、行为型分类拆解，通过核心思想提炼与精简代码示例，详解每种模式的适用场景与实现精髓，帮助开发者在实际开发中灵活运用以提升代码质量。
一、创建型模式：对象创建的优化艺术
创建型模式专注于对象创建机制的封装，通过解耦对象创建与使用逻辑，实现系统的灵活扩展。
1. 单例模式（Singleton）
核心思想：确保类仅有一个实例，并提供全局访问点。
适用场景：全局配置、线程池、日志对象等。
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;
}
}
2. 工厂模式（Factory）
核心思想：封装对象创建逻辑，客户端无需关注具体实现。
分类：简单工厂、工厂方法、抽象工厂。
工厂方法示例：
// 产品接口
public interface Shape { void draw(); }
// 具体产品
public class Circle implements Shape {
@Override
public void draw() { System.out.println("绘制圆形"); }
}
// 工厂接口
public interface ShapeFactory { Shape createShape(); }
// 具体工厂
public class CircleFactory implements ShapeFactory {
@Override
public Shape createShape() { return new Circle(); }
}
3. 建造者模式（Builder）
核心思想：分离复杂对象构建与表示，支持分步创建。
适用场景：参数繁多的对象（如配置类、POJO）。
实现示例：
public class Computer {
private String cpu;
private String ram;
private Computer(Builder builder) {
this.cpu = builder.cpu;
this.ram = builder.ram;
}
public static class Builder {
private String cpu;
private String ram;
public Builder cpu(String cpu) {
this.cpu = cpu;
return this;
}
public Builder ram(String ram) {
this.ram = ram;
return this;
}
public Computer build() { return new Computer(this); }
}
}
// 使用：new Computer.Builder().cpu("i7").ram("16GB").build()
二、结构型模式：类与对象的组合策略
结构型模式通过类或对象的灵活组合，优化系统结构以解决接口适配、功能扩展等问题。
1. 代理模式（Proxy）
核心思想：为目标对象提供代理，控制访问权限或增强功能。
应用场景：远程调用、权限控制、缓存。
JDK 动态代理示例：
public interface UserService { void login(String name); }
public class UserServiceImpl implements UserService {
@Override
public void login(String name) { System.out.println(name + "登录"); }
}
// 代理处理器
public class LogProxy implements InvocationHandler {
private Object target;
public LogProxy(Object target) { this.target = target; }
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("调用前日志：" + method.getName());
Object result = method.invoke(target, args);
System.out.println("调用后日志：" + method.getName());
return result;
}
}
2. 装饰器模式（Decorator）
核心思想：动态为对象添加功能，不改变原类结构。
优势：替代继承，避免类爆炸。
实现示例：
// 核心接口
public interface Coffee {
String getDesc();
double cost();
}
// 基础实现
public class SimpleCoffee implements Coffee {
@Override
public String getDesc() { return "纯咖啡"; }
@Override
public double cost() { return 5.0; }
}
// 装饰器抽象类
public abstract class CoffeeDecorator implements Coffee {
protected Coffee coffee;
public CoffeeDecorator(Coffee coffee) { this.coffee = coffee; }
}
// 具体装饰器
public class MilkDecorator extends CoffeeDecorator {
public MilkDecorator(Coffee coffee) { super(coffee); }
@Override
public String getDesc() { return coffee.getDesc() + "+牛奶"; }
@Override
public double cost() { return coffee.cost() + 2.0; }
}
3. 适配器模式（Adapter）
核心思想：转换接口适配客户端需求，解决兼容性问题。
对象适配器示例：
// 目标接口
public interface Target { void request(); }
// 适配者
public class Adaptee {
public void specificRequest() { System.out.println("适配者处理"); }
}
// 适配器
public class Adapter implements Target {
private Adaptee adaptee;
public Adapter(Adaptee adaptee) { this.adaptee = adaptee; }
@Override
public void request() { adaptee.specificRequest(); }
}
三、行为型模式：对象间的交互协调
行为型模式聚焦对象间的通信与职责分配，优化系统行为协作逻辑。
1. 观察者模式（Observer）
核心思想：定义一对多依赖，状态变化时通知所有依赖者。
应用场景：事件监听、消息通知。
实现示例：
import java.util.ArrayList;
import java.util.List;
// 主题接口
public interface Subject {
void register(Observer o);
void remove(Observer o);
void notifyObservers();
}
// 观察者接口
public interface Observer { void update(String msg); }
// 具体主题
public class NewsSubject implements Subject {
private List
private String news;
@Override
public void register(Observer o) { observers.add(o); }
@Override
public void remove(Observer o) { observers.remove(o); }
@Override
public void notifyObservers() {
for (Observer o : observers) o.update(news);
}
public void setNews(String news) {
this.news = news;
notifyObservers();
}
}
2. 策略模式（Strategy）
核心思想：封装算法家族，支持动态切换。
优势：避免多重条件判断。
实现示例：
// 策略接口
public interface Payment { void pay(double amount); }
// 具体策略
public class CreditCardPay implements Payment {
private String cardNo;
public CreditCardPay(String cardNo) { this.cardNo = cardNo; }
@Override
public void pay(double amount) {
System.out.println(amount + "元信用卡支付，卡号：" + cardNo);
}
}
// 策略使用者
public class ShoppingCart {
private Payment payment;
public void setPayment(Payment payment) { this.payment = payment; }
public void checkout(double amount) { payment.pay(amount); }
}
3. 模板方法模式（Template Method）
核心思想：父类定义算法骨架，子类实现具体步骤。
适用场景：流程固定但细节可变（如报表生成）。
实现示例：
// 抽象父类
public abstract class Game {
// 模板方法（不可重写）
public final void play() {
init();
start();
end();
}
protected abstract void init();
protected abstract void start();
// 钩子方法（可选实现）
protected void end() { System.out.println("游戏结束"); }
}
// 具体实现
public class Football extends Game {
@Override
protected void init() { System.out.println("足球游戏初始化"); }
@Override
protected void start() { System.out.println("足球游戏开始"); }
}
四、其他常用模式速览
模式类型
模式名称
核心用途
创建型
原型模式
通过复制创建对象，避免重复初始化
创建型
抽象工厂模式
创建相关联的对象家族
结构型
桥接模式
分离抽象与实现，两者独立扩展
结构型
组合模式
统一处理单个对象与对象集合
结构型
享元模式
共享细粒度对象，减少内存占用
结构型
外观模式
为复杂系统提供统一访问接口
行为型
迭代器模式
遍历集合对象，封装遍历逻辑
行为型
命令模式
将请求封装为对象，支持撤销 / 重做
行为型
责任链模式
多对象轮流处理请求，解耦发送者与接收者
行为型
备忘录模式
保存对象状态，支持恢复
五、模式选择与应用原则
1. 核心选择依据
需控制对象创建：单例（唯一实例）、工厂（复杂创建）、建造者（分步构建）；
需优化结构组合：装饰器（功能扩展）、适配器（接口适配）、代理（访问控制）；
需协调对象行为：观察者（状态通知）、策略（算法切换）、模板方法（流程固定）。
2. 设计原则适配
开闭原则：策略模式（扩展新策略不改旧代码）、装饰器模式（新增装饰不影响核心）；
依赖倒置：工厂模式（依赖接口而非实现）、观察者模式（主题依赖抽象观察者）；
里氏替换：模板方法模式（子类可替换父类参与流程）。
六、总结
Java 设计模式的 23 种模式本质是 “问题 - 解决方案” 的映射集合，三大分类各有侧重：创建型解决对象创建的灵活性问题，结构型解决系统结构的扩展性问题，行为型解决对象交互的协调性问题。
实际应用中需避免 “为模式而模式”，关键在于：
理解模式解决的核心痛点，而非死记代码结构；
结合业务场景组合模式（如工厂 + 策略、装饰器 + 代理）；
优先保持代码简洁，复杂模式仅用于解决对应复杂问题。
设计模式是前人的经验沉淀，但其价值在于启发设计思维。随着 Java 语言发展（如 Records、Sealed Classes），部分模式的实现得以简化，但 “解耦、复用、可扩展” 的核心设计思想始终是高质量代码的基石。