Java设计模式之五：建造者模式详细解析

一、建造者模式介绍：

建造者模式是针对复杂对象的构建过程，提供一种分步构建对象的解决方案。它允许用户能够通过一步步构建对象的方式创建一个复杂的对象，同时也可以灵活地增加或修改构建步骤，最终构建出特定的对象。

1.1建造者模式定义

建造者模式是一种对象创建型模式，它将构建复杂对象的过程和表示进行分离，使得同样的构建过程可以创建不同的表示。

1.2建造者模式结构与分析：

建造者模式包含以下几个角色：

• Product（产品）：要创建的复杂对象。
• Builder（建造者）：定义构建对象各个部分的接口，以及提供一个构建复杂对象的抽象方法。
• ConcreteBuilder（具体建造者）：实现Builder接口，负责构建和装配产品的各个部分。
• Director（指挥者）：负责安排构建顺序，也可通过Builder接口直接获取各个部分并构建复杂对象。
• Client（客户端）：使用Builder模式的客户端。

二、建造者模式代码举例：

2.1电脑构建者模式

这是一个简单的电脑构建者模式的示例，通过Director指挥者来指导具体的构建者（ConcreteBuilder）构建出特定配置的电脑对象。

// 例子1: 创建一个电脑对象
// Product: 电脑
class Computer {
  private String cpu;
  private String memory;
  private String hardDrive;

  // ... 省略其他属性

  // 省略构造函数、getter和setter方法
}

// Builder: 电脑构建者接口
interface ComputerBuilder {
  void buildCPU();
  void buildMemory();
  void buildHardDrive();
  Computer getProduct();
}

// ConcreteBuilder: 具体电脑构建者
class DesktopComputerBuilder implements ComputerBuilder {
  private Computer computer = new Computer();

  @Override
  public void buildCPU() {
    computer.setCpu("Intel Core i7");
  }

  @Override
  public void buildMemory() {
    computer.setMemory("16GB DDR4");
  }

  @Override
  public void buildHardDrive() {
    computer.setHardDrive("1TB SSD");
  }

  @Override
  public Computer getProduct() {
    return computer;
  }
}

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

  public ComputerDirector(ComputerBuilder builder) {
    this.builder = builder;
  }

  public Computer buildComputer() {
    builder.buildCPU();
    builder.buildMemory();
    builder.buildHardDrive();
    return builder.getProduct();
  }
}

// Client: 客户端代码
public class Client {
  public static void main(String[] args) {
    ComputerBuilder builder = new DesktopComputerBuilder();
    ComputerDirector director = new ComputerDirector(builder);
    Computer computer = director.buildComputer();
    // 使用构建好的computer对象
  }
}

1. Computer 类表示要创建的产品——电脑，它包含了 private 字段 cpu, memory 和 hardDrive，用于存储电脑的 CPU、内存和硬盘信息。

2. ComputerBuilder 接口是电脑构建者的抽象，定义了构建电脑的方法 buildCPU(), buildMemory() 和 buildHardDrive()，以及获取构建好的电脑对象的方法 getProduct()。

3. DesktopComputerBuilder 类是具体的电脑构建者，实现了 ComputerBuilder 接口，它负责实际构建电脑对象的过程。在 buildCPU(), buildMemory() 和 buildHardDrive() 方法中分别设置了电脑的 CPU、内存和硬盘信息，最后在 getProduct() 方法中返回构建好的电脑对象。

4. ComputerDirector 类充当指挥者的角色，负责安排构建顺序。在 buildComputer() 方法中按照约定的顺序调用建造者的方法，然后返回构建好的电脑对象。

5. Client 类是客户端代码，它实例化具体的建造者对象和指挥者对象，然后通过指挥者来构建电脑对象。

整体上，这段代码展示了建造者模式的典型结构。它通过将产品的构建过程和产品本身解耦，使得可以按照步骤构建一个复杂的对象，同时也可以轻松地改变构建步骤或者构建不同表示的对象。

2.2建造者模式来创建一辆汽车对象

// Product: 汽车
class Car {
  private String brand;
  private String model;
  private String color;
  private String engine;
  // ... 其他属性

  // 省略构造函数、getter和setter方法
}

// Builder: 汽车构建者接口
interface CarBuilder {
  void buildBrand(String brand);
  void buildModel(String model);
  void buildColor(String color);
  void buildEngine(String engine);
  Car getProduct();
}

// ConcreteBuilder: 具体汽车构建者
class SedanCarBuilder implements CarBuilder {
  private Car car = new Car();

  @Override
  public void buildBrand(String brand) {
    car.setBrand(brand);
  }

  @Override
  public void buildModel(String model) {
    car.setModel(model);
  }

  @Override
  public void buildColor(String color) {
    car.setColor(color);
  }

  @Override
  public void buildEngine(String engine) {
    car.setEngine(engine);
  }

  @Override
  public Car getProduct() {
    return car;
  }
}

// Director: 指挥者
class CarManufacturer {
  private CarBuilder builder;

  public CarManufacturer(CarBuilder builder) {
    this.builder = builder;
  }

  public void constructCar(String brand, String model, String color, String engine) {
    builder.buildBrand(brand);
    builder.buildModel(model);
    builder.buildColor(color);
    builder.buildEngine(engine);
  }

  public Car getCar() {
    return builder.getProduct();
  }
}

// Client: 客户端代码
public class Client {
  public static void main(String[] args) {
    CarBuilder builder = new SedanCarBuilder();
    CarManufacturer manufacturer = new CarManufacturer(builder);

    manufacturer.constructCar("Toyota", "Camry", "Silver", "2.5L");
    Car car = manufacturer.getCar();
    // 使用构建好的 car 对象
  }
}

在这个例子中，我们使用了建造者模式来创建汽车对象。CarBuilder 接口定义了构建汽车的步骤，SedanCarBuilder 是一个具体的汽车构建者，负责实现构建步骤并创建 Car 对象。CarManufacturer 充当指挥者的角色，实际上提供了一个更加简单易用的接口来安排构建步骤。

三、建造者模式适用环境：

• 当所创建的对象有复杂的内部结构或者有复杂的构建过程时，建造者模式则可以很好地适用。
• 如果需要构建出多个具有相同构建步骤的复杂对象，但最终表示方式不同，也可以考虑使用建造者模式。

四、建造者模式优缺点：

优点：

• 可以分步构建复杂对象，使得构建过程更直观、灵活。
• 可以隐藏产品内部细节，便于用户通过相同的构建过程创建不同的表示。

缺点：

• 对于产品内部变化和需求的变化，需要修改建造者接口和具体建造者类，而且随着产品复杂度的增加，建造者模式的实现也会变得比较复杂。