GOF设计模式-建造者模式（builder）

建造者模式（builder），将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

• Dirextor: 指挥者类，用于统一组装流程
• Builder：抽象Builder类，规范产品的组建，一般是由子类实现。
• DFCarBuilder: 抽象Builder类的实现类，实现抽象Builder类定义的所有方法，并且返回一个组建好的对象
• Car：产品类

举个建造汽车的例子，现在要建造一辆汽车，需要发动机，变速箱，底盘（汽车三大件）

产品类：

public class Car {

    private String engine; // 发动机引擎

    private String transmission; // 变速箱

    private String  chassis; // 底盘

    public String getEngine() {
        return engine;
    }

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

    public String getTransmission() {
        return transmission;
    }

    public void setTransmission(String transmission) {
        this.transmission = transmission;
    }

    public String getChassis() {
        return chassis;
    }

    public void setChassis(String chassis) {
        this.chassis = chassis;
    }

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

抽象建造者

public abstract class Builder {

    public abstract void buildEngine(String engine);
    public abstract void buildTransmission(String transmission);
    public abstract void buildChassis(String chassis);

    public abstract Car create();
}

建造者

public class DFCarBuilder extends Builder {

    private Car dfCar = new Car();

    @Override
    public void buildEngine(String engine) {
        dfCar.setEngine(engine);
    }

    @Override
    public void buildTransmission(String transmission) {
        dfCar.setTransmission(transmission);
    }

    @Override
    public void buildChassis(String chassis) {
        dfCar.setChassis(chassis);
    }

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

用Dirextor指挥者类来统一组装过程

public class Dirextor {

    Builder builder = null;

    public Dirextor(Builder builder) {
        this.builder = builder;
    }

    public Car createCar(String engine, String transmission, String chassis){
        this.builder.buildChassis(chassis);
        this.builder.buildEngine(engine);
        this.builder.buildTransmission(transmission);
        return builder.create();
    }

    public static void main(String[] args) {
        Builder builder = new DFCarBuilder();
        Dirextor dirextor = new Dirextor(builder);
        Car myCar = dirextor.createCar("地球梦科技发动机", "爱信9AT自动变速箱", "标志的底盘");
        System.out.println(myCar.toString());
    }
}

使用场景：

• 当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。
• 相同的方法，不同的执行顺序，产生不同的事件结果时。
• 多个部件或零件,都可以装配到一个对象中，但是产生的运行结果又不相同时。
• 产品类非常复杂，或者产品类中的调用顺序不同产生了不同的效能。
• 创建一些复杂的对象时，这些对象的内部组成构件间的建造顺序是稳定的，但是对象的内部组成构件面临着复杂的变化。

优点：

• 使用建造者模式可以使客户端不必知道产品内部组成的细节。
• 具体的建造者类之间是相互独立的，容易扩展。
• 由于具体的建造者是独立的，因此可以对建造过程逐步细化，而不对其他的模块产生任何影响。

代码地址：https://github.com/mazh1992/model/