Java创建型模式

Java创建型模式

创建型模式是设计模式的一个类别，专注于对象的创建机制，旨在以更灵活、高效的方式实例化对象。在Java中，创建型模式通过封装对象的创建过程，降低代码耦合度，提高可维护性和可扩展性。本章节详细介绍五种常见的Java创建型模式：单例模式、工厂方法模式、抽象工厂模式、建造者模式和原型模式。

1. 单例模式（Singleton Pattern）

单例模式确保一个类只有一个实例，并提供一个全局访问点。

适用场景

• 需要控制资源访问（如数据库连接池）。
• 配置管理器或日志记录器。

实现方式

以下是线程安全的懒汉式单例实现：

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

实际案例

Java运行时环境中的Runtime类就是单例模式的典型应用：

Runtime runtime = Runtime.getRuntime();
runtime.availableProcessors();  // 返回可用处理器数量

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

定义一个创建对象的接口，但让子类决定实例化哪个类。

结构图

classDiagram Creator <|-- ConcreteCreator Product <|-- ConcreteProduct Creator : +factoryMethod()* Product ConcreteCreator : +factoryMethod() Product

代码示例

interface Shape {
    void draw();
}

class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing Circle");
    }
}

class ShapeFactory {
    public Shape createShape(String type) {
        return switch (type.toLowerCase()) {
            case "circle" -> new Circle();
            // 可扩展其他形状
            default -> throw new IllegalArgumentException("Unknown shape type");
        };
    }
}

使用示例

ShapeFactory factory = new ShapeFactory();
Shape circle = factory.createShape("circle");
circle.draw();  // 输出: Drawing Circle

3. 抽象工厂模式（Abstract Factory Pattern）

提供一个接口，用于创建相关或依赖对象的家族，而不需要指定具体类。

与工厂方法的区别

工厂方法模式	抽象工厂模式
创建单一产品	创建产品族
通过继承实现	通过组合实现

代码实现

interface GUIFactory {
    Button createButton();
    Checkbox createCheckbox();
}

class WinFactory implements GUIFactory {
    public Button createButton() { return new WinButton(); }
    public Checkbox createCheckbox() { return new WinCheckbox(); }
}

// 使用
GUIFactory factory = new WinFactory();
Button btn = factory.createButton();
btn.paint();  // 渲染Windows风格按钮

4. 建造者模式（Builder Pattern）

分步骤构建复杂对象，允许相同的构建过程创建不同的表示。

经典实现

class Computer {
    private String CPU;
    private String RAM;
    // ...其他组件

    static class Builder {
        private String CPU;
        private String RAM;

        Builder withCPU(String cpu) { this.CPU = cpu; return this; }
        Builder withRAM(String ram) { this.RAM = ram; return this; }
        
        Computer build() {
            Computer computer = new Computer();
            computer.CPU = this.CPU;
            computer.RAM = this.RAM;
            return computer;
        }
    }
}

// 使用
Computer pc = new Computer.Builder()
    .withCPU("Intel i7")
    .withRAM("16GB")
    .build();

JDK应用

StringBuilder和Locale.Builder都采用了建造者模式。

5. 原型模式（Prototype Pattern）

通过复制现有对象来创建新对象，而不是新建实例。

实现要点

• 实现Cloneable接口
• 重写clone()方法

class Sheep implements Cloneable {
    private String name;
    
    public Sheep(String name) { this.name = name; }
    
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

// 使用
Sheep original = new Sheep("Dolly");
Sheep cloned = (Sheep) original.clone();

深拷贝与浅拷贝

• 浅拷贝：复制基本类型字段，引用类型字段共享
• 深拷贝：完全独立的对象副本

模式对比总结

模式名称	主要目的	适用场景
单例模式	控制实例数量	全局唯一对象
工厂方法	子类决定实例化	单一产品创建
抽象工厂	创建产品族	相关对象家族
建造者	分步构建复杂对象	多参数对象构造
原型模式	克隆现有对象	创建成本高的对象

数学原理

某些创建型模式可以形式化表示为： $\{\begin{array}{ll}\text{Singleton}:& |\text{Instances}|=1\\ \text{Factory}:& \text{create}:T\to \text{Product}\\ \text{Prototype}:& \text{clone}:\text{Prototype}\to \text{Prototype}\end{array}$

最佳实践建议

1. 优先考虑简单工厂而非抽象工厂 2. 单例模式要谨慎使用，避免成为"全局变量" 3. 建造者模式适合参数超过4个的构造函数 4. 原型模式在对象创建成本高时特别有效

通过掌握这些创建型模式，开发者可以更灵活地控制系统中的对象创建过程，提高代码的可维护性和扩展性。