Java 常见设计模式（易理解版，含代码示例）

设计模式是解决软件开发中通用问题的标准化解决方案，核心是解耦、复用、提高代码可维护性，以下选取 Java 开发中最常用、最实用的 8 种设计模式，按「创建型 / 结构型 / 行为型」分类，每个模式均说明核心思想 + 适用场景 + 极简代码示例，示例无冗余逻辑，重点体现设计思路。

 

一、创建型模式（管理对象的创建过程，降低创建与使用的耦合）

 

1. 单例模式（Singleton）

 

核心思想

保证一个类在整个应用中只有一个实例，并提供全局唯一的访问入口（避免频繁创建销毁对象，节省资源）。

 

适用场景

工具类、数据库连接池、配置文件管理器、日志工厂等（需全局统一状态的场景）。

经典实现（懒汉式 - 双重检查锁，线程安全 + 懒加载，实际开发首选）

 

java  运行

 
 
 
 
// 单例类：数据库连接池示例
public class DbPool {
    // 1. 私有静态实例，volatile防止指令重排（保证实例初始化完成后再被访问）
    private static volatile DbPool instance;
    
    // 2. 私有构造方法，禁止外部new创建实例
    private DbPool() {
        // 模拟初始化连接池
        System.out.println("初始化数据库连接池，仅执行一次");
    }
    
    // 3. 公共静态方法，全局访问入口
    public static DbPool getInstance() {
        // 第一次检查：未创建时才进入同步代码块（提高效率）
        if (instance == null) {
            // 同步锁：保证线程安全
            synchronized (DbPool.class) {
                // 第二次检查：防止多线程同时进入后重复创建
                if (instance == null) {
                    instance = new DbPool();
                }
            }
        }
        return instance;
    }
    
    // 业务方法：模拟获取连接
    public void getConnection() {
        System.out.println("获取数据库连接");
    }
}

// 测试类
public class SingletonTest {
    public static void main(String[] args) {
        // 两次获取的是同一个实例
        DbPool pool1 = DbPool.getInstance();
        DbPool pool2 = DbPool.getInstance();
        System.out.println(pool1 == pool2); // 输出：true（地址相同，单例生效）
        pool1.getConnection();
    }
}

 

 

 

关键要点

 

• 私有构造器 + 静态实例 + 静态访问方法是单例的核心；
• 双重检查锁（DCL）兼顾「懒加载」（用到时才创建）和「线程安全」，是生产环境最常用的单例实现。

 

2. 工厂方法模式（Factory Method）

 

核心思想

 

定义创建对象的接口，让子类决定具体创建哪个类的实例（将对象创建延迟到子类，解耦创建逻辑与业务逻辑）。

 

适用场景

 

需要根据不同条件创建不同对象，且对象类型有共同父类 / 接口（如日志框架：按配置创建文件日志 / 控制台日志实例）。

 

代码示例（日志工厂场景）

 

java

 

运行

 

 

 

 

// 步骤1：定义产品接口（所有日志对象的共同规范）
public interface Logger {
    void log(String message);
}

// 步骤2：实现具体产品类
// 控制台日志
public class ConsoleLogger implements Logger {
    @Override
    public void log(String message) {
        System.out.println("控制台日志：" + message);
    }
}
// 文件日志
public class FileLogger implements Logger {
    @Override
    public void log(String message) {
        System.out.println("文件日志：" + message);
    }
}

// 步骤3：定义工厂接口（创建产品的抽象方法）
public interface LoggerFactory {
    Logger createLogger();
}

// 步骤4：实现具体工厂类（子类决定创建哪个产品）
// 控制台日志工厂
public class ConsoleLoggerFactory implements LoggerFactory {
    @Override
    public Logger createLogger() {
        return new ConsoleLogger();
    }
}
// 文件日志工厂
public class FileLoggerFactory implements LoggerFactory {
    @Override
    public Logger createLogger() {
        return new FileLogger();
    }
}

// 测试类
public class FactoryMethodTest {
    public static void main(String[] args) {
        // 创建控制台日志：工厂+产品一一对应，无需直接new具体产品
        LoggerFactory factory1 = new ConsoleLoggerFactory();
        Logger logger1 = factory1.createLogger();
        logger1.log("用户登录成功"); // 输出：控制台日志：用户登录成功
        
        // 创建文件日志：新增日志类型只需加「产品类+工厂类」，无需修改原有代码
        LoggerFactory factory2 = new FileLoggerFactory();
        Logger logger2 = factory2.createLogger();
        logger2.log("数据更新失败"); // 输出：文件日志：数据更新失败
    }
}

 

 

 

