参考文章：
java设想形式之制作者形式

一、什么是制作者形式
制作者形式：是将一个庞杂的对象的构建与它的示意星散，使得一样的构建历程能够建立差别的示意。
工场类形式供应的是建立单个类的形式，而制作者形式则是将种种产品集合起来举行治理，用来建立复合对象，所谓复合对象就是指某个类具有差别的属性。

详细表现为4个角色
产品（Product）：制作的产品
导演（Director）：批示制作的历程，不触及制作的细节
制作者（Builder）：笼统制作历程，划定产品哪些部份须要建立
详细制作者（ConceteBuilder）：完成Builder，完成产品各个部份的制作，并供应产品

运用场景：
须要天生的对象有庞杂的内部结构，且各部份都邑依据需求发作组装变化
瑕玷：
1、当产品内部非常庞杂，须要用大批的详细制作者，致使体系巨大
2、产品要有共同点，局限受限制

下面举个例子：肯德基点餐环节，角色对应离别以下
Product：一餐食品（Meal）
Director：前台销售员（Seller）
Builder：笼统制作者（Builder）
ConceteBuilder：厨师（Cook）

起首完成一些食品

// Food 食品笼统类
class Food {
    constructor() {
        this.name = null;
        this.price = null;
    }
}
// 汉堡
class Burger extends Food {
    constructor() {
        super();
        this.name = '汉堡';
        this.price = 16;
    }
}
// 鸡翅
class ChickenWing extends Food {
    constructor() {
        super();
        this.name = '鸡翅';
        this.price = 12;
    }
}
// 可乐
class Coke extends Food {
    constructor() {
        super();
        this.name = '可乐';
        this.price = 6;
    }
}

产品Product
一桌餐饭能够有恣意数目的恣意组合

// Product
class Meal {
    constructor() {
        this.foods = [];
    }
    
    addFood(item) {
        this.foods.push(item);
    }
    showPrice() {
        var i = this.foods.length,
            price = 0;
        while(i--) {
            price += this.foods[i].price;
        }

        return price;
    }
}

笼统制作类Builder
范例各部份的制作

// Builder
class Builder {
    cookBurger() {}
    cookWing() {}
    cookCoke() {}
    finishCook() {}
}

详细制作类
厨师担任各个食品的烹调，并添加到meal里

// ConceteBuilder
class Cook extends Builder {
    constructor() {
        super();
        this.meal = new Meal();
    }

    cookBurger(number) {
        for (var i = 0; i < number; i++) {
            this.meal.addFood(new Burger());
        }
    }
    cookWing(number) {
        for (var i = 0; i < number; i++) {
            this.meal.addFood(new ChickenWing());
        }
    }
    cookCoke(number) {
        for (var i = 0; i < number; i++) {
            this.meal.addFood(new Coke());
        }
    }
    finishCook() {
        return this.meal;
    }
}

导演Director
担任关照厨房须要烹调啥啥啥。

// Director
class Seller {
    constructor() {
        this.builder = null;
    }

    bindCook(builder) {
        this.builder = builder;
    }
    placeOrder(burgerAmount, wingAmount, cokeAmount) {
        this.builder.cookBurger(burgerAmount);
        this.builder.cookWing(wingAmount);
        this.builder.cookCoke(cokeAmount);

        var meal = this.builder.finishCook();
        console.log('总价：' + meal.showPrice());
        return meal;
    }
}

末了模仿一次下单场景

var seller = new Seller();
var cook = new Cook();
seller.bindCook(cook);
seller.placeOrder(1, 2, 3); // 58

总结：
易于解耦
将产品自身与产品建立历程举行解耦，能够运用雷同的建立历程来获得差别的产品。也就说细节依靠笼统。
易于准确掌握对象的建立
将庞杂产品的建立步骤剖析在差别的要领中，使得建立历程越发清楚
易于拓展
增添新的详细制作者无需修正原有类库的代码，易于拓展，相符“开闭准绳“。