「Java设计模式」图文代码案例详解Java五大创建者模式建造者与原型

一、创建者模式概述

创建者模式（Creational Pattern）是设计模式中最常用的一大类，它主要关注对象的创建过程，旨在将对象的创建与使用分离，降低系统的耦合度。Java中常见的五大创建者模式包括：

单例模式（Singleton）
工厂方法模式（Factory Method）
抽象工厂模式（Abstract Factory）
建造者模式（Builder）
原型模式（Prototype）

本文将重点详解其中的建造者模式和原型模式，并通过图文结合的方式帮助读者深入理解。

二、建造者模式（Builder Pattern）

2.1 模式定义

建造者模式将复杂对象的构建过程与其表示分离，使得同样的构建过程可以创建不同的表示。它适用于创建那些包含多个组成部分、构建过程复杂的对象。

2.2 结构图（UML）

+----------------+ +----------------+
| Director |--------> | Builder |

+----------------+ | + getResult() |
+----------------+
^
|

+----------------------------+
| ConcreteBuilder |

+----------------------------+
|
v

+----------------+
| Product |

+----------------+
| - partA |
| - partB |

+----------------+
`

Director：指挥者，负责安排复杂对象的构建顺序。
Builder：抽象建造者，定义构建产品的各个部分的抽象方法。
ConcreteBuilder：具体建造者，实现 Builder 接口，构造和装配产品的各个部件。
Product：产品角色，被构建的复杂对象。

2.3 代码案例

假设我们要组装一台电脑，电脑由 CPU、内存、硬盘等部件组成。

`java // 产品类：Computer class Computer { private String cpu; private String ram; private String disk;

public void setCpu(String cpu) { this.cpu = cpu; }
public void setRam(String ram) { this.ram = ram; }
public void setDisk(String disk) { this.disk = disk; }

@Override
public String toString() {
return "Computer [CPU=" + cpu + ", RAM=" + ram + ", Disk=" + disk + "]";
}
}

// 抽象建造者
abstract class ComputerBuilder {
protected Computer computer = new Computer();

public abstract void buildCpu();
public abstract void buildRam();
public abstract void buildDisk();

public Computer getResult() {
return computer;
}
}

// 具体建造者：游戏电脑
class GamingComputerBuilder extends ComputerBuilder {
@Override
public void buildCpu() { computer.setCpu("Intel i9"); }
@Override
public void buildRam() { computer.setRam("32GB DDR5"); }
@Override
public void buildDisk() { computer.setDisk("1TB SSD"); }
}

// 具体建造者：办公电脑
class OfficeComputerBuilder extends ComputerBuilder {
@Override
public void buildCpu() { computer.setCpu("Intel i5"); }
@Override
public void buildRam() { computer.setRam("16GB DDR4"); }
@Override
public void buildDisk() { computer.setDisk("512GB SSD"); }
}

// 指挥者
class Director {
private ComputerBuilder builder;

public void setBuilder(ComputerBuilder builder) {
this.builder = builder;
}

public Computer construct() {
builder.buildCpu();
builder.buildRam();
builder.buildDisk();
return builder.getResult();
}
}

// 客户端
public class Client {
public static void main(String[] args) {
Director director = new Director();

ComputerBuilder gamingBuilder = new GamingComputerBuilder();
director.setBuilder(gamingBuilder);
Computer gamingPC = director.construct();
System.out.println(gamingPC);

ComputerBuilder officeBuilder = new OfficeComputerBuilder();
director.setBuilder(officeBuilder);
Computer officePC = director.construct();
System.out.println(officePC);
}
}
`

2.4 应用场景

需要生成的对象具有复杂的内部结构。
需要生成的对象内部属性本身相互依赖。
与不可变对象配合使用，避免构造方法参数过多。

2.5 优缺点

优点：
- 客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦。
- 每一个具体建造者都相对独立，可以方便地扩展新的建造者。

缺点：
- 产品的组成部分必须相同，如果产品内部变化复杂，会导致需要定义很多具体建造者类。
- 如果产品的内部变化复杂，可能会导致系统变得庞大。

三、原型模式（Prototype Pattern）

3.1 模式定义

原型模式用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。它适用于创建重复的对象，同时保证性能。

3.2 结构图（UML）

+---------------------+
| Prototype |

+---------------------+
| + clone(): Prototype|

+---------------------+
^
|

+---------------------+
| ConcretePrototype |

+---------------------+
| + clone(): Prototype|

+---------------------+
`

Prototype：声明克隆自身的接口。
ConcretePrototype：实现克隆自身的具体操作。
Client：通过调用克隆方法来创建新对象。

3.3 代码案例

以一个简历（Resume）为例，通过原型模式复制简历。

`java // 原型接口 interface CloneableResume extends Cloneable { CloneableResume clone(); }

// 具体原型：简历
class Resume implements CloneableResume {
private String name;
private String position;
private String experience;

public Resume(String name, String position, String experience) {
this.name = name;
this.position = position;
this.experience = experience;
}

public void setExperience(String experience) {
this.experience = experience;
}

@Override
public CloneableResume clone() {
try {
return (Resume) super.clone();
} catch (CloneNotSupportedException e) {
throw new RuntimeException(e);
}
}

@Override
public String toString() {
return "Resume{name='" + name + "', position='" + position + "', experience='" + experience + "'}";
}
}

// 客户端
public class PrototypeClient {
public static void main(String[] args) {
Resume original = new Resume("张三", "Java开发工程师", "3年经验");
System.out.println("原始简历：" + original);

// 克隆简历
Resume copy1 = (Resume) original.clone();
copy1.setExperience("5年经验");
System.out.println("克隆简历1：" + copy1);

Resume copy2 = (Resume) original.clone();
copy2.setExperience("1年经验");
System.out.println("克隆简历2：" + copy2);
}
}
`

输出：
`
原始简历：Resume{name='张三', position='Java开发工程师', experience='3年经验'}
克隆简历1：Resume{name='张三', position='Java开发工程师', experience='5年经验'}
克隆简历2：Resume{name='张三', position='Java开发工程师', experience='1年经验'}
`

3.4 深拷贝与浅拷贝

浅拷贝：只复制对象的基本数据类型字段，引用类型字段仍指向原对象。
深拷贝：不仅复制对象的基本数据类型字段，而且递归复制引用类型字段所指向的对象。

浅拷贝实现：默认的 clone() 方法就是浅拷贝。
深拷贝实现：可以通过序列化或手动递归克隆实现。

示例：深拷贝利用序列化：

`java import java.io.*;

class DeepPrototype implements Serializable {
private String name;
private List hobbies;

public DeepPrototype deepClone() {
try {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(this);
ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bis);
return (DeepPrototype) ois.readObject();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
// 省略 getter/setter 和构造器
}
`