关键要点

 

• 核心是「工厂接口 + 产品接口」，符合「开闭原则」（新增功能不修改原有代码）；
• 区别于简单工厂（一个工厂创建所有产品），工厂方法更灵活，适合产品类型较多的场景。

 

二、结构型模式（优化类 / 对象的组合方式，实现更灵活的功能扩展）

 

1. 装饰器模式（Decorator）

 

核心思想

 

动态地给对象添加额外功能，无需继承原类（继承是静态扩展，装饰器是动态扩展，更灵活）。

 

适用场景

 

需要为对象添加多个可选功能，且功能可自由组合（如 IO 流、日志增强、奶茶加配料）。

 

代码示例（奶茶加配料场景，贴近生活，易理解）

 

java

 

运行

 

 

 

 
// 步骤1：定义抽象组件（被装饰的核心对象）
public abstract class MilkTea {
    // 奶茶描述
    public abstract String getDescription();
    // 奶茶价格
    public abstract double getPrice();
}

// 步骤2：实现具体组件（基础奶茶，无配料）
// 原味奶茶（基础款）
public class OriginalMilkTea extends MilkTea {
    @Override
    public String getDescription() {
        return "原味奶茶";
    }
    @Override
    public double getPrice() {
        return 10.0; // 基础价10元
    }
}

// 步骤3：定义装饰器抽象类（继承组件，持有组件引用，核心）
public abstract class MilkTeaDecorator extends MilkTea {
    protected MilkTea milkTea; // 持有被装饰的奶茶对象
    // 构造器传入被装饰对象
    public MilkTeaDecorator(MilkTea milkTea) {
        this.milkTea = milkTea;
    }
}

// 步骤4：实现具体装饰器（具体配料，动态添加功能）
// 珍珠配料（装饰器1）
public class PearlDecorator extends MilkTeaDecorator {
    public PearlDecorator(MilkTea milkTea) {
        super(milkTea);
    }
    @Override
    public String getDescription() {
        // 原有描述 + 新增配料
        return milkTea.getDescription() + " + 珍珠";
    }
    @Override
    public double getPrice() {
        // 原有价格 + 配料价格
        return milkTea.getPrice() + 2.0; // 珍珠2元
    }
}
// 椰果配料（装饰器2）
public class CoconutDecorator extends MilkTeaDecorator {
    public CoconutDecorator(MilkTea milkTea) {
        super(milkTea);
    }
    @Override
    public String getDescription() {
        return milkTea.getDescription() + " + 椰果";
    }
    @Override
    public double getPrice() {
        return milkTea.getPrice() + 1.5; // 椰果1.5元
    }
}

// 测试类：自由组合配料（动态扩展）
public class DecoratorTest {
    public static void main(String[] args) {
        // 基础款：原味奶茶
        MilkTea milkTea = new OriginalMilkTea();
        System.out.println(milkTea.getDescription() + " | 价格：" + milkTea.getPrice()); // 原味奶茶 | 10.0
        
        // 动态加珍珠：原味奶茶 + 珍珠
        milkTea = new PearlDecorator(milkTea);
        System.out.println(milkTea.getDescription() + " | 价格：" + milkTea.getPrice()); // 原味奶茶+珍珠 | 12.0
        
        // 再动态加椰果：原味奶茶 + 珍珠 + 椰果
        milkTea = new CoconutDecorator(milkTea);
        System.out.println(milkTea.getDescription() + " | 价格：" + milkTea.getPrice()); // 原味奶茶+珍珠+椰果 | 13.5
        
        // 直接创建：原味奶茶 + 椰果（单独加）
        MilkTea milkTea2 = new CoconutDecorator(new OriginalMilkTea());
        System.out.println(milkTea2.getDescription() + " | 价格：" + milkTea2.getPrice()); // 原味奶茶+椰果 | 11.5
    }
}

 

 

 

关键要点

 

• 装饰器与被装饰对象实现同一接口 / 继承同一父类，保证使用方式一致；
• 装饰器持有被装饰对象的引用，通过「包装」实现功能叠加，支持无限层装饰（如再加布丁、仙草）。

 

2. 代理模式（Proxy）

 

核心思想

 

为一个对象提供替身，通过替身控制对原对象的访问（可在访问原对象前后添加额外逻辑，如权限校验、日志、缓存）。

 

