建造者模式：通常用于创建一些复杂的对象，这些对象内部构建间的构建顺序通常稳定，但是对象内部的构建通常面临着复杂的变化

    优点：使得构建代码和表示代码分离，由于构建者隐藏了该产品是如何组装的，所以若要改变一个产品的内部表示，只需要再定义一个具体的构建者就可以了

    实现：假设需要构建一个产品，需要两个零件，但是零件的构成范围很宽泛
    1、产品类

    1. /**
    2.  * 产品类
    3.  */
    4. public class Product {
    5.     //零件
    6.     List<String> list = new ArrayList<>();
    8.     public void add(String element){
    9.         list.add(element);
    10.     }
    12.     public void builderProduct(){
    13.         System.out.print("构建一个产品，它的构成部件有：");
    14.         for (String element : list){
    15.             System.out.print(element+"    ");
    16.         }
    17.         System.out.println("");
    18.     }
    19. }

    2、建造类

    1. /**
    2.  * 建造者抽象类（必须有两个零件）
    3.  */
    4. public abstract class Builder {
    5.     /**
    6.      * 零件一
    7.      */
    8.     public abstract void elementOne();
    10.     /**
    11.      * 零件二
    12.      */
    13.     public abstract void elementTwo();
    15.     /**
    16.      * 获取产品
    17.      */
    18.     public abstract Product getProduct();
    19. }
    21. /**
    22.  * 建造者具体实现类1
    23.  */
    24. public class CreateBuilderOne extends Builder{
    25.     Product product = new Product();
    26.     public void elementOne(){
    27.         product.add("零件a");
    28.     }
    30.     public void elementTwo(){
    31.         product.add("零件b");
    32.     }
    34.     public Product getProduct(){
    35.         return product;
    36.     }
    37. }
    39. /**
    40.  * 建造者具体实现类2
    41.  */
    42. public class CreateBuilderTwo extends Builder{
    43.     Product product = new Product();
    44.     public void elementOne(){
    45.         product.add("零件x");
    46.     }
    48.     public void elementTwo(){
    49.         product.add("零件y");
    50.     }
    52.     public Product getProduct(){
    53.         return product;
    54.     }
    55. }

    3、指挥者

    1. /**
    2.  * 指挥者
    3.  */
    4. public class Director {
    5.     public void construct(Builder builder){
    6.         builder.elementOne();
    7.         builder.elementTwo();
    8.     }
    9. }

    4、测试类

    1. /**
    2.  * 测试建造者模式
    3.  */
    4. public class TestBuilder {
    5.     public static void main(String [] args){
    6.         Director director = new Director();
    7.         CreateBuilderOne one = new CreateBuilderOne();
    8.         CreateBuilderTwo two = new CreateBuilderTwo();
    10.         director.construct(two);
    11.         Product product = two.getProduct();
    12.         product.builderProduct();
    13.     }
    14. }

    测试结果：
    image.png

    建造者模式是当创建复杂对象的算法，应该独立与该对象的组成部分以及它的装配方式时需要用到的模式