题目
介绍下建造者模式
答案
建造者模式（Builder Pattern）是一种 创建型设计模式，用于构建一个复杂对象的各个部分，并允许使用相同的构建过程创建不同的表示（或版本）对象。
建造者模式的特点:
- **将对象的构建过程与表示分离**
- 适合对象内部结构复杂、参数较多或构建步骤较多的场景。
- 通常包含以下几个角色：
- **Product（产品类）**：复杂对象，将被构建的对象。
- **Builder（抽象建造者）**：定义构建产品的各个部件的抽象。
- **ConcreteBuilder（具体建造者）**：实现 Builder 接口，具体构建各个部件。
- **Director（指挥者）**：调用建造者的方法来完成复杂对象的创建。
代码示例：建造一台电脑
```java
// 产品类
public class Computer {
private String CPU;
private String GPU;
private String memory;
private String storage;
public void setCPU(String CPU) { this.CPU = CPU; }
public void setGPU(String GPU) { this.GPU = GPU; }
public void setMemory(String memory) { this.memory = memory; }
public void setStorage(String storage) { this.storage = storage; }
@Override
public String toString() {
return "Computer{" +
"CPU='" + CPU + '\'' +
", GPU='" + GPU + '\'' +
", Memory='" + memory + '\'' +
", Storage='" + storage + '\'' +
'}';
}
}
// 抽象建造者
public interface ComputerBuilder {
void buildCPU();
void buildGPU();
void buildMemory();
void buildStorage();
Computer getComputer();
}
// 具体建造者
public class GamingComputerBuilder implements ComputerBuilder {
private Computer computer = new Computer();
public void buildCPU() {
computer.setCPU("Intel i9");
}
public void buildGPU() {
computer.setGPU("NVIDIA RTX 4090");
}
public void buildMemory() {
computer.setMemory("32GB DDR5");
}
public void buildStorage() {
computer.setStorage("1TB NVMe SSD");
}
public Computer getComputer() {
return computer;
}
}
// 指挥者
public class Director {
private ComputerBuilder builder;
public Director(ComputerBuilder builder) {
this.builder = builder;
}
public void constructComputer() {
builder.buildCPU();
builder.buildGPU();
builder.buildMemory();
builder.buildStorage();
}
public Computer getComputer() {
return builder.getComputer();
}
}
// 测试
public class Main {
public static void main(String[] args) {
ComputerBuilder builder = new GamingComputerBuilder();
Director director = new Director(builder);
director.constructComputer();
Computer computer = director.getComputer();
System.out.println(computer);
}
}
```
使用场景
- 当一个对象的构建过程非常复杂时（如多个步骤、顺序要求等）。
- 当一个类的构造函数有很多参数，尤其是可选参数时。