引出建造者模式：

package com.disign.build;

/**
 * Created by zhen on 2017-05-19.
 */
public class BuildPersonTest {
    /**
     * 吃面，面的口味與廚師的心情等關聯引出：
     *  抽象不應該依賴於細節，細節應該依賴於抽象，吃的菜不能依賴於廚師的細節。
     *  構建小人
     *  防止哪次構建的時候小人少了哪個必要組件，應該使用抽象繼承
     */
    public static void main(String[] args){

        Person thin 
 
= BuildPerson.build(new ThinPerson());
        Person fat = BuildPerson.build(new FatPerson());
    }

}
class BuildPerson{

    public static Person build(Person person){
        person.buildHead();
        person.buildBody();
        person.buildArmLeft();
        person.buildArmRight();
        person.buildLegLeft();
        person.buildLegRight();
        
 
return person;
    }

}
abstract class Person{
   abstract void buildHead();
   abstract void buildBody();
   abstract void buildArmLeft();
   abstract void buildArmRight();
   abstract void buildLegLeft();
   abstract void buildLegRight();
}
class FatPerson extends Person{
    @Override
    void buildHead() {

    }

    @Override
    
 
void buildBody() {

    }

    @Override
    void buildArmLeft() {

    }

    @Override
    void buildArmRight() {

    }

    @Override
    void buildLegLeft() {

    }

    @Override
    void buildLegRight() {

    }
}
class ThinPerson extends Person{
    @Override
    void buildHead() {

    }

    @Override
    void buildBody() {

    }

    @Override
    void buildArmLeft() {

    }

    @Override
    void buildArmRight() {

    }

    @Override
    void buildLegLeft() {

    }

    @Override
    void buildLegRight() {

    }
}

我們上面的代碼就用到了建造者模式。

建造小人的過程是穩定的，都需要頭身手腳，具體建造的細節不同，有高矮胖瘦。但是對於用戶而言，我只告訴你，我需要一個胖小人，我們應該在保證一個正常人的前提下對人的細節進行修飾。

如果你需要將一個復雜對象的構建與它的表示分離，使得同樣的構建過程可以創建不同的表示意圖的時候，我們可以使用建造者模式，又叫生成器模式。如果我們用了建造者模式，用戶只需要指定需要建造的類型就可以得到他們，具體的建造的過程和細節就不需要知道了。

建造者模式Builder，將一個復雜對象的構建與它的表示分離，使得同樣的構建過程可以創建不同的表示

圖中Builder是什麽？

為創建一個Product對象各個部件指定的抽象接口。

ConcreteBuilder是什麽？

具體創造的，實現Builder接口，構造和裝配各個部件。

Product是什麽？

具體的小人，產品角色。

Director是什麽？

指揮者，用來根據用戶需求構建小人對象，是一個使用Builder接口的對象

什麽時候使用構建者模式呢？

用於創建一些復雜的對象，這些對象內部構建之間的構造順序通常是非常穩定的，單對象內部的構建通常面臨著復雜的變化

構造者模式的好處就是使得構造代碼與表示代碼分離，由於構造者隱藏了該產品是如何組裝的，所以弱需要改變一個產品的內部表示，只需要再定一個具體的建構者就可以了。

基本代碼：

public class BuildProductTest {
    public static void main(String[] args){
        Director director = new Director();
        BuilderProduct builderProduct1 = new ConcreteBuilder1();
        BuilderProduct builderProduct2 = new ConcreteBuilder2();
        
        director.construct(builderProduct1);
        Product p1 = builderProduct1.getResult();
        p1.show();

        director.construct(builderProduct2);
        Product p2 = builderProduct2.getResult();
        p2.show();
    }
}
class Product{
    List<String> parts = new ArrayList<String>();
    public void add(String part){
        parts.add(part);
    }
    public void show(){
        for (String part: parts) {
            System.out.println(part);
        }
    }
}
abstract class BuilderProduct{
        public abstract void buildPartA();
        public abstract void buildPartB();
        public abstract Product getResult();
}
class ConcreteBuilder1 extends BuilderProduct{
    @Override
    public void buildPartA() {

    }

    @Override
    public void buildPartB() {

    }

    @Override
    public Product getResult() {
        return null;
    }
}
class ConcreteBuilder2 extends BuilderProduct{
    @Override
    public void buildPartA() {
        
    }

    @Override
    public void buildPartB() {

    }

    @Override
    public Product getResult() {
        return null;
    }
}
class Director{
    public void construct(BuilderProduct builder){
        builder.buildPartA();
        builder.buildPartB();
    }
}

建構者模式是在當創建復雜對象的算法應該獨立於該對象的組成以及它們的裝配方式時使用的模式。

建造者模式 build