创建型模式之建造者模式（Builder）

建造者模式：

              将一个复杂对象的构建和它的表示分离，使得同样的构建过程可以创建不同的表示。“复杂对象的构建和它的表示分离”可以理解为一台电脑，无论使用

       任何品牌的零部件，只要能正常安装即可，“同样的构建过程可以创建不同的表示。”可以理解为同样的部件可采取多种安装方式。

       建造者模式由以下4个部件构成：

       Builder（抽象构建者角色）：为创建一个Product对象的各个部件指定抽象接口。
       ConcreteBuilder(具体建造者角色)：实现Builder接口以构建和装配产品的各个部件。
       Director（导演者角色）:构造一个使用Builder接口的对象。
       Product(产品对象)：表示被构建的复杂对象，ConcreteBuilder创建该产品的内部表示并定义它的装配过程。包含定义组成部分的类，包括将这些部件装配成最终

       产品的接口。

实例：西门子冰箱制造厂升级，有厂长策划，技术工人改装新的压缩机。
西门子导演者

public class SiemensDirector
{
    WasherBuilder builder;
    public SiemensDirector(WasherBuilder builder)
    {
        this.builder = builder;
    }
    
    public void conctruct()
    {
        builder.buildWasherSkeleton();
        builder.buildWasherEngine();
        builder.buildWasherWheels();
        builder.buildWasherBody();
    }
}

建造冰箱的框架

public interface WasherBuilder
{
    public void buildWasherSkeleton();//框架
    
    public void buildWasherEngine();//压缩机
    
    public void buildWasherWheels();//轮子

    public void buildWasherBody();//冰箱门

}

具体建造者

public class SiemensWasherBuilder implements WasherBuilder
{
public SiemensWasher washer = new  SiemensWasher();
    public void buildWasherSkeleton()
    {
        washer.setWasherSkeleton("冰箱框架");
    }
    public void buildWasherEngine()
    {
        Compressor compressor = new Compressor("新型压缩机");
        washer.setWasherEngine(compressor);
    }
    
    public void buildWasherWheels()
    {
        washer.setWasherWheels("冰箱轮子");
    }
    public void buildWasherBody()
    {
        washer.setWasherDoor("冰箱门");
        washer.setWasherColor("银白色");
    }
    public SiemensWasherBuilder retrieveWasher()
    {
        return washer;
    }

}

西门子冰箱

public class SiemensWasher
{
    private String washerSketon;
    private String washerColor;
    private String washerDoor;
    private String washerWheels;
    private Compressor washerEngine;
    public void setWasherSkeleton(String washerSketon)
    {
        this.washerSketon=washerSketon;
    }
    public void setWasherColor(String washercolor)
    {
        this.washercolor=washercolor;
    }
    public void setWasherDoor(String washerDoor)
    {
        this.washerDoor=washerDoor;
    }
    public void setWasherWheels(String washerWheels)
    {
        this.washerWheels=washerWheels;
    }public void setWasherEngine(Compressor washerEngine)
    {
        this.washerEngine=washerEngine;
    }
    public String toString()
    {
        return washerSketon+","+washerColor+","+washerDoor+","+washerWheels+","+washerEngine.toString();
    }
}

一个部件对象（压缩机）冰箱的核心

public class Compressor
{
    private String name;
    public void setName(String name)
    {
        this.name =name;
    }
    public String toString()
    {
        return this.name;
    }
}

测试类

public class TestBuilder
{
    public static void main(String[] args)
    {
        WasherBuilder builder = new SiemensWasherBuilder();//创建一个builder对象
        SiemensDirector director =new SiemensDirector(builder);//创建一个导演者，并为它配置一个builder
        director.conctruct();//导演者通知builder去创建产品，在这个过程中builder将会根据导演者的要求，去创建组织并创建产品对象。
        SiemensWasherBuilder siemensWasher = builder.retrieveWasher();//从具体创建者中得到具体产品。
    }

}

优势：
        客户端无需了解产品内部情况。
        通过新的具体构建者，即可改变产品的内部结构。
        四个角色相互独立，具备高扩展性。
        通过对建造过程的细化，可降低项目维护的风险。
  适用场景：
        产品对象有一个较复杂的内部结构，并且其具体的构建方法面临变化时，
        产品类的构建过程中，可使被构造的对象有不同的表现，
        创建对象时，需要调用软件对象的其他对象。