设计模式

今天我们来一起看一下建造这模式。

借用百度百科的语言：

在这样的设计模式中，有以下几个角色：

1 builder：为创建一个产品对象的各个部件指定抽象接口。

2 ConcreateBuilder：实现Builder的接口以构造和装配该产品的各个部件，定义并明确它所创建的表示，并 提供一个检索产品的接口。

3 Director：构造一个使用Builder接口的对象。

4 Product：表示被构造的复杂对象。ConcreteBuilder创建该产品的内部表示并定义它的装配过程，包含定义组成部件的类，包括将这些部件装配成最终产品的接口。

这些就是这个设计模式中涉及到的所有角色。

从名字上看，建造者，那么重点一定是在Builder和Director上，由builder来构建Product的各个部件，并完成最终的Product装配。由Director构造一个builder的实体对象，那么指挥builder工作的内容都在director中，因此，我们在使用时，只需要持有director对象就行了。最终就能得到一个Product的对象。我们并不关注Product的构建过程是怎样的，它的构建对我们完全不透明。我只需要拿到Product就行了。

建造这模式封装了整个Product实例化的过程，对前台不透明。

我在网上看到过一篇解释建造者模式的文章，说的非常形象，在这里引用一下，我忘记原地址了~对原作者深表歉意

案例：我们需要一所房子（Home），因此我找来了一个包工头（Director，他懂房子的设计和构造），又找来了一群人来建房子（ConCreateBuilder，这些人只知道建造，对于设计并不懂，我也不懂，那么就需要包工头出场了），由包工头来指挥这些人怎么建造（怎么做窗子，做门，做墙壁，做地板……等等）。包工头也不组装房子，还是由包工头来设计生产和组装的过程，组装的过程最后还是由builder来完成的。最后我们只需要找到包工头，拿到我们的房子就行了。整个过程中，我都没有参与房子的建造过程，最后我还是拿到了房子。

使用上面这个案例，我们来用代码实现整个过程：

Home

public class Home {    Window window;//有一扇窗子    Door door;//有一扇门    Floor floor;//有地板    public Home() {        // TODO Auto-generated constructor stub        window = new Window();        door = new Door();        floor = new Floor();    }    class Window {        String windowName;    }    class Door {        String doorName;    }    class Floor {        String floorName;    }    public void speak() {        System.out.println("i am home , my window is " + window.windowName + ", door is " + door.doorName                + ", floor is " + floor.floorName);    }}

我们需要一间房子，房子有门，有窗，有地板。

接下来需要建造房子的人（Builder，ConCreateBuilder）

Builder接口

public interface Builder {    void buildWindow(String windowName);    void buildDoor(String doorName);    void buildFloor(String floorName);    Home buildHome();}

抽象了房子的各个部件和整个房子的建造过程

ConCreateBuilder

public class ConCreateBuilder implements Builder {    Home home;    public ConCreateBuilder() {        // TODO Auto-generated constructor stub        home = new Home();    }    @Override    public void buildWindow(String windowName) {        // TODO Auto-generated method stub        home.window.windowName = windowName;    }    @Override    public void buildDoor(String doorName) {        // TODO Auto-generated method stub        home.door.doorName = doorName;    }    @Override    public void buildFloor(String floorName) {        // TODO Auto-generated method stub        home.floor.floorName = floorName;    }    @Override    public Home buildHome() {        // TODO Auto-generated method stub        return home;    }}

在ConCreateBuilder中实际的去建造。

来看看包工头都干了什么

Director

public class Director {    Builder builder ;    public Director(Builder builder) {        this.builder = builder;    }    Home buildHome() {        builder.buildDoor("doorA");        builder.buildWindow("windowB");        builder.buildFloor("floorC");        return builder.buildHome();    }}

可以看到包工头并没有参与建造过程，它只是指挥了builder怎么去建造，做窗子，做门，做地板，做房子，并把做好的房子返回回去

接下来我们做一个测试类：

Main

public class Main {    public static void main(String[] args) {        // TODO Auto-generated method stub        Builder builder = new ConCreateBuilder();        Director director = new Director(builder);        Home home = director.buildHome();        home.speak();    }}

测试结果：

i am home , my window is windowB, door is doorA, floor is floorC

从上面这个测试类中，我们看到，我们什么也没做，招了一群建造者，招了一个包工头（Director），告诉包工头，我需要一所房子;

然后包工头（Dirctor）就去指挥这群人（ConCreateBuilder），指导他们builderDoor(),buildWindow(),buildFloor()，最后组装成房子（buildHome）;

ConCreateBuilder在包工头下达了命令之后，给这所房子做了门……最后组建了房子。

上面很形象的及时了整个建造者模式的过程，对象的创建由建造者完成，我们不再需要自己去做对象的创建过程。