适用场景

 

远程调用（RPC）、权限控制、日志记录、懒加载（如 MyBatis 的 Mapper 代理、Spring AOP 的底层实现）。

 

代码示例（静态代理，权限校验场景，易懂）

 

java

 

运行

 

 

 

 

// 步骤1：定义业务接口（原对象和代理对象共同实现）
public interface UserService {
    // 用户查询功能
    void queryUser(String userId);
}

// 步骤2：实现原对象（真实业务逻辑，核心功能）
public class UserServiceImpl implements UserService {
    @Override
    public void queryUser(String userId) {
        // 真实业务：查询用户信息
        System.out.println("查询用户ID：" + userId + " 的信息，执行数据库操作");
    }
}

// 步骤3：实现代理对象（替身，控制对原对象的访问）
public class UserServiceProxy implements UserService {
    // 持有真实对象的引用
    private UserService userService;
    // 构造器传入真实对象
    public UserServiceProxy(UserService userService) {
        this.userService = userService;
    }
    @Override
    public void queryUser(String userId) {
        // 访问原对象前：添加额外逻辑（权限校验）
        if (checkPermission()) {
            System.out.println("权限校验通过，允许查询用户信息");
            // 调用真实对象的核心方法
            userService.queryUser(userId);
            // 访问原对象后：添加额外逻辑（日志记录）
            System.out.println("查询用户信息完成，记录操作日志");
        } else {
            System.out.println("权限校验失败，禁止查询用户信息");
        }
    }
    // 模拟权限校验逻辑
    private boolean checkPermission() {
        // 此处简化：默认管理员ID为"admin"可访问
        return "admin".equals(Thread.currentThread().getName());
    }
}

// 测试类
public class ProxyTest {
    public static void main(String[] args) {
        // 真实业务对象
        UserService realService = new UserServiceImpl();
        // 代理对象包装真实对象
        UserService proxyService = new UserServiceProxy(realService);
        
        // 1. 以管理员身份访问（线程名设为admin）
        Thread thread1 = new Thread(() -> proxyService.queryUser("U001"), "admin");
        thread1.start(); // 输出：权限校验通过 → 查询用户 → 记录日志
        
        System.out.println("-----分割线-----");
        
        // 2. 以普通用户身份访问（线程名设为user）
        Thread thread2 = new Thread(() -> proxyService.queryUser("U001"), "user");
        thread2.start(); // 输出：权限校验失败，禁止查询
    }
}

 

 

 

关键要点

 

• 静态代理：原对象和代理对象编译期确定，一一对应（适合简单场景）；
• 动态代理（如 JDK 动态代理、CGLIB）：运行期动态生成代理对象，无需手动编写代理类（Spring AOP 核心，适合批量代理场景）；
• 核心：代理对象不做核心业务，只做「增强 / 控制」，真实业务由原对象执行。

 

三、行为型模式（规范对象之间的交互方式，提高交互的灵活性和可复用性）

 

1. 观察者模式（Observer）

 

核心思想

 

定义「一对多」的依赖关系，当被观察者（主题）的状态发生变化时，会自动通知所有依赖它的观察者，并更新观察者状态（发布 - 订阅模式的底层实现）。

 

适用场景

 

事件监听、消息通知、数据更新同步（如 GUI 界面刷新、微信公众号推送、订单状态变更通知）。

 

代码示例（微信公众号推送场景，贴近实际）

 

java

 

运行

 

 

 

 

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

// 步骤1：定义被观察者（主题）接口
public interface Subject {
    // 注册观察者（关注公众号）
    void registerObserver(Observer observer);
    // 移除观察者（取消关注）
    void removeObserver(Observer observer);
    // 通知所有观察者（推送消息）
    void notifyObservers(String message);
}

// 步骤2：定义观察者接口（订阅者）
public interface Observer {
    // 接收通知并更新（接收公众号消息）
    void update(String message);
}

// 步骤3：实现具体被观察者（微信公众号）
public class WeChatOfficialAccount implements Subject {
    // 存储所有观察者（粉丝）
    private List<Observer> observerList = new ArrayList<>();
    // 公众号名称
    private String accountName;
    
    public WeChatOfficialAccount(String accountName) {
        this.accountName = accountName;
    }
    
    @Override
    public void registerObserver(Observer observer) {
        observerList.add(observer);
        System.out.println(observer + " 关注了 " + accountName);
    }
    
