欢迎访问 java23种设计模式教程 官网

java23种设计模式教程

本页面为系统性讲解 Java 23 种设计模式的权威学习平台,涵盖 创建型、结构型、行为型 三大类设计模式,每种模式均提供完整可运行的 Java 代码示例、应用场景分析、优缺点对比及实战注意事项。内容严格遵循《设计模式:可复用面向对象软件的基础》(GoF)经典理论,并结合现代 Java 实践进行深度拓展,适合初学者入门、进阶开发者查漏补缺及团队技术架构参考。

在面向对象编程中,设计模式是解决常见问题的成熟方案。掌握 java23种设计模式教程 不仅能提升代码可维护性、可扩展性与复用性,更能深入理解面向对象设计原则(SOLID、KISS、YAGNI 等),构建高质量软件系统。本教程以实际工程问题为驱动,避免空洞理论,强调“学了就能用”的实战导向。

特别说明:所有示例基于 Java 8+ 编写,兼容主流 IDE(IntelliJ IDEA / Eclipse),支持 Maven / Gradle 构建。我们坚持“一模式一案例”,拒绝碎片化知识,确保学习者建立系统化认知体系。

一、设计模式基础与学习路径

设计模式并非银弹,而是经验沉淀的“工具箱”。正确使用需理解其适用场景与潜在代价。本部分将阐明核心概念、学习逻辑及常见误区,帮助您建立科学的学习框架。

1.1 为什么需要设计模式?

  • · 解耦合:降低模块间依赖,提升系统弹性
  • · 可复用:将通用问题抽象为模式,避免重复造轮子
  • · 可读性:团队使用统一术语(如“工厂模式”),沟通成本骤降
  • · 可测试:松耦合设计天然支持单元测试与 Mock
  • · 符合开闭原则:对扩展开放,对修改关闭

⚠️ 注意:滥用设计模式会导致过度设计!仅在问题具备复用性、且未来可能变化时引入模式。

1.2 学习路径建议

  1. ⑴ 先掌握 Java 基础(类、接口、继承、多态)
  2. ⑵ 通读 GoF 23 种模式分类(创建型/结构型/行为型)
  3. ⑶ 从简单模式入手(单例、策略、装饰者)
  4. ⑷ 对照 JDK 源码验证理解(如 ArrayList.sort → 策略模式)
  5. ⑸ 在项目中渐进式应用(先改小模块,再推广)

1.3 常见误区警示

  • · ❌ “所有场景都必须用设计模式” → 实际:简单问题用简单方案更优
  • · ❌ “模式名称决定实现” → 实际:核心是解决问题的意图(Intent),非形式
  • · ❌ “代码越多越高级” → 实际:模式旨在减少重复逻辑,非堆砌代码
  • · ❌ “忽略运行时性能” → 实际:如单例模式需考虑线程安全与懒加载开销

二、23 种设计模式分类全景图

23 种模式按用途分为三大类,每类解决特定层次的设计问题。下表为完整分类索引,供快速定位与系统学习:

类别 模式名称 核心意图 典型应用场景
创建型(5种) 单例模式 确保类仅有一个实例,并提供全局访问点 线程池、缓存、日志对象等资源管理
工厂方法模式 定义创建对象的接口,让子类决定实例化哪个类 JDBC 驱动管理、Spring Bean 创建
抽象工厂模式 提供创建一系列相关或依赖对象的接口 UI 主题切换(Windows/macOS 风格控件)
建造者模式 分离复杂对象的构建与表示,支持逐步构造 StringBuilder、MyBatis SqlSessionFactory 构建
原型模式 通过复制现有对象创建新对象,避免昂贵的创建过程 对象克隆(需实现 Cloneable 接口)
结构型(7种) 适配器模式 将一个类的接口转换成客户期望的另一个接口 USB 转 Type-C 转接器、MyBatis TypeHandler
装饰者模式 动态扩展对象功能,替代继承 Java IO 流(BufferedInputStream)、Spring AOP
代理模式 为其他对象提供一种代理以控制对原对象的访问 RMI、Spring AOP、缓存代理
桥接模式 将抽象与实现解耦,使二者可独立变化 JDBC 驱动与数据库实现分离
组合模式 将对象组合成树形结构以表示“部分-整体”层次 文件系统、DOM 树、GUI 容器树
外观模式 为子系统提供统一高层接口,简化客户端调用 Spring Framework 中的 Context 接口
享元模式 运用共享技术高效支持大量细粒度对象 String 常量池、线程池、数据库连接池
行为型(11种) 责任链模式 将请求沿处理链传递,直至被处理 Servlet Filter、MyBatis Interceptor
命令模式 将请求封装为对象,支持参数化、队列化、日志化 撤销/重做操作、线程池任务提交
解释器模式 定义语言文法,并提供解释器处理句子 SQL 解析器、正则表达式引擎
迭代器模式 提供顺序访问聚合对象元素的方法 Collection.iterator()、Stream API
中介者模式 用中介对象封装对象间交互,降低耦合 MVC 中 Controller、消息总线
备忘录模式 在不破坏封装前提下捕获对象内部状态并保存 游戏存档、数据库事务回滚
观察者模式 定义对象间一对多依赖,状态变更时自动通知 事件监听机制、Spring ApplicationEvent
状态模式 允许对象在内部状态改变时改变其行为 订单状态流转(待支付→已发货)
策略模式 定义一系列算法,将它们封装并可互换 Comparator 排序、Spring CacheManager
模板方法模式 定义算法骨架,延迟步骤到子类实现 JdbcTemplate、HttpServlet.service()
访问者模式 表示一个作用于某对象结构中各元素的操作 AST 解析器、Maven 插件扩展点

