Java设计模式：建造者模式

1. 定义

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

2. 角色

2.1 Builder：抽象建造者

给出一个抽象接口，以规范产品对象的各个组成成分的建造。

2.2 ConcreteBuilder：具体建造者

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

2.3 Director：指挥者

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

2.4 Product：产品角色

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

3. 实例

实例模型：再把老东家拿来做例子：冠捷(TPV)生产飞利浦电视，接收到客户的订单后，车间的领导就会开启电视制作的生产线。电视是由电源，主板，音箱，屏幕组成。

产品角色类：

package zzw.cn.buildtv;

public class PhilipsTV
{
    private String screen;//屏幕
    private String power;//电源
    private String mainboard;//主板
    private String speaker;//音箱

    public String getScreen()
    {
        return screen;
    }

    public void setScreen(String screen)
    {
        this.screen = screen;
    }

    public String getPower()
    {
        return power;
    }

    public void setPower(String power)
    {
        this.power = power;
    }

    public String getMainboard()
    {
        return mainboard;
    }

    public void setMainboard(String mainboard)
    {
        this.mainboard = mainboard;
    }

    public String getSpeaker()
    {
        return speaker;
    }

    public void setSpeaker(String speaker)
    {
        this.speaker = speaker;
    }

    public void show()
    {
        System.out.println("PhilipsTV{" +
                "screen='" + screen + '\'' +
                ", power='" + power + '\'' +
                ", mainboard='" + mainboard + '\'' +
                ", speaker='" + speaker + '\'' +
                '}');
    }
}

抽象建造者类：

package zzw.cn.buildtv;

public abstract class PhilipsTVBuilder
{
    abstract void buildScreen();
    abstract void buildPower();
    abstract void buildMainboard();
    abstract void buildSpeaker();
    abstract PhilipsTV createPhilipsTV();
}

具体建造者类：

package zzw.cn.buildtv;

public class TPVPhilipsTVBuilder extends PhilipsTVBuilder
{
    private PhilipsTV mPhilipsTV = new PhilipsTV();

    @Override
    void buildScreen()
    {
        mPhilipsTV.setScreen("飞利浦电视的屏幕组装完成。");
    }

    @Override
    void buildPower()
    {
        mPhilipsTV.setPower("飞利浦电视的屏幕组装完成。");
    }

    @Override
    void buildMainboard()
    {
        mPhilipsTV.setMainboard("飞利浦电视的主板组装完成。");
    }

    @Override
    void buildSpeaker()
    {
        mPhilipsTV.setSpeaker("飞利浦电视的音箱组装完成。");
    }

    @Override
    PhilipsTV createPhilipsTV()
    {
        return mPhilipsTV;
    }
}

  指挥者：调用建造者中的方法完成复杂对象的创建。

package zzw.cn.buildtv;

public class TPVDirector
{
    private PhilipsTVBuilder builder;

    public TPVDirector(PhilipsTVBuilder builder)
    {
        this.builder = builder;
    }
    public PhilipsTV construct()
    {
        builder.buildPower();
        builder.buildMainboard();
        builder.buildScreen();
        builder.buildSpeaker();
        return builder.createPhilipsTV();
    }
}

 客户类：

package zzw.cn.buildtv;

public class BuilderTest
{
    public static void main(String[] args)
    {
        PhilipsTVBuilder builder = new TPVPhilipsTVBuilder();
        TPVDirector director = new TPVDirector(builder);
        PhilipsTV philipsTV = director.construct();
        philipsTV.show();
    }
}

结果：

PhilipsTV{screen='飞利浦电视的屏幕组装完成。', power='飞利浦电视的屏幕组装完成。', mainboard='飞利浦电视的主板组装完成。', speaker='飞利浦电视的音箱组装完成。'}

Process finished with exit code 0

4. 优缺点 

优点：

a. 良好的封装性， 使用建造者模式可以使客户端不必知道产品内部组成的细节；

b. 建造者独立，容易扩展；

c. 在对象创建过程中会使用到系统中的一些其它对象，这些对象在产品对象的创建过程中不易得到。

缺点：

a. 会产生多余的Builder对象以及Director对象，消耗内存；

b. 对象的构建过程暴露。