Builder模式是一步一步创建一个复杂对象的创建型模式。该模式是为了将构建复杂对象的过程和他的部件解耦，使得构建过程和部件的表示隔离开来。

Builder模式 主要用于“构建一个复杂的对象”。把复杂对象的创建过程加以抽象，通过子类继承和重写方法，来得到具有复合属性的对象。

同时为了统一创建过程，把对象的创建操作统一封装到Director的方法中。
由于一个复杂对象的单个属性可能会发生变化（例如：制造汽车时使用的某一部件属于不同的厂家）但是整个复杂对象的构建过程却不会发生变化（例如：汽车的构建图纸已经固定，只需要把部件按照图纸装配好）

将一个复杂对象的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。即构建过程相同，但是子部件却不相同。

抽象工厂注重的是不同的工厂生产不同的产品，builder注重的是某个产品由不同的零件组成，产品的生产工程。
Director就是负责产品组装的，是控制生产过程的；而builder是负责产品部件生产的。这样就实现了“过程”和“部件”的解耦。
抽象工厂通过不同的构建过程生成不同的对象表示，而Builder模式通过相同的构建过程生成不同的表示。

UML图：

生活中的例子：计算机的组装过程简化为构建主机，设置操作系统，设置显示器3个部分，然后通过Director类和具体的Builder来构建计算机对象

Computer.java

package com.hust.builder;
//计算机抽象类，即Product角色
public abstract class Computer {
      protected String mBoard;
      protected String mDisplay;
      protected String mOs;

      protected Computer(){};
      //设置CPU核心数
      public void setBoard(String board) {
          mBoard=board;
      }
      //设置内存
      public void setDisplay(String display){
          mDisplay=display;
      }
      //设置操作系统
      public abstract void setOs();

      public String toString(){
        return "Computer[mBoard="+mBoard+",mDisplay="+mDisplay+",mOs="+mOs+"]";  
      }
}

MacBook.java

package com.hust.builder;
//具体的Computer类，Macbook
public class MacBook extends Computer {

    public void setOs() {
         mOs="Mac OS X 10.10";
    }

}

Builder.java

//抽象Builder类
public abstract class Builder {
       //必须有建造部件的方法
      public abstract void buildBoard(String board) ;
      public abstract void buildDisplay(String display) ;
      public abstract void buildOS();
      //必须有获得结果对象的方法
      public abstract Computer create() ;
} 

MacBookBuilder.java

package com.hust.builder;
//具体Builder类，MacbookBuilder
public class MacBookBuilder extends Builder {
    private Computer mComputer=new MacBook();//被构造对象作为具体Builder的成员变量

    //以下三种方法，是构建对象的部分或者零件
    public void buildBoard(String board) {
        mComputer.setBoard(board);
    }

    public void buildDisplay(String display) {
        mComputer.setDisplay(display);
    }

    public void buildOS() {
        mComputer.setOs();
    }

    public Computer create() {      
        return mComputer;
    }

}

Director.java

package com.hust.builder;
//Director类，负责构造Computer
public class Director {
     Builder mBuilder=null;//把构建器作为成员变量
     public Director(Builder mBuilder){
         this.mBuilder=mBuilder;
     }
     //封装构建过程
     public void construct(String board,String display) {
        mBuilder.buildBoard(board);
        mBuilder.buildDisplay(display);
        mBuilder.buildOS();
    }
}

1，builder抽象类必须要有建造部件的方法和获得结果对象的方法

2，builder具体类必须是对象结果作为成员变量

3，Director的类必须有一个construct方法封装构造过程

在实际开发中，Director角色经常被省略，直接使用一个Builder来进行对象的主机组装，这个Builder通常为链是调用，它的关键点是setter方法都会返回自身，就是return this

MacBookBuilder.java

package com.hust.builder2;
//具体Builder类，MacbookBuilder
public class MacBookBuilder {
    private Computer mComputer=new MacBook();//被构造对象作为具体Builder的成员变量

    //以下三种方法，是构建对象的部分或者零件
    public MacBookBuilder buildBoard(String board) {
        mComputer.setBoard(board);
        return this;
    }

    public MacBookBuilder buildDisplay(String display) {
        mComputer.setDisplay(display);
        return this;
    }

    public MacBookBuilder buildOS() {
        mComputer.setOs();
        return this;
    }

    public Computer create() {      
        return mComputer;
    }

}

test.java

package com.hust.builder2;

public class TestBuilder2 {

    /**
     *计算机的组装过程简化为构建主机，设置操作系统，设置显示器3个部分，然后通过Director类和具体的Builder来构建计算机对象
     */
    public static void main(String[] args) {
        //构建器，是为了构建对象的零件
        MacBookBuilder mBuilder=new MacBookBuilder();


       //在实际开发中，Director角色经常被省略，直接使用一个Builder来进行对象的主机组装，这个Builder通常为链是调用，它的关键点事setter方法都会返回自身，他、也就是return this     
         ;
       System.out.println(mBuilder.buildBoard("因特尔主板").buildDisplay("AOC显示器").buildOS().create().toString());
       //System.out.println(mBuilder.create().toString());

    }

}