2.1 分类记忆口诀(助记法)

创建型:单工工,建原;
结构型:适装代桥,组外享;
行为型:责任命令解迭代,中介备忘观察,状态策略模板访问。

三、核心模式深度详解(含代码示例)

以下选取 6 种高频模式进行深度解析,每种均包含:
① UML 类图要点
② 标准 Java 实现
③ JDK 源码定位
④ 实战注意事项

3.1 单例模式(Singleton)

【意图】确保类仅有一个实例,提供全局访问点。
【UML】类私有构造器 + 静态实例变量 + 公共静态方法。

public class Logger {
    // volatile 确保多线程可见性
    private static volatile Logger instance;
    private Logger() {}
    // 双重检查锁定(DCL)实现线程安全懒加载
    public static Logger getInstance() {
        if (instance == null) {
            synchronized (Logger.class) {
                if (instance == null) {
                    instance = new Logger();
                }
            }
        }
        return instance;
    }
    public void log(String msg) {
        System.out.println("[LOG] " + msg);
    }
}

【JDK 对应】Runtime.getRuntime()、Desktop.getDesktop()、Calendar.getInstance()
【注意】枚举单例最安全(防反射/序列化破坏):

public enum Singleton {
    INSTANCE;
    public void doSomething() {}
}

3.2 工厂方法模式(Factory Method)

【意图】定义创建对象的接口,但让子类决定实例化哪个类。
【UML】Creator 抽象类声明工厂方法,ConcreteCreator 实现具体工厂。

interface Button { void render(); }
class WindowsButton implements Button {
    public void render() { System.out.println("Windows 按钮"); }
}
class MacButton implements Button {
    public void render() { System.out.println("Mac 按钮"); }
}
interface Dialog {
    Button createButton();
}
class WindowsDialog implements Dialog {
    public Button createButton() { return new WindowsButton(); }
}
class MacDialog implements Dialog {
    public Button createButton() { return new MacButton(); }
}
public class Client {
    public static void main(String[] args) {
        Dialog dialog = new MacDialog(); // 运行时决定
        dialog.createButton().render();  // 输出:Mac 按钮
    }
}

【JDK 对应】java.util.Calendar.getInstance()、java.text.NumberFormat.getInstance()
【优势】消除 if-else 判断,符合开闭原则;【劣势】增加类数量

3.3 策略模式(Strategy)

【意图】定义一系列算法,封装每个算法并使其可互换。
【UML】Strategy 接口定义算法,ConcreteStrategy 实现具体策略,Context 使用策略。

interface SortStrategy {
    > void sort(List list);
}
class BubbleSort implements SortStrategy {
    public > void sort(List list) {
        // 冒泡排序实现
        for (int i=0; i 0)
                    Collections.swap(list, j, j+1);
    }
}
class QuickSort implements SortStrategy {
    public > void sort(List list) {
        // 快速排序实现(简化)
        list.sort(Comparator.naturalOrder());
    }
}
class SortContext {
    private SortStrategy strategy;
    public void setStrategy(SortStrategy strategy) { this.strategy = strategy; }
    public void executeSort(List list) { strategy.sort(list); }
}
public class Client {
    public static void main(String[] args) {
        SortContext context = new SortContext();
        context.setStrategy(new QuickSort());
        List list = Arrays.asList(3,1,4,1,5);
        context.executeSort(list); // 自动使用快速排序
    }
}

【JDK 对应】Collections.sort() 接受 Comparator(策略);Arrays.sort() 使用 TimSort(策略)
【实战】Spring Security 中 PasswordEncoder(BCryptPasswordEncoder、Pbkdf2PasswordEncoder)

