建造者模式

1. 介绍

建造者模式是一种设计模式，用于构建复杂对象的各个部分，而无需指定该对象的具体类。它通过逐步创建对象的各个部分，并利用建造者对象将这些部分组装成最终产品。这种模式特别适用于需要创建复杂对象的场景，尤其是在对象的创建过程涉及多个步骤，或者对象的不同部分可以独立变化时。

主要角色

产品（Product）: 最终构建的复杂对象，包含各种组成部分。
抽象建造者（Builder）: 定义创建产品的步骤和方法，但不负责具体的组合。
具体建造者（Concrete Builder）: 继承自抽象建造者，实现具体步骤，负责实际创建产品的部分。
指挥者（Director）: 管理建造过程，调用建造者的方法以确保产品按顺序构建。
客户端（Client）: 使用指挥者来获取最终产品，无需了解构建过程的细节。

应用场景

复杂对象构建: 构建需要多个步骤的复杂对象时，建造者模式非常适用。
步骤独立性: 每个步骤可能需要不同设置时，建造者模式能有效组织这些步骤。
组件独立变化: 当对象的不同部分可以独立变化时，简化对象的创建过程。
重用构建过程: 在多个地方重复使用对象的创建过程时，封装和复用逻辑。
复杂算法: 构建过程涉及复杂逻辑时，封装在具体建造者中，客户端可以简单获取产品。

优点

分离创建与表示: 提高代码灵活性和可维护性。
增加灵活性: 通过不同的建造者配置不同产品特性。
避免参数爆炸: 使代码清晰易懂。
更好的封装: 客户端专注于最终产品，无需了解创建细节。

缺点

增加复杂性: 引入多个角色可能增加系统复杂性。
多个建造者: 对于每种产品类型，可能需要定义多个具体建造者，增加代码量。

2. 代码案例

// =================== 建造者模式 ===================

/**
 * 1. 产品类（Car）:
 *    - engine: 发动机类型，例如 "V8 发动机"。
 *    - transmission: 变速器类型，例如 "6速手动"。
 *    - wheels: 车轮类型，例如 "运动轮胎"。
 *    - color: 颜色，例如 "红色"。
 *    - isSunroof: 是否有天窗（true 或 false）。
 *    - Car.Builder 是一个内部类，用于逐步构建 Car 对象，支持链式调用的方法。
 */

// =================== 产品类（Product） ===================
class Car {
    /**
     * 汽车类，作为建造者模式中的产品类。
     * 包含多个属性，代表汽车的不同特性。
     */
    private String engine;  // 发动机类型
    private String transmission;  // 变速器类型
    private String wheels;  // 车轮类型
    private String color;  // 颜色
    private boolean isSunroof;  // 是否有天窗

    public Car() {
        this.isSunroof = false;  // 默认无天窗
    }

    @Override
    public String toString() {
        return String.format("汽车 [发动机=%s, 变速器=%s, 车轮=%s, 颜色=%s, 天窗=%s]",
                engine, transmission, wheels, color, isSunroof);
    }

    // Builder 类用于逐步构建 Car 对象。
    public static class Builder {
        private Car car;

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

        public Builder setEngine(String engine) {
            car.engine = engine;
            return this;
        }

        public Builder setTransmission(String transmission) {
            car.transmission = transmission;
            return this;
        }

        public Builder setWheels(String wheels) {
            car.wheels = wheels;
            return this;
        }

        public Builder setColor(String color) {
            car.color = color;
            return this;
        }

        public Builder setSunroof(boolean isSunroof) {
            car.isSunroof = isSunroof;
            return this;
        }

        public Car build() {
            return car;
        }
    }
}

// =================== 抽象建造者（Builder） ===================

abstract class CarBuilder {
    /**
     * 汽车建造者接口，定义了构建汽车的各个步骤。
     */
    public abstract CarBuilder buildEngine();
    public abstract CarBuilder buildTransmission();
    public abstract CarBuilder buildWheels();
    public abstract CarBuilder buildColor();
    public abstract CarBuilder buildSunroof();
    public abstract Car getResult();
}

// =================== 具体建造者（Concrete Builder） ===================

class SportsCarBuilder extends CarBuilder {
    /**
     * 具体建造者，实现了 CarBuilder 接口，用于构建一辆特定类型的汽车。
     */
    private Car.Builder builder;

    public SportsCarBuilder() {
        builder = new Car.Builder();
    }

    @Override
    public CarBuilder buildEngine() {
        builder.setEngine("V8 发动机");
        return this;
    }

    @Override
    public CarBuilder buildTransmission() {
        builder.setTransmission("6速手动");
        return this;
    }

    @Override
    public CarBuilder buildWheels() {
        builder.setWheels("运动轮胎");
        return this;
    }

    @Override
    public CarBuilder buildColor() {
        builder.setColor("红色");
        return this;
    }

    @Override
    public CarBuilder buildSunroof() {
        builder.setSunroof(true);
        return this;
    }

    @Override
    public Car getResult() {
        return builder.build();
    }
}

// =================== 指挥者（Director） ===================

class CarDirector {
    /**
     * 指挥者类，负责安排和管理汽车的建造过程。
     */
    private CarBuilder builder;

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

    public Car construct() {
        return builder.buildEngine()
                .buildTransmission()
                .buildWheels()
                .buildColor()
                .buildSunroof()
                .getResult();
    }
}

// =================== 客户端（Client） ===================

public class Main {
    public static void main(String[] args) {
        // 创建具体建造者
        CarBuilder builder = new SportsCarBuilder();

        // 创建指挥者并传入建造者
        CarDirector director = new CarDirector(builder);

        // 使用指挥者构建汽车
        Car car = director.construct();

        // 输出构建的汽车
        System.out.println(car);

        // 直接使用建造者链式调用构建汽车
        Car customCar = builder.buildEngine()
                .buildTransmission()
                .buildWheels()
                .buildColor()
                .buildSunroof()
                .getResult();
        System.out.println(customCar);
    }
}