设计模式之建造者模式
- 一、原理
- 二、使用场景：
-
- 1.场景1：
- [2. 场景2：](#2. 场景2：)
- 三、代码示例：
-
- [1. 创建Computer 类，表示要构建的复杂对象。](#1. 创建Computer 类，表示要构建的复杂对象。)
- [2. 创建Builder接口，定义构建对象的各个步骤。](#2. 创建Builder接口，定义构建对象的各个步骤。)
- [3. 创建具体的Builder类，实现Builder接口，并具体实现构建对象的各个步骤。](#3. 创建具体的Builder类，实现Builder接口，并具体实现构建对象的各个步骤。)
- [4. 创建Director类，负责使用Builder对象构建复杂对象。](#4. 创建Director类，负责使用Builder对象构建复杂对象。)
- [5. 在客户端中使用Director来构建复杂对象。](#5. 在客户端中使用Director来构建复杂对象。)
- 6、运行以上代码，可以输出以下结果：
- 四、总结
一、原理
1、建造者模式是一种创建型设计模式，用于创建复杂对象。它通过将对象的构建过程分解为多个简单的步骤，并且使用相同的构建过程可以创建不同的表示。
2、建造者模式通过将对象的构建过程分解为多个步骤，每个步骤由一个Builder类负责。建造者类通常包含一些方法用于设置对象的各个部分，并且返回自身。最后，客户端通过调用建造者类的方法来构建对象。
二、使用场景：
1.场景1：
当需要创建一个包含多个组成部分或者参数较多的对象时，可以使用建造者模式。例如，创建一个汽车对象时需要设置引擎、车身、轮胎、内饰等多个部分。
2. 场景2：
当需要创建一个对象的构建过程可以灵活组装时，可以使用建造者模式。例如，可以根据客户的需求动态地组装一个自定义的电脑。
三、代码示例：
下面是一个简单的示例代码，展示了如何使用建造者模式创建一个电脑对象：
1. 创建Computer 类，表示要构建的复杂对象。
java
package org.storemanage.regestercenter.bulidermode;
/**
* @CreateTime: 2024-08-27
* @Description: 电脑信息
* @Version: 1.0
* @Author: hkf
*/
public class Computer {
private String name;
private String cpu;
private String hardDisk;
private String Memory;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getCpu() {
return cpu;
}
public void setCpu(String cpu) {
this.cpu = cpu;
}
public String getHardDisk() {
return hardDisk;
}
public void setHardDisk(String hardDisk) {
this.hardDisk = hardDisk;
}
public String getMemory() {
return Memory;
}
public void setMemory(String memory) {
Memory = memory;
}
@Override
public String toString() {
return "Computer{" +
"name='" + name + '\'' +
", cpu='" + cpu + '\'' +
", hardDisk='" + hardDisk + '\'' +
", Memory='" + Memory + '\'' +
'}';
}
}2. 创建Builder接口，定义构建对象的各个步骤。
java
package org.storemanage.regestercenter.bulidermode;
/**
* @CreateTime: 2024-08-27
* @Description: 设置电脑属性的接口
* @Version: 1.0
* @Author: hkf
*/
public interface Builder {
void setName();
void setCpu();
void setHarDisk();
void setMemory();
Computer builder();
}3. 创建具体的Builder类，实现Builder接口，并具体实现构建对象的各个步骤。
java
package org.storemanage.regestercenter.bulidermode;
/**
* @CreateTime: 2024-08-27
* @Description: 具体电脑实现类
* @Version: 1.0
* @Author: hkf
*/
public class ConcreteBuilder implements Builder{
private Computer computer = new Computer();
@Override
public void setName() {
computer.setName("Lenovo Computer");
}
@Override
public void setCpu() {
computer.setCpu("i9 13代");
}
@Override
public void setHarDisk() {
computer.setHardDisk("固态硬盘2T");
}
@Override
public void setMemory() {
computer.setMemory("内存48G");
}
@Override
public Computer builder() {
return computer;
}
}4. 创建Director类，负责使用Builder对象构建复杂对象。
java
package org.storemanage.regestercenter.bulidermode;
/**
* @CreateTime: 2024-08-27
* @Description: 负责使用Builder对象构建复杂对象
* @Version: 1.0
* @Author: hkf
*/
public class Director {
private Builder builder;
public void setBuilder(Builder builder) {
this.builder = builder;
}
public Computer createObject(){
builder.setCpu();
builder.setName();
builder.setMemory();
builder.setHarDisk();
return builder.builder();
}
}5. 在客户端中使用Director来构建复杂对象。
java
package org.storemanage.regestercenter.bulidermode;
/**
* @CreateTime: 2024-08-27
* @Description: 计算机测试类
* @Version: 1.0
* @Author: hkf
*/
public class ComputerDemo {
public static void main(String[] args) {
Director director = new Director();
ConcreteBuilder concreteBuilder = new ConcreteBuilder();
director.setBuilder(concreteBuilder);
Computer computer = director.createObject();
System.err.println("获取电脑名称name:\n"+computer.getName());
System.err.println("获取电脑信息Cpu：\n"+computer.getCpu());
System.err.println("获取电脑内存信息Memory:\n"+computer.getMemory());
System.err.println("获取硬盘信息hardDis:\n"+computer.getHardDisk());
}
}6、运行以上代码，可以输出以下结果：
获取电脑名称name:
Lenovo Computer
获取电脑信息Cpu：
i9 13代
获取电脑内存信息Memory:
内存48G
获取硬盘信息hardDis:
固态硬盘2T
以上就是使用建造者模式的示例代码和详解。建造者模式将对象的构建过程分解为多个步骤，使得创建复杂对象变得灵活和可扩展。
四、总结
1、建造者模式的优点：
- 提供了将复杂对象的构建过程和表示分离的能力，使得构建过程可以独立于表示而变化。
- 可以隐藏复杂对象的创建细节，使得客户端代码可以直接使用已经构建好的对象，而不需要知道具体的构建过程。
- 可以通过改变具体的建造者和指导者来创建不同的产品，使得客户端代码可以使用不同的建造者来构建不同的产品实例。
- 可以避免在客户端代码中直接创建复杂对象，从而提高代码的可维护性和可扩展性。
2、建造者模式的缺点：
- 建造者模式会增加代码的复杂度，需要定义多个类和接口来实现建造者和指导者，增加了系统的抽象层次。
- 如果产品的构建过程相对简单，或者产品的结构相对稳定，使用建造者模式可能会显得过于复杂和冗余。
- 建造者模式在创建对象时需要一定的性能开销，因为需要额外的对象构建过程和对象组装操作。
如有不足欢迎指出，期待与大家一起进步--------------