    @Override
    public void removeObserver(Observer observer) {
        observerList.remove(observer);
        System.out.println(observer + " 取消关注了 " + accountName);
    }
    
    @Override
    public void notifyObservers(String message) {
        System.out.println("\n" + accountName + " 推送新消息：" + message);
        // 遍历所有观察者，通知更新
        for (Observer observer : observerList) {
            observer.update(message);
        }
    }
    // 公众号发消息（触发通知）
    public void publishMessage(String message) {
        notifyObservers(message);
    }
}

// 步骤4：实现具体观察者（微信用户）
public class WeChatUser implements Observer {
    // 用户名
    private String userName;
    
    public WeChatUser(String userName) {
        this.userName = userName;
    }
    
    @Override
    public void update(String message) {
        // 接收消息后的处理（此处简化为打印）
        System.out.println(userName + " 收到消息：" + message);
    }
    
    @Override
    public String toString() {
        return userName;
    }
}

// 测试类
public class ObserverTest {
    public static void main(String[] args) {
        // 创建被观察者：Java编程公众号
        Subject javaAccount = new WeChatOfficialAccount("Java编程");
        
        // 创建观察者：3个微信用户
        Observer user1 = new WeChatUser("张三");
        Observer user2 = new WeChatUser("李四");
        Observer user3 = new WeChatUser("王五");
        
        // 用户关注公众号（注册观察者）
        javaAccount.registerObserver(user1);
        javaAccount.registerObserver(user2);
        javaAccount.registerObserver(user3);
        
        // 公众号推送第一条消息
        javaAccount.publishMessage("Java设计模式超详细讲解！");
        
        // 李四取消关注（移除观察者）
        javaAccount.removeObserver(user2);
        
        // 公众号推送第二条消息（李四不再接收）
        javaAccount.publishMessage("Spring Boot最新教程上线！");
    }
}

 

 

 

输出结果

 

plaintext

 

 

张三 关注了 Java编程
李四 关注了 Java编程
王五 关注了 Java编程

Java编程 推送新消息：Java设计模式超详细讲解！
张三 收到消息：Java设计模式超详细讲解！
李四 收到消息：Java设计模式超详细讲解！
王五 收到消息：Java设计模式超详细讲解！
李四 取消关注了 Java编程

Java编程 推送新消息：Spring Boot最新教程上线！
张三 收到消息：Spring Boot最新教程上线！
王五 收到消息：Spring Boot最新教程上线！

 

 

关键要点

 

• 被观察者维护观察者列表，提供「注册 / 移除 / 通知」方法；
• 观察者实现「更新」方法，接收被观察者的状态变化；
• 核心：被观察者与观察者解耦，新增观察者只需实现 Observer 接口，无需修改被观察者代码（开闭原则）。

 

2. 策略模式（Strategy）

 

核心思想

 

定义一系列算法 / 策略，将每个算法封装成独立的类，使它们可以互相替换（算法与使用算法的客户端解耦，方便切换和扩展）。

 

适用场景

 

需要根据不同场景选择不同算法，且算法易变（如排序算法、支付方式、优惠活动计算）。

 

代码示例（支付方式选择场景，实际开发常用）

 

java

 

运行

 

 

 
 
// 步骤1：定义策略接口（所有支付算法的共同规范）
public interface PayStrategy {
    // 支付方法：返回支付结果
    String pay(double amount);
}

// 步骤2：实现具体策略类（不同的支付方式，封装独立算法）
// 支付宝支付
public class AlipayStrategy implements PayStrategy {
    @Override
    public String pay(double amount) {
        return "使用支付宝支付 " + amount + " 元，支付成功！";
    }
}
// 微信支付
public class WeChatPayStrategy implements PayStrategy {
    @Override
    public String pay(double amount) {
        return "使用微信支付 " + amount + " 元，支付成功！";
    }
}
// 银行卡支付
public class BankCardPayStrategy implements PayStrategy {
    @Override
    public String pay(double amount) {
        return "使用银行卡支付 " + amount + " 元，支付成功！";
    }
}

// 步骤3：定义上下文类（客户端，使用策略的对象，持有策略引用）
public class PayContext {
    // 持有策略接口引用（面向接口编程，支持任意策略）
    private PayStrategy payStrategy;
    // 构造器注入策略（动态切换）
    public PayContext(PayStrategy payStrategy) {
        this.payStrategy = payStrategy;
    }
    // 对外提供支付方法，调用策略的核心算法
    public String doPay(double amount) {
        return payStrategy.pay(amount);
    }
    // 提供set方法，支持运行时动态修改策略
    public void setPayStrategy(PayStrategy payStrategy) {
        this.payStrategy = payStrategy;
    }
}

