Java设计模式怎么实现？

在Java开发中，设计模式是解决常见问题的经典方案，能提升代码的可维护性、扩展性和复用性，下面从专业角度详解Java类设计模式的核心内容,结合代码示例说明实际应用。

设计模式的重要性

设计模式是经验总结的编程范式，由GoF（Gang of Four）在《设计模式：可复用面向对象软件的基础》中系统化提出,其价值在于：

• 降低耦合度：模块间依赖最小化
• 提升代码复用：避免重复造轮子
• 增强系统灵活性：适应需求变化
• 标准化设计：团队协作更高效

设计模式分类及典型实现

创建型模式（管理对象创建）

单例模式（Singleton）
确保类只有一个实例，全局可访问。

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;
    }
}

• 应用场景：数据库连接池、日志处理器
• 优点：节省内存资源
• 缺点：单元测试困难（需Mock静态实例）

工厂方法模式（Factory Method）
将对象创建委托给子类。

interface Shape {
    void draw();
}
class Circle implements Shape {
    @Override
    public void draw() { System.out.println("绘制圆形"); }
}
class ShapeFactory {
    public Shape createShape(String type) {
        if ("circle".equals(type)) return new Circle();
        // 扩展其他形状
        return null;
    }
}

• 应用场景：JDBC连接器、Spring BeanFactory
• 优点：符合开闭原则，新增类型无需修改工厂

结构型模式（组合对象形成结构）

适配器模式（Adapter）
兼容不兼容接口。

class LegacyPrinter {
    void printDocument() { /* 旧式打印 */ }
}
interface ModernPrinter {
    void print();
}
class PrinterAdapter implements ModernPrinter {
    private LegacyPrinter legacyPrinter;
    public PrinterAdapter(LegacyPrinter printer) {
        this.legacyPrinter = printer;
    }
    @Override
    public void print() {
        legacyPrinter.printDocument();  // 适配调用
    }
}

• 应用场景：旧系统整合、第三方库适配

代理模式（Proxy）
控制对象访问。

interface Image {
    void display();
}
class RealImage implements Image {
    @Override
    public void display() { /* 加载大图 */ }
}
class ProxyImage implements Image {
    private RealImage realImage;
    @Override
    public void display() {
        if (realImage == null) {
            realImage = new RealImage();  // 延迟加载
        }
        realImage.display();
    }
}

• 应用场景：Spring AOP、远程方法调用（RMI）

行为型模式（对象间通信）

观察者模式（Observer）
一对多依赖通知。

import java.util.ArrayList;
import java.util.List;
abstract class Subject {
    private List<Observer> observers = new ArrayList<>();
    void attach(Observer o) { observers.add(o); }
    void notifyAll(String message) {
        for (Observer o : observers) {
            o.update(message);
        }
    }
}
interface Observer {
    void update(String message);
}
class User implements Observer {
    @Override
    public void update(String msg) {
        System.out.println("收到通知: " + msg);
    }
}

• 应用场景：事件驱动系统、消息队列订阅
• 优点：解耦发布者与订阅者

策略模式（Strategy）
动态切换算法。

interface PaymentStrategy {
    void pay(int amount);
}
class CreditCardPay implements PaymentStrategy {
    @Override
    public void pay(int amount) { /* 信用卡支付逻辑 */ }
}
class PaymentContext {
    private PaymentStrategy strategy;
    public void setStrategy(PaymentStrategy strategy) {
        this.strategy = strategy;
    }
    public void executePay(int amount) {
        strategy.pay(amount);
    }
}

• 应用场景：支付方式切换、排序算法选择

设计模式选择原则

1. 识别问题本质

   • 创建对象复杂 → 工厂/建造者模式
   • 接口不兼容 → 适配器模式
   • 状态变化通知 → 观察者模式

2. 避免过度设计

   • 简单场景直接实例化对象（而非工厂）
   • 单例滥用会导致全局状态被墙

3. 结合框架特性

   

   • Spring中的依赖注入（DI）天然实现单例和工厂
   • MyBatis使用代理模式生成Mapper接口实现

反模式警示

• 上帝对象（God Object）：单个类承担过多职责 → 拆分为多个类+组合模式
• 循环依赖：A依赖B，B依赖A → 引入中介者模式或事件总线
• 硬编码条件分支：大量if/else → 用策略模式+工厂重构

实际应用建议

1. 重构时机：当发现代码频繁修改相同逻辑时引入模式
2. 性能考量：代理模式可能增加调用链深度
3. 团队共识：统一模式命名（如XXXStrategy）提升可读性

权威引用：

• Gamma, E., Helm, R., Johnson, R., & Vlissides, J. (1994). Design Patterns: Elements of Reusable Object-Oriented Software. Addison-Wesley.
• Oracle官方Java设计模式教程：https://docs.oracle.com/javase/tutorial/extra/certification/designpatterns.html
• Martin Fowler《重构：改善既有代码的设计》

设计模式是工具而非目标，合理运用能显著提升工程质量，但需结合具体场景，建议通过开源项目（如Spring Framework）学习模式的实际应用,并定期进行代码评审优化设计。