建造者模式代码举例(java语言版与go语言版)

前言：本来想写个有建造者、具体的建造者、监工等角色的建造者模式的。但是还是觉得举一个用户去快餐店点餐的例子更具普遍性。

JAVA语言版建造者模式

创建商品接口：

public interface Item {
    String name();

    Packing packing();

    float price();
}

创建商品包装接口：

public interface Packing {
    String pack();
}

创建商品包装实现类：

public class Bottle implements Packing {
    @Override
    public String pack() {
        return "瓶子";
    }
}

public class Wrapper implements Packing {
    @Override
    public String pack() {
        return "包装纸";
    }
}

创建实现商品接口的汉堡抽象类与冷饮抽象类：

public abstract class Burger implements Item {
    @Override
    public Packing packing() {
        return new Wrapper();
    }
}

public abstract class ColdDrink implements Item {
    @Override
    public Packing packing() {
        return new Wrapper();
    }
}

创建继承冷饮抽象类的百事可乐，可口可乐的实现类和创建继承汉堡抽象类的蔬菜汉堡，鸡肉汉堡实现类

public class Coke extends ColdDrink {
    @Override
    public String name() {
        return "可口可乐";
    }

    @Override
    public float price() {
        return 15.0f;
    }
}

public class Pepsi extends ColdDrink {
    @Override
    public String name() {
        return "百事可乐";
    }

    @Override
    public float price() {
        return 13.0f;
    }
}

public class ChickenBurger extends Burger {
    @Override
    public String name() {
        return "鸡肉汉堡";
    }

    @Override
    public float price() {
        return 30.0f;
    }
}

public class VegBurger extends Burger {
    @Override
    public String name() {
        return "蔬菜汉堡";
    }

    @Override
    public float price() {
        return 25.0f;
    }
}

创建套餐组合方式的类

public class Meal {
    private List<Item> items = new LinkedList<>();

    public void addItem(Item item) {
        items.add(item);
    }

    public float getCost() {
        float cost = 0.0f;
        for (Item item : items) {
            cost = cost + item.price();
        }
        return cost;
    }

    public void showItems() {
        for (Item item : items) {
            System.out.println("商品:" + item.name());
            System.out.println("包装:" + item.packing().pack());
            System.out.println("价钱:" + item.price() + "元");
        }
        System.out.println("一共："+getCost()+"元");
        System.out.println("");
    }
}

创建套餐选择类：

public class MealBuilder {
    public Meal prepareVegMeal() {
        Meal meal = new Meal();
        meal.addItem(new VegBurger());
        meal.addItem(new Coke());
        return meal;
    }

    public Meal prepareNonVegMeal() {
        Meal meal = new Meal();
        meal.addItem(new ChickenBurger());
        meal.addItem(new Pepsi());
        return meal;
    }
}

BuiderPatternDemo 使用 MealBuider 来演示建造者模式

public class BuilderPatternDemo {
    public static void main(String[] args) {
        MealBuilder mealBuilder = new MealBuilder();

        Meal vegMeal = mealBuilder.prepareVegMeal();
        vegMeal.showItems();

        Meal nonVegMeal = mealBuilder.prepareNonVegMeal();
        nonVegMeal.showItems();
    }
}

输出结果：

商品:蔬菜汉堡
包装:包装纸
价钱:25.0元
商品:可口可乐
包装:包装纸
价钱:15.0元
一共：40.0元

商品:鸡肉汉堡
包装:包装纸
价钱:30.0元
商品:百事可乐
包装:包装纸
价钱:13.0元
一共：43.0元

GO语言版建造者模式

创建商品接口：

type Item interface {
	Name() string;
	Packing() Packing;
	Price() float64;
}

创建包装接口：

type Packing interface {
	Pack() string
}

创建包装接口实现类：

type Bottle struct {
}

func (this *Bottle) Pack() string {
	return "瓶子"
}


type Wrapper struct {
}

func (this *Wrapper) Pack() string {
	return "包装纸"
}

创建实现商品接口的实现类

type Coke struct {
}

func (this *Coke) Name() string {
	return "可口可乐"
}

func (this *Coke) Packing() Packing {
	return &Bottle{}
}

func (this *Coke) Price() float64 {
	return 15.0

}


type Pepsi struct {
}

func (this *Pepsi) Name() string {
	return "百事可乐"
}

func (this *Pepsi) Packing() Packing {
	return &Bottle{}
}

func (this *Pepsi) Price() float64 {
	return 13.0
}


type ChickenBurger struct {
}

func (this *ChickenBurger) Name() string {
	return "鸡肉汉堡"
}

func (this *ChickenBurger) Packing() Packing {
	return &Wrapper{}
}

func (this *ChickenBurger) Price() float64 {
	return 30.0
}


type VegBurger struct {
}

func (this *VegBurger) Name() string {
	return "蔬菜汉堡"
}

func (this *VegBurger) Packing() Packing {
	return &Wrapper{}
}

func (this *VegBurger) Price() float64 {
	return 25.0
}

创建套餐组合方式的类

type Meal struct {
	Items []Item
}

func (this *Meal) AddItem(item Item) {
	this.Items = append(this.Items, item)
}

func (this *Meal) GetCost() float64 {
	cost := 0.0

	/*	for index,val:=range this.Items  {
			cost=val.Price()+cost
		}*/

	for i := 0; i < len(this.Items); i++ {
		cost = cost + this.Items[i].Price()
	}
	return cost
}

func (this *Meal) ShowItems() {
	for i := 0; i < len(this.Items); i++ {
		fmt.Println("商品", this.Items[i].Name())
		fmt.Println("包装", this.Items[i].Packing().Pack())
		fmt.Println("价钱", this.Items[i].Price(), "元")
	}
	fmt.Println("一共：", this.GetCost())
	fmt.Println("")

}

创建套餐选择类：

type MealBuilder struct {
}

func (this *MealBuilder) PrepareVegMeal() Meal {
	meal := Meal{}
	meal.AddItem(&VegBurger{})
	meal.AddItem(&Coke{})
	return meal
}

func (this *MealBuilder) PrepareNonVegMeal() Meal {
	meal := Meal{}
	meal.AddItem(&ChickenBurger{})
	meal.AddItem(&Pepsi{})
	return meal
}

BuiderPatternDemo 使用 MealBuider 来演示建造者模式

func main() {
	mealBuilder := builder.MealBuilder{}
	vegMeal := mealBuilder.PrepareNonVegMeal()
	vegMeal.ShowItems()

	nonVegMeal := mealBuilder.PrepareVegMeal()
	nonVegMeal.ShowItems()
}

输出结果：

商品 鸡肉汉堡
包装 包装纸
价钱 30 元
商品 百事可乐
包装 瓶子
价钱 13 元
一共： 43

商品 蔬菜汉堡
包装 包装纸
价钱 25 元
商品 可口可乐
包装 瓶子
价钱 15 元
一共： 40