建造者模式

1. 定义

建造者模式（Bulider Pattern）是将一个复杂对象的构建过程与它的实现表示分离，使得同样的构建过程可以创建不同的表示，属于创建型模式。

这定义看着很懵，对吧，我形象的解答一下，那就是复杂对象的实现表示是可以抽象出一个共有逻辑的（比如车都有车门，车架，底盘），但是复杂对象的构建过程是各自的（赛车的底盘就低，SUV的底盘就高，各自的构建过程是不同的）。

建造者模式把最后的实现表示，和中间的构建过程分离开了。

说白了，一个建造者根据自己的逻辑建造一套产品，工程师根据不同的建造者得到对应的一套产品，根据表示逻辑进行表示。

这和抽象工厂模式对应上了，前面抽象工厂模式我们讲过，抽象工厂模式就是卖套餐，卖一系列产品。建造者在这儿就是一个卖套餐的，一个建造者有一系列产品，但是，这些散装的零件拿给消费者，消费者懵了啊，我要买车你给我这些干哈，我不会啊。所以需要有一个工程师，他说我的设定就是组装，所以工程师内部是复杂产品的表示逻辑。

2. 代码

依旧是这个车的例子，车有车门，车架，底盘，每个部位的对象都有一个属性value，一个抽象的Builder确定了构建车门，车架和底盘的逻辑。宝马和特斯拉两个Builder实现类各自都有自己的车门，车架和底盘的构建逻辑。一个工程师复杂车门、车架和底盘的表示逻辑（组装）。

车 Car：

public class Car {
    private Door door;
    private Frame frame;
    private BasePlate basePlate;

    public void setDoor(Door door) {
        this.door = door;
    }

    public void setFrame(Frame frame) {
        this.frame = frame;
    }

    public void setBasePlate(BasePlate basePlate) {
        this.basePlate = basePlate;
    }

    @Override
    public String toString() {
        return "Car{" +
                "door='" + door + '\'' +
                ", frame='" + frame + '\'' +
                ", basePlate='" + basePlate + '\'' +
                '}';
    }
}

车门 Door

public class Door {
    private String value;

    public Door() {
    }

    @Override
    public String toString() {
        return value;
    }

    public Door(String value) {
        this.value = value;
    }
}

车架 Frame

public class Frame {
    private String value;

    public Frame() {
    }

    @Override
    public String toString() {
        return value;
    }

    public Frame(String value) {
        this.value = value;
    }
}

底盘 BasePlate

public class BasePlate {
    private String value;

    public BasePlate() {
    }

    @Override
    public String toString() {
        return value;
    }

    public BasePlate(String value) {
        this.value = value;
    }
}

抽象的Builder

public abstract class Builder {

    public abstract Door buildDoor();

    public abstract Frame buildFrame();

    public abstract BasePlate buildBasePlate();
}

宝马Builder

public class BMWBuilder extends Builder{
    @Override
    public Door buildDoor() {
        return new Door("宝马自己的车门生产");
    }

    @Override
    public Frame buildFrame() {
        return new Frame("宝马自己的车架生产");
    }

    @Override
    public BasePlate buildBasePlate() {
        return new BasePlate("宝马自己的底盘生产");
    }
}

特斯拉Builder

public class TeslaBuilder extends Builder{
    @Override
    public Door buildDoor() {
        return new Door("特斯拉自己的车门生产");
    }

    @Override
    public Frame buildFrame() {
        return new Frame("特斯拉自己的车架生产");
    }

    @Override
    public BasePlate buildBasePlate() {
        return new BasePlate("特斯拉自己的底盘生产");
    }
}

工程师Engineer

public class Engineer {
    private Car car = new Car();

    public void make(Builder builder) {
        car.setDoor(builder.buildDoor());
        car.setFrame(builder.buildFrame());
        car.setBasePlate(builder.buildBasePlate());
        System.out.println("工程师已经完成了车的组装逻辑：" + car);
    }
}

测试代码

public class Test {
    public static void main(String[] args) {
        Engineer engineer = new Engineer();
//        Builder builder = new BMWBuilder(); //工程师已经完成了车的组装逻辑：Car{door='宝马自己的车门生产', frame='宝马自己的车架生产', basePlate='宝马自己的底盘生产'}
        Builder builder = new TeslaBuilder();//工程师已经完成了车的组装逻辑：Car{door='特斯拉自己的车门生产', frame='特斯拉自己的车架生产', basePlate='特斯拉自己的底盘生产'}

        engineer.make(builder);
    }
}