编辑“︁Java创建型模式”︁（章节）

= Java创建型模式 =

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

== 1. 单例模式（Singleton Pattern） ==
单例模式确保一个类只有一个实例，并提供一个全局访问点。

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

=== 实现方式 ===
以下是线程安全的懒汉式单例实现：
<syntaxhighlight lang="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;
    }
}
</syntaxhighlight>

=== 实际案例 ===
Java运行时环境中的<code>Runtime</code>类就是单例模式的典型应用：
<syntaxhighlight lang="java">
Runtime runtime = Runtime.getRuntime();
runtime.availableProcessors();  // 返回可用处理器数量
</syntaxhighlight>

== 2. 工厂方法模式（Factory Method Pattern） ==
定义一个创建对象的接口，但让子类决定实例化哪个类。

=== 结构图 ===
<mermaid>
classDiagram
    Creator <|-- ConcreteCreator
    Product <|-- ConcreteProduct
    Creator : +factoryMethod()* Product
    ConcreteCreator : +factoryMethod() Product
</mermaid>

=== 代码示例 ===
<syntaxhighlight lang="java">
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");
        };
    }
}
</syntaxhighlight>

=== 使用示例 ===
<syntaxhighlight lang="java">
ShapeFactory factory = new ShapeFactory();
Shape circle = factory.createShape("circle");
circle.draw();  // 输出: Drawing Circle
</syntaxhighlight>

== 3. 抽象工厂模式（Abstract Factory Pattern） ==
提供一个接口，用于创建相关或依赖对象的家族，而不需要指定具体类。

=== 与工厂方法的区别 ===
{| class="wikitable"
|-
! 工厂方法模式 !! 抽象工厂模式
|-
| 创建单一产品 || 创建产品族
|-
| 通过继承实现 || 通过组合实现
|}

=== 代码实现 ===
<syntaxhighlight lang="java">
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风格按钮
</syntaxhighlight>

== 4. 建造者模式（Builder Pattern） ==
分步骤构建复杂对象，允许相同的构建过程创建不同的表示。

=== 经典实现 ===
<syntaxhighlight lang="java">
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();
</syntaxhighlight>

=== JDK应用 ===
<code>StringBuilder</code>和<code>Locale.Builder</code>都采用了建造者模式。

== 5. 原型模式（Prototype Pattern） ==
通过复制现有对象来创建新对象，而不是新建实例。

=== 实现要点 ===
* 实现<code>Cloneable</code>接口
* 重写<code>clone()</code>方法

<syntaxhighlight lang="java">
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();
</syntaxhighlight>

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

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

== 数学原理 ==
某些创建型模式可以形式化表示为：
<math>
\begin{cases}
\text{Singleton}: & |\text{Instances}| = 1 \\
\text{Factory}: & \text{create} : T \rightarrow \text{Product} \\
\text{Prototype}: & \text{clone} : \text{Prototype} \rightarrow \text{Prototype}
\end{cases}
</math>

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

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

[[Category:编程语言]]
[[Category:Java]]
[[Category:Java设计模式]]