设计模式——构建者模式

概述：将一个复杂对象的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。

• 抽象建造者（Builder）：给出一个抽象接口，以规范产品对象的各个组成成分的建造。这个接口规定要实现复杂对象的哪些部分的创建，并不涉及具体的对象部件的创建。
• 具体建造者（Concrete Builder）：实现Builder接口，针对不同的商业逻辑，具体化复杂对象的各部分的创建。 在建造过程完成后，提供产品的实例。
• 指导者（Director）：调用具体建造者来创建复杂对象的各个部分，在指导者中不涉及具体产品的信息，只负责保证对象各部分完整创建或按某种顺序创建。
• 产品（Product）：要创建的复杂对象。

例子：

创建一个汽车对象，需要引擎、轮胎、车体等等对象的组合，然后去完成汽车对象的负责业务功能

汽车类：

//汽车
public class Car {

    //引擎
    private Engine engine;
    //轮胎
    private Tyre tyre;
    //车体
    private BodyWork bodyWork;

    //在这实现各种业务方法即可，例如
    public void run() {
        System.out.println(engine.getName() + "," + tyre.getName() + ","
                         + bodyWork.getName() + "的车子跑起来啦...");
    }

    public Engine getEngine() {return engine;}
    public void setEngine(Engine engine) {this.engine = engine;}
    public Tyre getTyre() {return tyre;}
    public void setTyre(Tyre tyre) {this.tyre = tyre;}
    public BodyWork getBodyWork() {return bodyWork;}
    public void setBodyWork(BodyWork bodyWork) {this.bodyWork = bodyWork;}
}

//引擎
class Engine {
    private String name;
    public Engine(String name) {
        this.name = name;
    }

    public String getName() {return name;}
    public void setName(String name) {this.name = name;}
}

//轮胎
class Tyre {
    String name;
    public Tyre(String name) {
        this.name = name;
    }
    public String getName() {return name;}
    public void setName(String name) {this.name = name;}
}

//车体
class BodyWork {
    String name;
    public BodyWork(String name) {
        this.name = name;
    }
    public String getName() {return name;}
    public void setName(String name) {this.name = name;}
}

抽象建造者：

public interface CarBuilder {

    public Engine builderEngine();
    public Tyre builderTyre();
    public BodyWork builderBodyWork();
}

具体建造者：

public class BydCarBuilder implements CarBuilder{

    @Override
    public Engine builderEngine() {
        System.out.println("构建发动机");
        return new Engine("XX发动机");
    }

    @Override
    public Tyre builderTyre() {
        System.out.println("构建轮胎");
        return new Tyre("XX轮胎");
    }

    @Override
    public BodyWork builderBodyWork() {
        System.out.println("构建车身");
        return new BodyWork("XX车身");
    }
}

指导者：

public class BydCarDirector {

    private CarBuilder builder;

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

    /**
     * 组装汽车
     */
    public Car directCar() {
        Engine engine = builder.builderEngine();
        Tyre tyre = builder.builderTyre();
        BodyWork bodyWork = builder.builderBodyWork();

        Car car = new Car();
        //装配成Car对象
        car.setEngine(engine);
        car.setTyre(tyre);
        car.setBodyWork(bodyWork);

        return car;
    }

}

测试类：

public class Test {

    public static void main(String[] args) {

        CarBuilder builder = new BydCarBuilder();

        BydCarDirector director = new BydCarDirector(builder);

        Car car = director.directCar();

        car.run();
    }
}

在平时用的JDom库中的类，DomBuilder、SaxBuilder等就用到了构建者模式