建造者模式举例：去肯德基点餐，我们可以认为点餐就属于一个建造订单的过程。我们点餐的顺序是无关的，点什么东西也是没有要求的，可以单点，也可以点套餐，也可以套餐加单点，但是最后一定要点确认来完成订单。

public class OrderBuilder{
    private Burger mBurger;
    private Suit mSuit;

    //单点汉堡,num为数量
    public OrderBuilder burger(Burger burger， int num){
        mBurger = burger;
    }

    //点套餐，实际中套餐也可以点多份
    public OrderBuilder suit(Suit suit, int num){
    mSuit = suit;
    }

    //完成订单
    public Order build(){
        Order order = new Order();
        order.setBurger(mBurger);
        order.setSuit(mSuit);
        return order;
    }
}

另外适用于快速失败，在 build 时可以做校验，如果不满足必要条件，则可以直接抛出创建异常，在 OkHttp3 中的 Request.Builder 中就是这样用的。

public Request build() {  
    if (url == null) throw new IllegalStateException("url == null");  
    return new Request(this);
}

例如订单要求价格至少达到 30 块:

//完成订单
public Order build(){
    Order order = new Order();
    order.setBurger(mBurger);
    order.setSuit(mSuit);
    if(order.getPrice() < 30){
        throw new BuildException("订单金额未达到30元");
    }
    return order;
}

另外，在构建时如果有必传参数和可选参数，可以为 Builder 类添加构造函数来保证必传参数不会遗漏，例如在构建一个 http 请求时, url 是必传的:

public class RequestBuilder{
    private final String mUrl;
    private Map<String, String> mHeaders = new HashMap<String, String>();

    private RequestBuilder(String url){
        mUrl = url;
    }

    public static RequestBuilder newBuilder(String url){
        return new RequestBuilder(url);
    }

    public RequestBuilder addHeader(String key, String value){
        mHeaders.put(key, value);
    }

    public Request build(){
        Request request = new Request();
        request.setUrl(mUrl);
        request.setHeaders(mHeaders);
        return request;
    }
}

步骤 7可以拆开吧？

抽象建造者 1

public  class Builder {    
    public Meal meal = new Meal();    
    public void prepareVegMeal(){};    
    public void prepareNonVegMeal(){};    
    public Meal getMeal(){return null;
};

指挥者 2

public class Director {    
    public void Constuct(Builder builder){        
        builder.prepareVegMeal();        
        builder.prepareNonVegMeal();    
    }
}

具体的建造者

public class VegMealBuilder extends Builder{    
    public void prepareVegMeal() {        
        meal.addItem(new VegBurger());        
        meal.addItem(new Coke());
    }    
    public void prepareNonVegMeal() {    }    
    public Meal getMeal() {        
        return meal;    
    }
}

具体建造者

public class NonVegMealBuilder extends Builder {    
    @Override    
    public void prepareVegMeal() {    }    
    @Override    
    public void prepareNonVegMeal() {        
        meal.addItem(new ChickenBurger());        
        meal.addItem(new Pepsi());    
    }    
    @Override   
    public Meal getMeal() {        
        return meal;    
    }
}

调用

public class Test {    
    @Test    
    public void BuilderPatternDemo() {        
        Director director = new Director();        
        VegMealBuilder b1 = new VegMealBuilder();        
        NonVegMealBuilder b2 = new NonVegMealBuilder();        
        director.Constuct(b1);        
        director.Constuct(b2);        
        Meal vegMeal = b1.getMeal();        
        System.out.println("Veg Meal");        
        vegMeal.showItems();        
        System.out.println("Total Cost: " +vegMeal.getCost());        
        Meal nonVegMeal = b2.getMeal();        
        System.out.println("\n\nNon-Veg Meal");        
        nonVegMeal.showItems();       
        System.out.println("Total Cost: " +nonVegMeal.getCost());    
    }
}

最后应该是优化成 list（含有多参数）传入，上层组装meal套餐或者单点，这种灵活性更强吧。

C++ 方式：

#include <string>
#include <vector>
#include <iostream>

using namespace std;

class Packing {
    public:
        virtual string pack() {
            return "";
        };
};

class Item {
    public:
        virtual string name() {
            return "";
        };
        virtual Packing *packing() {
            return new Packing();
        };
        virtual float price() {
            return 0;
        };
};

class Wrapper: public Packing {
    public:
        string pack() {
            return "Wrapper";
        }
};

class Bottle: public Packing {
    public:
        string pack() {
            return "Bottle";
        }
};

class Burger: public Item {
    public:
        Packing *packing() {
            return new Wrapper();
        }
};

class ColdDrink: public Item {
    public:
        Packing *packing() {
            return new Bottle();
        }
};

class VegBurger: public Burger {
    public:
        float price() {
            return 25.0f;
        }

        string name() {
            return "Veg Burger";
        }
};

class ChickenBurger: public Burger {
    public:
        float price() {
            return 50.5f;
        }

        string name() {
            return "Chicken Burger";
        }
};

class Coke: public ColdDrink {
   public:
        float price() {
            return 30.0f;
        }

        string name() {
            return "Coke";
        }
};

class Pepsi: public ColdDrink {
   public:
        float price() {
            return 35.0f;
        }

        string name() {
            return "Pepsi";
        }
};

class Meal {
    private:
        vector<Item *> items;
    public:
        void addItem(Item *item) {
            items.push_back(item);
        }

        float getCost() {
            float cost = 0.0f;
            for (Item *item : items) {
                cost += item -> price();
            }
            return cost;
        }

        void showItems() {
            for (Item *item : items) {
                cout << "Item : " << item -> name() << ", Packing : "
                    << item -> packing() -> pack() << ", Price : ";
                printf("%.1f\n", item -> price());
            }
        }
};

class MealBuilder {
    public:
        Meal *prepareVegMeal() {
            Meal *meal = new Meal();
            meal -> addItem(new VegBurger());
            meal -> addItem(new Coke());
            return meal;
        }

        Meal *prepareNonVegMeal () {
            Meal *meal = new Meal();
            meal -> addItem(new ChickenBurger());
            meal -> addItem(new Pepsi());
            return meal;
        }
};

int main() {
    MealBuilder mealBuilder;

    Meal *vegMeal = mealBuilder.prepareVegMeal();
    cout << "Veg Meal" << endl;
    vegMeal -> showItems();
    cout << "Total Cost: " << vegMeal -> getCost() << endl;
    delete(vegMeal);

    Meal *nonVegMeal = mealBuilder.prepareNonVegMeal();
    cout << "\n\nNon-Veg Meal" << endl;
    nonVegMeal -> showItems();
    cout << "Total Cost: " << nonVegMeal -> getCost() << endl;
    delete(nonVegMeal);
}