3.4 装饰者模式(Decorator)

【意图】动态给对象添加功能,比继承更灵活。
【UML】Component 接口定义核心功能,Decorator 持有 Component 引用并扩展。

interface Coffee {
    String getDescription();
    double getCost();
}
class SimpleCoffee implements Coffee {
    public String getDescription() { return "普通咖啡"; }
    public double getCost() { return 10.0; }
}
class MilkDecorator implements Coffee {
    private Coffee coffee;
    public MilkDecorator(Coffee coffee) { this.coffee = coffee; }
    public String getDescription() { return coffee.getDescription() + ", 加奶"; }
    public double getCost() { return coffee.getCost() + 2.0; }
}
class SugarDecorator implements Coffee {
    private Coffee coffee;
    public SugarDecorator(Coffee coffee) { this.coffee = coffee; }
    public String getDescription() { return coffee.getDescription() + ", 加糖"; }
    public double getCost() { return coffee.getCost() + 1.0; }
}
public class Client {
    public static void main(String[] args) {
        Coffee coffee = new MilkDecorator(new SugarDecorator(new SimpleCoffee()));
        System.out.println(coffee.getDescription()); // 普通咖啡, 加糖, 加奶
        System.out.println(coffee.getCost());        // 13.0
    }
}

【JDK 对应】java.io.InputStream 的 FilterInputStream 家族(BufferedInputStream、DataInputStream)
【关键】装饰者与原对象实现同一接口,且构造器参数为接口类型

3.5 代理模式(Proxy)

【意图】为其他对象提供代理以控制访问。
【类型】远程代理(RMI)、虚拟代理(延迟加载)、保护代理(权限控制)。

interface Image {
    void display();
}
class RealImage implements Image {
    private String filename;
    public RealImage(String filename) {
        this.filename = filename;
        loadFromDisk(); // 真实加载耗时操作
    }
    private void loadFromDisk() { System.out.println("加载 " + filename); }
    public void display() { System.out.println("显示 " + filename); }
}
class ProxyImage implements Image {
    private RealImage realImage;
    private String filename;
    public ProxyImage(String filename) { this.filename = filename; }
    public void display() {
        if (realImage == null) realImage = new RealImage(filename);
        realImage.display();
    }
}
public class Client {
    public static void main(String[] args) {
        Image img = new ProxyImage("test.jpg");
        img.display(); // 加载 test.jpg → 显示 test.jpg
        img.display(); // 显示 test.jpg(复用已加载对象)
    }
}

【JDK 对应】java.lang.reflect.Proxy、Spring AOP(JDK 动态代理)
【注意】CGLIB 用于目标类无接口时(生成子类)

3.6 观察者模式(Observer)

【意图】定义对象间一对多依赖,状态变更时自动通知所有依赖者。
【UML】Subject 维护观察者列表,Observer 定义更新接口。

import java.util.*;
interface Observer {
    void update(String event);
}
class EventSource {
    private List observers = new ArrayList<>();
    public void addObserver(Observer o) { observers.add(o); }
    public void notifyObservers(String event) {
        for (Observer o : observers) o.update(event);
    }
    public void doSomething() {
        String event = "任务完成";
        notifyObservers(event);
    }
}
class LogObserver implements Observer {
    public void update(String event) {
        System.out.println("[日志] " + event);
    }
}
class AlertObserver implements Observer {
    public void update(String event) {
        System.out.println("[告警] " + event);
    }
}
public class Client {
    public static void main(String[] args) {
        EventSource source = new EventSource();
        source.addObserver(new LogObserver());
        source.addObserver(new AlertObserver());
        source.doSomething();
        // 输出:
        // [日志] 任务完成
        // [告警] 任务完成
    }
}

【JDK 对应】java.util.EventListener / EventObject(AWT 事件模型)
【现代替代】Spring ApplicationEvent / ApplicationListener;Guava EventBus

四、实战应用指南

本节提供 java23种设计模式教程 在真实项目中的落地经验,包括性能优化、常见坑点及工程化建议。

4.1 性能优化要点

  • · 享元模式:合理使用常量池(如 String、Integer 缓存),但避免过度共享导致内存泄漏
  • · 装饰者链:过长装饰链影响性能,考虑合并或使用 Builder 模式
  • · 单例懒加载:DCL 实现需 volatile + 双重检查,避免指令重排
  • · 观察者通知:异步通知(线程池)避免阻塞主线程

