创建型模式3.建造者模式

创建型模式

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

建造者模式（Builder Pattern） 是一种创建型设计模式，旨在通过一步步构建复杂对象，解耦对象的构建过程和表示方式。建造者模式允许你用相同的构建过程创建不同的表示（即不同类型的复杂对象）。这使得对象的创建过程更加灵活，同时避免了在构造函数中使用大量的参数。

关键概念

Builder（建造者）：负责构建一个产品的各个部分，并提供一个方法来获取构建完成的产品。
ConcreteBuilder（具体建造者） ：实现了 Builder 接口，负责构建产品的各个部分，并提供获取产品的功能。
Product（产品）：由建造者构建的复杂对象，包含多个部分。
Director（指挥者） ：指挥构建过程，负责使用 Builder 来构建产品。Director 并不关心产品的具体组成部分，只是按照特定的步骤来创建产品。

适用场景

当对象的构建过程非常复杂时，且构建过程中的不同步骤可以按照一定的顺序进行组合。
当一个产品的创建过程必须允许不同的表示（例如同一产品的不同版本或变种）。
当对象的构建过程需要控制创建对象的不同部分的顺序。

优缺点分析

优点：

解耦复杂对象的构建与表示：建造者模式将对象的创建过程从对象本身分离出来，使得客户端可以只关心如何构建，而不用关心如何表示。
灵活性强：同一个建造过程可以构建不同的表示。
避免构造函数参数过多：如果一个对象需要多个构造参数，通过建造者模式可以将这些参数逐一设置，避免构造函数参数列表过于复杂。
产品的一致性 ：产品的构建是由 Director 负责的，可以确保产品的构建过程是统一且符合一定顺序的。

缺点：

增加类的数量：需要创建多个具体建造者类和指挥者类，会增加系统的复杂性。
适用于较为复杂的对象构建：对于简单对象的创建，使用建造者模式可能会显得过于复杂。

代码示例

1. 定义产品类（`Product`）

假设我们要创建一个表示汽车的对象，汽车有多个组成部分（如发动机、轮胎、车窗等）。

// 产品类（Product）
public class Car {
    private String engine;
    private String wheels;
    private String windows;

    public void setEngine(String engine) {
        this.engine = engine;
    }

    public void setWheels(String wheels) {
        this.wheels = wheels;
    }

    public void setWindows(String windows) {
        this.windows = windows;
    }

    @Override
    public String toString() {
        return "Car{" +
                "engine='" + engine + '\'' +
                ", wheels='" + wheels + '\'' +
                ", windows='" + windows + '\'' +
                '}';
    }
}

2. 定义建造者接口（`Builder`）

建造者接口定义了构建产品的各个步骤。

// 建造者接口（Builder）
public interface CarBuilder {
    void buildEngine();
    void buildWheels();
    void buildWindows();
    Car getResult();
}

3. 实现具体建造者（`ConcreteBuilder`）

具体建造者负责实现 CarBuilder 接口，构建汽车的不同部分。

// 具体建造者类（ConcreteBuilder）
public class SportsCarBuilder implements CarBuilder {
    private Car car;

    public SportsCarBuilder() {
        car = new Car();
    }

    @Override
    public void buildEngine() {
        car.setEngine("V8 Engine");
    }

    @Override
    public void buildWheels() {
        car.setWheels("Sports Wheels");
    }

    @Override
    public void buildWindows() {
        car.setWindows("Tinted Windows");
    }

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

4. 定义指挥者类（`Director`）

指挥者类负责按顺序构建产品，使用建造者来创建不同的产品。

// 指挥者类（Director）
public class Director {
    private CarBuilder carBuilder;

    public Director(CarBuilder carBuilder) {
        this.carBuilder = carBuilder;
    }

    public Car construct() {
        carBuilder.buildEngine();
        carBuilder.buildWheels();
        carBuilder.buildWindows();
        return carBuilder.getResult();
    }
}

5. 客户端代码

客户端通过指挥者来构建复杂对象。

// 客户端
public class BuilderPatternTest {
    public static void main(String[] args) {
        // 创建具体建造者对象
        CarBuilder builder = new SportsCarBuilder();
        
        // 创建指挥者对象
        Director director = new Director(builder);
        
        // 指挥者根据建造者构建对象
        Car car = director.construct();
        
        // 输出构建好的对象
        System.out.println(car);
    }
}

变种：可选参数

建造者模式可以支持可选的参数，允许客户端根据需要选择是否构建某些部分。例如，在上面的例子中，如果用户不需要车窗，CarBuilder 可以提供一个不设置窗户的建造方法。

总结

建造者模式通过分步骤、分部分地构建复杂对象，极大地解耦了对象的构建和表示过程。这种模式的优点是能够应对对象的复杂性，同时提供灵活的创建过程。它常用于产品（如汽车、电脑等）的构建过程较为复杂、包含多个可选部分的场景。通过使用建造者模式，可以使得创建不同类型的对象更加灵活，并保持较高的可维护性。