Builder模式

定义

将一个复杂对象的构建过程分离，使得同样的构建过程可以创建不同的结果。

使用场景

• 相同的方法，不同的执行顺序，产生不同的结果
• 多个零件或者部件，可以组装到一个对象中，产生不同的结果
• 初始化过程比较复杂，参数较多

举一个例子，Android对话框，就是Builder模式，像这样：

new AlertDialog.Builder(this)
        .setTitle("xxx")
        .setMessage("xxx")
        .create()
        .show();

本是一个相对复杂的对话框，通过链式编程构建出来。

实现

我们假设组装一台宝马轿车，它有品牌、型号、颜色。

车

public abstract class Car {
    // 品牌
    protected String mBrand;
    // 型号
    protected String mModel;
    // 颜色
    protected String mColor;

    public abstract void setBrand();

    public void setColor(String mColor) {
        this.mColor = mColor;
    }

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

    @Override
    public String toString() {
        return "Car{" +
                "mBrand='" + mBrand + '\'' +
                ", mModel='" + mModel + '\'' +
                ", mColor='" + mColor + '\'' +
                '}';
    }
}

宝马车

public class BMWCar extends Car {

    @Override
    public void setBrand() {
        mBrand = "BMW";
    }
}

下面是Builder类，用来描述构建一台车需要哪些方法

public abstract class CarBuilder {

    public abstract CarBuilder buildBrand();

    public abstract CarBuilder buildModel(String model);

    public abstract CarBuilder buildColor(String color);

    public abstract Car create();
}

接下来来实现构建一台宝马车的Builder

public class BMWBuilder extends CarBuilder {

    Car car = new BMWCar();

    @Override
    public BMWBuilder buildBrand() {
        car.setBrand();
        return this;
    }

    @Override
    public BMWBuilder buildModel(String model) {
        car.setModel(model);
        return this;
    }

    @Override
    public BMWBuilder buildColor(String color) {
        car.setColor(color);
        return this;
    }

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

这里的build方法都返回自身，用来链式调用。

调用

下面来构建一台红色的3系宝马轿车

new BMWBuilder()
        .buildBrand()
        .buildModel("3 Li")
        .buildColor("红色")
        .create();

如果你还想给车子添加个HUD、换个真皮座椅，只需要在Builder里添加对用的方法，构建的时候设置属性就可以了。

结论

Builder设计模式具有良好的封装性，构建者独立，方便扩展。
不足就是需要创建多个Builder。