4.2 常见坑点解析

  • · 工厂模式滥用:简单对象创建无需工厂(如 new ArrayList())
  • · 策略模式无变化:若算法永不变更,策略模式增加复杂度
  • · 代理模式反射开销:JDK 动态代理比静态代理慢约 5-10 倍,高并发场景慎用
  • · 单例序列化破坏:需实现 readResolve() 返回单例实例

4.3 工程化建议

  • · 使用依赖注入框架(Spring)自动管理单例与代理
  • · 结合 AOP 实现横切关注点(日志、权限)
  • · 模式命名规范:类名后缀体现模式(如 UserServiceImpl → UserServiceFactory)
  • · 单元测试覆盖:对每种模式实现独立测试用例

4.4 模式组合应用示例

Spring MVC 请求处理流程融合多种模式:
① DispatcherServlet → 中介者模式(协调各组件)
② HandlerMapping → 策略模式(选择处理器)
③ Bean 创建 → 工厂方法 + 单例
④ AOP 拦截 → 代理模式
⑤ 请求日志 → 装饰者模式(RequestWrapper 扩展)

五、高频问题答疑

整理自社区高频提问,逐条深度解答。

Q1:设计模式与编程范式有何区别?

A:编程范式(如面向对象、函数式)是整体编程风格;设计模式是在特定范式下解决具体问题的方案。例如:策略模式是面向对象中的行为型模式,而函数式中可能用高阶函数替代。

Q2:何时该用工厂模式而非直接 new?

A:当满足以下任一条件时:
① 创建逻辑复杂(如需初始化多参数)
② 需要返回子类实例(如 JDBC 驱动)
③ 需解耦客户端与具体实现(依赖注入基础)
④ 需控制实例数量(单例/对象池)

Q3:代理模式与装饰者模式有何区别?

A:
① 代理模式:侧重控制访问(如权限、延迟加载),目标对象可不存在
② 装饰者模式:侧重功能增强,目标对象必须存在
③ 代理常为单例,装饰者可多层嵌套
④ 代理模式中代理类与真实类通常同接口;装饰者要求装饰类与被装饰类实现同一接口

Q4:JDK 中哪些类体现了模板方法模式?

A:
① java.util.AbstractList(定义 add() 基础逻辑)
② java.io.InputStream(定义 read() 模板)
③ javax.servlet.http.HttpServlet(service() 调用 doXXX)
④ Spring JdbcTemplate(execute() 封装连接/异常处理)

5.1 其他问题速查表

问题 答案摘要
单例模式线程安全实现? 双重检查锁定(DCL)或枚举单例
适配器模式与装饰者模式区别? 适配器:接口转换;装饰者:功能增强
观察者模式如何避免内存泄漏? 使用 WeakReference 存储观察者引用
建造者模式 vs 工厂模式? 建造者:分步构建复杂对象;工厂:一次性创建

七、学习资源推荐

7.1 必读书籍

  • 《设计模式:可复用面向对象软件的基础》(GoF)—— 经典原典
  • 《Head First 设计模式》—— 入门首选,图文并茂
  • 《Java与模式》(阎宏)—— 中文经典,结合 JDK 源码
  • 《设计模式:可复用面向对象软件的基础》—— 工程实践指南

7.2 在线资源

7.3 学习建议

1. 每学一种模式,手动写 2 个不同场景的示例
2. 在开源项目中搜索模式关键词(如 "Strategy")验证理解
3. 尝试重构现有代码,逐步替换“坏味道”逻辑
4. 与团队约定模式使用规范,避免过度设计
坚持 java23种设计模式教程 系统学习,您将构建坚实的面向对象设计能力。

八、常见问题解答

我们整理了开发者最常提出的 10 个问题,供快速参考:

8.1 技术类问题

  1. Q:如何判断是否该用代理模式?
    A:当需要控制对象访问(如权限、延迟加载、日志记录)时使用,且目标对象与代理需实现同一接口。
  2. Q:装饰者模式与继承的区别?
    A:装饰者是组合优于继承的体现,可在运行时动态添加功能,而继承在编译时固定。
  3. Q:单例模式有哪几种安全实现?
    A:枚举单例(最安全)、双重检查锁定(DCL)、静态内部类(JVM 保证线程安全)。

8.2 学习类问题

  1. Q:初学者如何避免模式滥用?
    A:先掌握需求,再匹配模式;宁可简单,勿强行套用。
  2. Q:需要记住所有 23 种模式的 UML 图吗?
    A:建议掌握核心 5 种(单例、工厂、策略、装饰者、代理),其余按需查阅。
  3. Q:如何将模式知识转化为项目经验?
    A:在个人项目中刻意练习;参与开源项目贡献模式相关代码。