定义：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
    一共可分为四个角色：产品类（可抽象）、抽象建造者、建造者、导演类
    建造者模式 - 图1
    产品类：一般是一个复杂的对象，可以抽象。

    2. /**
    3.  * 产品类
    4.  */
    5. public class Phone {
    7.     private String name;
    9.     private int size;
    11.     private BigDecimal price;
    13.     public String getName() {
    14.         return name;
    15.     }
    17.     public void setName(String name) {
    18.         this.name = name;
    19.     }
    21.     public int getSize() {
    22.         return size;
    23.     }
    25.     public void setSize(int size) {
    26.         this.size = size;
    27.     }
    29.     public BigDecimal getPrice() {
    30.         return price;
    31.     }
    33.     public void setPrice(BigDecimal price) {
    34.         this.price = price;
    35.     }
    37.     @Override
    38.     public String toString() {
    39.         return "Phone{" +
    40.                 "name='" + name + '\'' +
    41.                 ", size=" + size +
    42.                 ", price=" + price +
    43.                 '}';
    44.     }
    45. }

    抽象建造者：是一个抽象类，制定创建对象和返回对象的抽象方法，由子类具体实现如何创建、创建什么对象。

    1. /**
    2.  * 抽象建造者
    3.  */
    4. public abstract class BuilderPhone {
    6.     public abstract void setFiled(String name, int size, BigDecimal price);
    8.     public abstract Phone createPhone();
    10. }

    建造者：抽象建造者的具体实现，来构建对象，返回对象。

    1. /**
    2.  * 建造者
    3.  */
    4. public class CreatePhone extends BuilderPhone{
    6.     private Phone phone;
    9.     @Override
    10.     public void setFiled(String name, int size, BigDecimal price) {
    11.         phone=new Phone();
    12.         phone.setName(name);
    13.         phone.setSize(size);
    14.         phone.setPrice(price);
    15.     }
    17.     @Override
    18.     public Phone createPhone() {
    19.         return phone;
    20.     }
    21. }

    导演者：负责利用建造者来创建想要的对象。

    1. /**
    2.  * 导演类
    3.  */
    4. public class Director {
    5.     private BuilderPhone builderPhone = new CreatePhone();
    7.     public Phone getXiaoMi(){
    8.         builderPhone.setFiled("小米手机",6,new BigDecimal("2998"));
    9.         return builderPhone.createPhone();
    10.     }
    12.     public Phone getIPhone(){
    13.         builderPhone.setFiled("苹果手机",6,new BigDecimal("12998"));
    14.         return builderPhone.createPhone();
    15.     }
    18.     public static void main(String[] args) {
    19.         Director director = new Director();
    20.         System.out.println(director.getXiaoMi());
    21.         System.out.println(director.getIPhone());
    22.     }
    25. }

    建造者模式的优点
    首先，建造者模式的封装性很好。使用建造者模式可以有效的封装变化，在使用建造者模式的场景中，一般产品类和建造者类是比较稳定的，因此，将主要的业务逻辑封装在导演类中对整体而言可以取得比较好的稳定性。
    其次，建造者模式很容易进行扩展。如果有新的需求，通过实现一个新的建造者类就可以完成，基本上不用修改之前已经测试通过的代码，因此也就不会对原有功能引入风险。
    建造者模式与工厂模式的区别
    我们可以看到，建造者模式与工厂模式是极为相似的，总体上，建造者模式仅仅只比工厂模式多了一个”导演类”的角色。在建造者模式的类图中，假如把这个导演类看做是最终调用的客户端，那么图中剩余的部分就可以看作是一个简单的工厂模式了。
    与工厂模式相比，建造者模式一般用来创建更为复杂的对象，因为对象的创建过程更为复杂，因此将对象的创建过程独立出来组成一个新的类——导演类。也就是说，工厂模式是将对象的全部创建过程封装在工厂类中，由工厂类向客户端提供最终的产品；而建造者模式中，建造者类一般只提供产品类中各个组件的建造，而将具体建造过程交付给导演类。由导演类负责将各个组件按照特定的规则组建为产品，然后将组建好的产品交付给客户端。