定义

众所周知，汽车这种具有很复杂结构的物体，很难一下完全构造出来。如图所示，我们可以先分别构建汽车的各个组成部分：发动机(engine)、底盘(chassis)、车身(carBody)、各种汽车系统(carSystem)，然后将这些部分进行组装就形成了一个完整的汽车。建造者模式就是一种让你分步骤创建复杂对象的设计模式。

示例分析

首先我们定义一个汽车对象，包含以上所说的各个部分。并且重写了 toString() 方法，方便最终我们的打印输出

public class Car {
    private String engine;
    private String chassis;
    private String carBody;
    private String carSystem;

    public Car() {
    }

    public Car(String engine, String chassis, String carBody, String carSystem) {
        this.engine = engine;
        this.chassis = chassis;
        this.carBody = carBody;
        this.carSystem = carSystem;
    }

    @Override
    public String toString() {
        return String.format("这是一辆组装好的汽车，包含:\n引擎: %s,\n底盘: %s,\n车身:%s,\n车载系统:%s",
                this.engine, this.chassis, this.carBody, this.carSystem);
    }
}

然后我们定义抽象的构建者类 CarBuilder ，该类中的每个方法就是建造的一个步骤，并且包含一个最终的组装方法（即之前提到的模板方法模式）。

public abstract class CarBuilder {
    public abstract String buildEngine();
    public abstract String buildChassis();
    public abstract String buildCarBody();
    public abstract String buildCarSystem();

    public Car build() {
        return new Car(
                buildEngine(),
                buildChassis(),
                buildCarBody(),
                buildCarSystem()
        );
    }
}

接下来我们分别实现宝马车和奥迪车对每个汽车部分的实现。相当于我们汽车工厂的流水线已经构建好了。

public class AudiCarBuilder extends CarBuilder {
    @Override
    public String buildEngine() {
        return "奥迪---引擎";
    }

    @Override
    public String buildChassis() {
        return "奥迪---底盘";
    }

    @Override
    public String buildCarBody() {
        return "奥迪---车身";
    }

    @Override
    public String buildCarSystem() {
        return "奥迪---车载系统";
    }
}


public class BMWCarBuilder extends CarBuilder {
    @Override
    public String buildEngine() {
        return "宝马---引擎";
    }

    @Override
    public String buildChassis() {
        return "宝马---底盘";
    }

    @Override
    public String buildCarBody() {
        return "宝马---车身";
    }

    @Override
    public String buildCarSystem() {
        return "宝马---车载系统";
    }
}

要想生产汽车，一定要有一个汽车工厂才行，接下来我们构建一个汽车工厂用来生产汽车。该工厂就是你给我一条汽车生产流水线（即明确的汽车建造者），我就给你生产一辆汽车。

public class CarFactory {
    public static Car buildCar(CarBuilder builder) {
        return builder.build();
    }
}

最终我们通过 Client 执行我们的整体流程，并打印最终的结果

public class Client {
    public static void main(String[] args) {
        Car bmwCar = CarFactory.buildCar(new BMWCarBuilder());
        System.out.println(bmwCar);

        System.out.println();

        Car audiCar = CarFactory.buildCar(new AudiCarBuilder());
        System.out.println(audiCar);
    }
}

这是一辆组装好的汽车，包含:
引擎: 宝马---引擎,
底盘: 宝马---底盘,
车身:宝马---车身,
车载系统:宝马---车载系统

这是一辆组装好的汽车，包含:
引擎: 奥迪---引擎,
底盘: 奥迪---底盘,
车身:奥迪---车身,
车载系统:奥迪---车载系统

优缺点

优点

1. 可以分步创建对象， 暂缓创建步骤或递归运行创建步骤
2. 生成不同形式的产品时， 你可以复用相同的制造代码
3. 单一职责原则。 你可以将复杂构造代码从产品的业务逻辑中分离出来

缺点

1. 该模式需要新增多个类， 会导致代码整体复杂程度会有所增加