// 测试类：动态切换支付方式
public class StrategyTest {
    public static void main(String[] args) {
        double orderAmount = 99.0; // 订单金额99元
        
        // 1. 使用支付宝支付
        PayContext payContext = new PayContext(new AlipayStrategy());
        System.out.println(payContext.doPay(orderAmount)); // 支付宝支付99元
        
        // 2. 运行时切换为微信支付
        payContext.setPayStrategy(new WeChatPayStrategy());
        System.out.println(payContext.doPay(orderAmount)); // 微信支付99元
        
        // 3. 运行时切换为银行卡支付
        payContext.setPayStrategy(new BankCardPayStrategy());
        System.out.println(payContext.doPay(orderAmount)); // 银行卡支付99元
        
        // 新增支付方式（如银联支付）：只需加一个策略类，无需修改PayContext
        // payContext.setPayStrategy(new UnionPayStrategy());
    }
}

 

 

 

关键要点

 

• 策略接口定义算法规范，具体策略类实现算法，算法之间互相独立；
• 上下文类（PayContext）不关心具体算法，只负责调用策略，面向接口编程；
• 新增算法只需实现策略接口，无需修改原有代码，符合「开闭原则」（区别于大量 if-else 判断）。

 

3. 模板方法模式（Template Method）

 

核心思想

 

在抽象父类中定义一个算法的骨架（模板方法），将算法中可变的步骤延迟到子类实现（固定算法结构，灵活定制可变步骤）。

 

适用场景

 

多个子类有共同的算法流程，仅部分步骤实现不同（如数据库操作、文件解析、奶茶制作流程）。

 

代码示例（数据库操作场景，开发常用，固定流程：连接→执行→关闭）

 

java

 

运行

 

 

 
 
// 步骤1：定义抽象父类（模板类，定义算法骨架）
public abstract class DbTemplate {
    // 模板方法：定义数据库操作的固定流程（final修饰，防止子类重写）
    public final String executeDbOperation(String sql) {
        // 步骤1：连接数据库（固定步骤，父类实现）
        connect();
        // 步骤2：执行SQL（可变步骤，子类实现）
        String result = executeSql(sql);
        // 步骤3：关闭数据库连接（固定步骤，父类实现）
        close();
        // 返回执行结果
        return result;
    }
    
    // 固定步骤1：连接数据库（父类实现，子类无需修改）
    private void connect() {
        System.out.println("连接数据库，加载驱动，建立连接...");
    }
    
    // 可变步骤2：执行SQL（抽象方法，子类必须实现）
    public abstract String executeSql(String sql);
    
    // 固定步骤3：关闭连接（父类实现，子类无需修改）
    private void close() {
        System.out.println("关闭数据库连接，释放资源...");
    }
}

// 步骤2：实现具体子类（定制可变步骤）
// 查询操作子类
public class SelectDbOperation extends DbTemplate {
    @Override
    public String executeSql(String sql) {
        System.out.println("执行查询SQL：" + sql);
        return "查询成功，返回10条数据";
    }
}
// 插入操作子类
public class InsertDbOperation extends DbTemplate {
    @Override
    public String executeSql(String sql) {
        System.out.println("执行插入SQL：" + sql);
        return "插入成功，影响1行数据";
    }
}

// 测试类
public class TemplateMethodTest {
    public static void main(String[] args) {
        // 执行查询操作：调用模板方法，自动执行「连接→查询→关闭」
        DbTemplate selectTemplate = new SelectDbOperation();
        String selectResult = selectTemplate.executeDbOperation("SELECT * FROM user");
        System.out.println("操作结果：" + selectResult);
        
        System.out.println("-----分割线-----");
        
        // 执行插入操作：调用同一模板方法，自动执行「连接→插入→关闭」
        DbTemplate insertTemplate = new InsertDbOperation();
        String insertResult = insertTemplate.executeDbOperation("INSERT INTO user(name) VALUES('张三')");
        System.out.println("操作结果：" + insertResult);
    }
}

 

 

 

关键要点

 

• 模板方法用final修饰，防止子类重写算法骨架，保证流程统一；
• 固定步骤由父类实现（私有方法，子类不可见），可变步骤由抽象方法定义，子类强制实现；
• 核心：封装不变部分，扩展可变部分，减少代码冗余（多个子类复用父类的固定流程）。

 

