设计模式五：建造者模式(Builder Pattern)

建造者模式(Builder Pattern)是一种创建型设计模式，用于通过一系列步骤来构建复杂对象。它将对象的构建过程与其表示分离，从而允许相同的构建过程可以创建不同的表示。

建造者模式中的几个角色：

1. 产品(Product)：表示被构建的复杂对象。
2. 抽象建造者(Builder)：定义了构建复杂对象所需的各个步骤，并声明了获取最终产品的方法。
3. 具体建造者(Concrete Builder)：实现了抽象建造者接口，负责实际构建产品的各个部分，并提供获取最终产品的方法。
4. 指挥者(Director)：负责调用具体建造者的方法来构建产品，但不关心具体的构建过程。
5. 使用建造者模式可以使得构建过程更加灵活，同时可以隐藏复杂对象的构建细节。它适用于需要创建具有多个部分或属性的复杂对象，并希望能够灵活地组合这些部分或属性的场景。

建造者模式适用于以下情况：

1. 当需要创建一个复杂对象，并且希望能够灵活地配置其属性或部分时，可以使用建造者模式。它允许按照特定的顺序或组合来构建对象的不同部分，从而生成不同的表示。
2. 当一个类有多个可选参数，并且希望避免使用大量的构造函数或者参数重载时，建造者模式可以解决这个问题。通过使用方法链式调用，每个可选参数都可以在需要的时候设置，从而构建出完整的对象。
3. 当需要创建的对象由一系列步骤组成，而且希望将这些步骤进行解耦和封装时，可以使用建造者模式。每个具体建造者只关注自己负责的构建步骤，而不必了解其他部分的细节，从而实现了高度的灵活性和可扩展性。
4. 当需要创建的对象具有复杂的内部结构，其中某些部分的构建过程可能相同，但具体细节又有所不同时，建造者模式非常有用。通过定义抽象建造者和具体建造者，可以让不同的建造者负责构建不同的部分，从而实现代码的复用和解耦。
5. 建造者模式适用于需要构建复杂对象，并且希望能够灵活地配置其属性或部分的情况。它可以简化对象的创建过程，提高代码的可读性和可维护性。同时，它也能够隐藏复杂对象的构建细节，使得客户端可以专注于业务逻辑而不必关心对象的创建过程。

一个简单的建造者模式的代码实例：

// 产品类
class Car {
    private String brand;
    private String model;
    private int year;

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public void setModel(String model) {
        this.model = model;
    }

    public void setYear(int year) {
        this.year = year;
    }

    public void display() {
        System.out.println("Brand: " + brand);
        System.out.println("Model: " + model);
        System.out.println("Year: " + year);
    }
}

// 抽象建造者类
abstract class CarBuilder {
    protected Car car;

    public void createCar() {
        car = new Car();
    }

    public abstract void buildBrand();

    public abstract void buildModel();

    public abstract void buildYear();

    public Car getCar() {
        return car;
    }
}

// 具体建造者类
class SedanCarBuilder extends CarBuilder {
    public void buildBrand() {
        car.setBrand("Toyota");
    }

    public void buildModel() {
        car.setModel("Camry");
    }

    public void buildYear() {
        car.setYear(2022);
    }
}

// 指挥者类
class CarDirector {
    private CarBuilder carBuilder;

    public void setCarBuilder(CarBuilder carBuilder) {
        this.carBuilder = carBuilder;
    }

    public Car getCar() {
        return carBuilder.getCar();
    }

    public void buildCar() {
        carBuilder.createCar();
        carBuilder.buildBrand();
        carBuilder.buildModel();
        carBuilder.buildYear();
    }
}

// 客户端代码
public class Main {
    public static void main(String[] args) {
        CarDirector carDirector = new CarDirector();
        CarBuilder sedanCarBuilder = new SedanCarBuilder();

        carDirector.setCarBuilder(sedanCarBuilder);
        carDirector.buildCar();

        Car car = carDirector.getCar();
        car.display();
    }
}

在上面的代码中，我们首先定义了产品类 Car ，然后定义了抽象建造者类 CarBuilder 和具体建造者类 SedanCarBuilder 。接着定义了指挥者类 CarDirector ，它负责控制具体建造者的构建过程。最后，在客户端代码中，我们通过指挥者来创建一个具体的汽车对象。
这个示例中，我们创建了一个 SedanCarBuilder 来构建一辆轿车的对象。通过使用指挥者 CarDirector ，我们可以按照特定的顺序调用建造者的方法，从而构建出一个完整的汽车对象。最终，我们可以通过 getCar() 方法获取到构建好的汽车对象，并调用 display() 方法显示汽车的属性信息。
通过使用建造者模式，我们可以将对象的构建过程与其表示分离，实现了对象的灵活构建。同时，我们也可以根据需要定义不同的具体建造者类来构建不同类型的对象，从而实现了代码的复用和解耦。

建造者模式的优点：

1. 分离构建过程和表示：建造者模式将对象的构建过程与其表示分离，使得相同的构建过程可以创建不同的表示。这样可以提高代码的灵活性和可扩展性。
2. 逐步构建复杂对象：建造者模式允许开发人员逐步构建复杂对象，通过一步步调用建造者的方法来构建对象。这种逐步构建的方式可以确保每个步骤都正确执行，最终得到一个完整且正确的对象。
3. 更好地控制对象的构建过程：使用建造者模式可以明确控制对象的构建过程，并且可以根据需要对其进行调整。开发人员可以自行定义具体的建造者类，从而按照自己的需求来构建对象。
4. 提供更好的对象创建过程管理：通过指挥者类来管理对象的创建过程，可以避免客户端直接与具体建造者类交互，从而简化了客户端的使用方式。

建造者模式的缺点：

1. 增加了代码的复杂度：引入建造者模式会增加额外的代码，包括抽象建造者、具体建造者和指挥者等，从而增加了代码的复杂度和维护成本。
2. 可能会导致对象过多：由于建造者模式可以逐步构建复杂对象，因此可能会导致创建过多的对象。这些对象之间可能存在较大的差异，从而可能导致系统资源的浪费。