构造者设计模式

构造者模式又叫创造者模式，是将一个复杂的对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。创建者模式隐藏了复杂对象的创建过程，它把复杂对象的创建过程加以抽象，通过子类继承或者重载的方式，动态的创建具有复合属性的对象。

这个说法有点官方,简单来说,有一个对象创建过程很复杂,我们采用构造者模式,可以将这个复杂的创建过程隐藏起来,而且可以通过构建者,来实现对象创建的多元化

举个例子,比如电脑的创建过程,需要创建CPU,硬盘,屏幕,主机,内存,适配器,键盘等等一系列小对象,最后才能构建出一个电脑对象也就是如果创建一个电脑对象的通常的做法,是这样编写我们的代码:

new Computer(new CPU(),new 屏幕(),new 硬盘(),new 内存(),new 主机(),new 内存(),new 适配器())

这样创建对象变得非常不容易,还有可能有电脑对象有两个cpu,两个内存,这样对象创建就更复杂,构造者设计模式就是解决复杂对象的创建,以及对象创建的多元化而诞生的

1.建造者角色（Builder）

对复杂对象的创建过程加以抽象，给出一个抽象接口，以规范产品对象的各个组成部分的建造。这个接口规定了要实现复杂对象的哪个部分的创建，但并不涉及具体对象不见的创建。

2.具体创建者角色（ConcreateBuilder）

实现Builder接口，针对不同的业务逻辑，具体化复杂对象的各个部分的创建。在建造过程完成后，提供产品的实例。

3.指导者（Director）

调用具体建造者来创建复杂对象的各个部分，在指导者中不设计具体产品的信息，只负责保证对象各部分完整创建或者按某种顺序创建。

4.产品（Computer）

要创建的复杂对象，一般来说包含多个部分。

下面我们通过代码体会一下：

首先我们定义Computer类，里面用一个List存储Computer对象的各个部分：

class Computer {

    List<String> parts = new ArrayList<>();

    public void show() {
        for (String part : parts) {
            System.out.println(part);
        }
    }
}

然后，我们定义Builder抽象类，并定义Computer包括CPU，Disk，Screen三个部分：

interface Builder {
    void buildCpu();

    void buildDisk();

    void buildScreen();

    Computer getComputer();

}

下面分别定义ConcreateBuilder角色的ThinkPadComputerBuilder及DaiErComputerBuilder

class ThinkPadComputerBuilder implements Builder {
    private Computer com = new Computer();

    @Override
    public void buildCpu() {
        com.parts.add("ThinkPadCPU");
    }

    @Override
    public void buildDisk() {
        com.parts.add("ThinkPadDisk");
    }

    @Override
    public void buildScreen() {
        com.parts.add("ThinkPadScreen");
    }

    @Override
    public Computer getComputer() {
        return com;
    }

}

class DaiErComputerBuilder implements Builder {
    private Computer com = new Computer();

    @Override
    public void buildCpu() {
        com.parts.add("DaiErCPU");
    }

    @Override
    public void buildDisk() {
        com.parts.add("DaiErDisk");
    }

    @Override
    public void buildScreen() {
        com.parts.add("DaiErScreen");
    }

    @Override
    public Computer getComputer() {
        return com;
    }

}

下面我们定义指导者角色BuilderDirector，在类中添加Builder的引用，并通过其构造方法初始化builder属性：

class Direct {

    private Buidler builder;

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

    public Computer build() {
        builder.buildCpu();
        builder.buildDisk();
        builder.buildScreen();
        return builder.getComputer();
    }

}

编写测试类：

public class Test {

    public static void main(String[] args) {
        //首先,创建出一个专门创建小对象的构建类
        Buidler thinkPadbuidler = new ThinkPadComputerBuilder();
        Buidler daiErBuidler = new DaiErComputerBuilder();
        //将构建类传入到控制类
        Direct dir1 = new Direct(thinkPadbuidler);
        Direct dir2 = new Direct(daiErBuidler);
        //调用控制类的,组装方法,组成一个Computer对象
        Computer thinkPadcomputer = dir1.build();
        Computer daiErComputer = dir2.build();

        thinkPadcomputer.show();
        daiErComputer.show();
    }
}

总结：

1）使用建造者模式的好处：

①使用建造者模式可以使客户端不必知道产品内部组成的细节。

②具体的建造者类之间是相互独立的，这有利于系统的扩展。

③具体的建造者相互独立，因此可以对建造的过程逐步细化，而不会对其他模块产生任何影响。

2）建造者模式的使用场景：

①创建一些复杂对象时，这些对象的内部组成部分之间的建造顺序是稳定的，但对象的内部组成构建面临着复杂的变化。

②要创建的复杂对象的算法，独立于该对象的组成部分，也独立于组成部分的装配方法时。

原文地址：http://blog.51cto.com/13587708/2103551