4. 迭代器模式（Iterator）

 

核心思想

 

提供一个统一的迭代器对象，遍历集合 / 容器中的元素，无需暴露容器的底层实现（如数组、链表、HashMap），实现「遍历逻辑与容器实现解耦」。

 

适用场景

 

需要遍历不同类型的容器，且不想暴露容器内部结构（Java 集合框架的Iterator就是迭代器模式的经典实现）。

 

代码示例（自定义集合 + 迭代器，模拟 Java 的 Iterator）

 

java

 

运行

 

 

 

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

// 步骤1：定义迭代器接口（统一遍历方法）
public interface MyIterator<T> {
    // 是否有下一个元素
    boolean hasNext();
    // 获取下一个元素
    T next();
}

// 步骤2：定义容器接口（提供获取迭代器的方法）
public interface MyCollection<T> {
    // 添加元素
    void add(T t);
    // 获取迭代器
    MyIterator<T> iterator();
}

// 步骤3：实现具体容器（底层用List实现，对外隐藏）
public class MyArrayList<T> implements MyCollection<T> {
    // 底层容器（对外隐藏，不暴露）
    private List<T> list = new ArrayList<>();
    
    @Override
    public void add(T t) {
        list.add(t);
    }
    
    // 返回自定义迭代器
    @Override
    public MyIterator<T> iterator() {
        return new MyArrayListIterator();
    }
    
    // 内部类：实现迭代器接口，封装遍历逻辑（仅容器内部可见）
    private class MyArrayListIterator implements MyIterator<T> {
        // 遍历索引
        private int index = 0;
        @Override
        public boolean hasNext() {
            return index < list.size();
        }
        @Override
        public T next() {
            return list.get(index++);
        }
    }
}

// 测试类：统一方式遍历容器，无需关心底层实现
public class IteratorTest {
    public static void main(String[] args) {
        // 创建自定义容器
        MyCollection<String> collection = new MyArrayList<>();
        // 添加元素
        collection.add("Java");
        collection.add("设计模式");
        collection.add("迭代器模式");
        collection.add("示例");
        
        // 获取迭代器，统一遍历
        MyIterator<String> iterator = collection.iterator();
        while (iterator.hasNext()) {
            String element = iterator.next();
            System.out.println(element); // 依次输出：Java → 设计模式 → 迭代器模式 → 示例
        }
        
        // 若底层替换为数组/链表，只需修改MyArrayList的实现，遍历代码无需任何修改
    }
}

 

 

 

关键要点

 

• 迭代器接口定义统一的遍历方法（hasNext/next），所有容器的迭代器都实现此接口；
• 容器只负责「存储元素」，迭代器负责「遍历元素」，遍历逻辑与容器解耦；
• Java 中所有集合（List/Set/Map）都实现了迭代器模式，Collection.iterator()就是获取迭代器的方法，遍历方式完全统一。

 

四、设计模式核心原则（一句话总结，理解后更易活用）

 

1. 开闭原则：对扩展开放，对修改关闭（新增功能用扩展，不修改原有代码）；
2. 单一职责：一个类 / 方法只做一件事（避免功能臃肿，便于维护）；
3. 依赖倒置：面向接口编程，不面向具体实现（降低耦合，提高灵活性）；
4. 里氏替换：子类可以完全替换父类，且不影响程序运行（保证继承的合理性）；
5. 迪米特法则：最少知道原则，一个对象只和直接关联的对象交互（降低耦合）。

 

五、总结

 

以上 8 种设计模式是 Java 开发中使用率最高、最实用的，各模式的核心价值可简单总结：

 

模式	核心价值	典型应用场景
单例模式	全局唯一实例，节省资源	工具类、连接池、配置管理器
工厂方法	解耦对象创建与使用	日志框架、对象工厂
装饰器模式	动态给对象添加功能	IO 流、日志增强
代理模式	控制对象访问，添加增强逻辑	权限校验、Spring AOP
观察者模式	一对多通知，发布 - 订阅	消息推送、事件监听
策略模式	算法可替换，消除 if-else	支付方式、排序算法
模板方法	固定算法骨架，扩展可变步骤	数据库操作、流程化业务
迭代器模式	统一遍历容器，隐藏底层实现	集合框架、自定义容器

 

使用技巧：设计模式不是 “必须用”，而是 “按需用”—— 当代码出现「耦合高、复用性低、维护困难」时，再考虑用设计模式优化，避免过度设计。