设计模式——建造者模式

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

product: 要创建的复杂对象
builder（抽象建造者）：规定要实现的复杂对象的创建，不涉及具体的对象部件的创建
concretebuilder:实现builder。针对不同的商业逻辑，具体化复杂对象的各部分创建，在构造完成之后，提供产品的实例。
director：调用具体建造者来创建复杂对象的各个部分，在指导者中不涉及具体产品的信息，只负责保证各部分完整创建或按某种顺序创建。

举例：车的建造（造车轮，造车身，造发动机）
car类：

package builder2;

public class car {
    private String wheel;
    private String skeleton;
    private String engine;

    public String getWheel() {
        return wheel;
    }
    public void setWheel(String wheel) {
        this.wheel = wheel;
    }
    public String getSkeleton() {
        return skeleton;
    }
    public void setSkeleton(String skeleton) {
        this.skeleton = skeleton;
    }
    public String getEngine() {
        return engine;
    }
    public void setEngine(String engine) {
        this.engine = engine;
    }
}

builder接口：

package builder2;

public interface builder {
    public void buildwheel() ;
    public void buildSkeleton();
    public void buildEngine();
    car buildcar();
}

具体建造者1：

package builder2;

public class concratebuilder implements builder {
    public concratebuilder(){
        c = new car();
    }
    car c;
    @Override
    public void buildwheel() {
        c.setWheel("奥迪轮子");
    }

    @Override
    public void buildSkeleton() {
        c.setSkeleton("奥迪车身结构");
    }

    @Override
    public void buildEngine() {
        c.setEngine("奥迪发动机");
    }

    @Override
    public car buildcar() {
        return c;
    }
}

具体建造者2：

package builder2;

public class concratebuilder2 implements builder {
    public concratebuilder2(){
        c = new car();
    }
    car c;
    @Override
    public void buildwheel() {
        c.setWheel("奔驰轮子");
    }

    @Override
    public void buildSkeleton() {
        c.setSkeleton("奔驰车身结构");
    }

    @Override
    public void buildEngine() {
        c.setEngine("奔驰发动机");
    }

    @Override
    public car buildcar() {
        return c;
    }
}

指导者：

package builder2;

public class director {
    public car construct(builder b){
        b.buildEngine();
        b.buildSkeleton();
        b.buildwheel();
        return b.buildcar();
    }
}

客户端：

package builder2;

public class Main {
    public static void main(String[] args) {
        director d = new director();
        builder b = new concratebuilder();
        builder b2 = new concratebuilder2();
        car c = d.construct(b);
        System.out.println(c);

        car c2 = d.construct(b2);
        System.out.println(c2);
    }
}

运行结果：

建造者模式和抽象工厂的区别：
建造者模式的指导者（director）管理建造者（builder)，用户与指导者联系，指导者联系建造者，最后得到产品。建造者模式可以强制实行一种分步骤进行的构造过程。只提供产品类各个组件的建造，具体的建造过程交给指导者。
工厂模式将全部创建过程封装在工厂类，由工厂类像客户端提供最终的产品。