建造者模式，又称生成器模式：将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。

三个角色：建造者、具体的建造者、监工、使用者（严格来说不算）

• 建造者角色：定义生成实例所需要的所有方法；
• 具体的建造者角色：实现生成实例所需要的所有方法，并且定义获取最终生成实例的方法；
• 监工角色：定义使用建造者角色中的方法来生成实例的方法；
• 使用者：使用建造者模式。

注意：定义中“将一个复杂的构建过程与其表示相分离”，表示并不是由建造者负责一切，而是由监工负责控制（定义）一个复杂的构建过程，由各个不同的建造者分别负责实现构建过程中所用到的所有构建步骤。不然，就无法做到“使得同样的构建过程可以创建不同的表示”这一目标。

建造者角色：

public abstract class Builder {
    public abstract void buildPart1();
    public abstract void buildPart2();
    public abstract void buildPart3();
}

监工角色：

public class Director {    // 将一个复杂的构建过程与其表示相分离
    private Builder builder;    // 针对接口编程，而不是针对实现编程
    public Director(Builder builder) {
        this.builder = builder;
    }
    public void setBuilder(Builder builder) {
        this.builder = builder;
    }

    public void construct() {   // 控制（定义）一个复杂的构建过程
        builder.buildPart1();
        for (int i = 0; i < 5; i++) {   // 提示：如果想在运行过程中替换构建算法，可以考虑结合策略模式。
            builder.buildPart2();
        }
        builder.buildPart3();
    }
}

具体的建造者角色：

/**
 * 此处实现了建造纯文本文档的具体建造者。
 * 可以考虑再实现一个建造HTML文档、XML文档，或者其它什么文档的具体建造者。
 * 这样，就可以使得同样的构建过程可以创建不同的表示
 */
public class ConcreteBuilder1 extends Builder {
  private StringBuffer buffer = new StringBuffer();//假设 buffer.toString() 就是最终生成的产品

    @Override
    public void buildPart1() {//实现构建最终实例需要的所有方法
        buffer.append("Builder1 : Part1\n");
    }

    @Override
    public void buildPart2() {
        buffer.append("Builder1 : Part2\n");
    }

    @Override
    public void buildPart3() {
        buffer.append("Builder1 : Part3\n");
    }
    
    public String getResult() {//定义获取最终生成实例的方法
        return buffer.toString();
    }
}

客户角色：

public class Client {
    public void testBuilderPattern() {
        ConcreteBuilder1 b1 = new ConcreteBuilder1();//建造者
        Director director = new Director(b1);//监工
        director.construct();//建造实例(监工负责监督，建造者实际建造)
        String result = b1.getResult();//获取最终生成结果
        System.out.printf("the result is :%n%s", result);
    }
}

Python 方式：

from abc import abstractmethod,ABCMeta

# 创建一个表示食物条目和食物包装的接口
class Item(metaclass=ABCMeta):
    @abstractmethod
    def myName(self):
        pass
    @abstractmethod
    def packing(self):
        pass
    @abstractmethod
    def price(self):
        pass

class Packing(metaclass=ABCMeta):
    @abstractmethod
    def pack(self):
        pass

# 实现Packing接口的实体类
class Wrapper(Packing):
    def pack(self):
        return "Wrapper"
class Bottle(Packing):
    def pack(self):
        return "Bottle"

# 实现Item接口的抽象类
class Burger(Item):
    def packing(self):
        return Wrapper()
    @abstractmethod
    def price(self):
        pass

class ColdDrink(Item):
    def packing(self):
        return Bottle()
    @abstractmethod
    def price(self):
        pass

# 创建扩展了Burger和ColdDrink的实体类
class VegBurger(Burger):
    def price(self):
        return 25.0
    def myName(self):
        return "Veg Burger"

class ChickenBurger(Burger):
    def price(self):
        return 50.5
    def myName(self):
        return "Chicken Burger"

class Coke(ColdDrink):
    def price(self):
        return 30.0
    def myName(self):
        return "Coke"

class Pepsi(ColdDrink):
    def price(self):
        return 35.0
    def myName(self):
        return "Pepsi"

# 设计一个Meal类，带有上面定义的对象
class Meal():
    __items = []
    
    #注意初始化，否则类变量会被重用
    def __init__(self):
        self.__items = []

    def addItem(self, aItem):
        self.__items.append(aItem)

    def getCost(self):
        mySum = 0
        for myCost in self.__items:
            mySum = mySum + myCost.price()
        return mySum

    def showItems(self):
        for myItem in self.__items:
            print("Item : %s , Packing : %s , Price : %5.2f" %(myItem.myName(), myItem.packing().pack(), myItem.price()))

# 设计一个MealBuilder类，负责创建Meal对象
class MealBuilder():
    def prepareVegmeal(self):
        meal = Meal()
        meal.addItem(VegBurger())
        meal.addItem(Coke())
        return meal

    def prepareNonVegMeal(self):
        meal = Meal()
        meal.addItem(ChickenBurger())

        meal.addItem(Pepsi())
        return meal

# 输出
if __name__ == '__main__':
    mealBuilder = MealBuilder()

    vegMeal = mealBuilder.prepareVegmeal()
    print("Veg Meal")
    vegMeal.showItems()
    print("Total Cost : %5.2f"  %vegMeal.getCost())

    nonVegMeal = mealBuilder.prepareNonVegMeal()
    print("\n\nNon-Veg Meal")
    nonVegMeal.showItems()
    print("Total Cost : %5.2f" %(nonVegMeal.getCost()))