23种设计模式：建造者模式
建造者模式
1.介绍
概念
建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
一个 Builder 类会一步一步构造最终的对象。该 Builder 类是独立于其他对象的。
主要作用
将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。
解决的问题
主要解决在软件系统中，有时候面临着"一个复杂对象"的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。
使用场景
1、需要生成的对象具有复杂的内部结构。
2、需要生成的对象内部属性本身相互依赖。
2.实现
java实现
1.创建食物条目接口
public interface Item {
public String name();
public Packing packing();
public float price();
}
2.创建食物包装接口
public interface Packing {
public String pack();
}
3.创建纸盒包装类
public class Wrapper implements Packing {
@Override
public String pack() {
return "Wrapper";
}
}
4.创建瓶子包装类
public class Bottle implements Packing {
@Override
public String pack() {
return "Bottle";
}
}
5.创建汉堡抽象类
public abstract class Burger implements Item {
@Override
public Packing packing() {
return new Wrapper();
}
@Override
public abstract float price();
}
6.创建冷饮抽象类
public abstract class ColdDrink implements Item {
@Override
public Packing packing() {
return new Bottle();
}
@Override
public abstract float price();
}
7.创建蔬菜汉堡类
public class VegBurger extends Burger {
@Override
public float price() {
return 25.0f;
}
@Override
public String name() {
return "Veg Burger";
}
}
8.创建鸡肉汉堡类
public class ChickenBurger extends Burger {
@Override
public float price() {
return 50.5f;
}
@Override
public String name() {
return "Chicken Burger";
}
}
9.创建可口可乐类
public class Coke extends ColdDrink {
@Override
public float price() {
return 30.0f;
}
@Override
public String name() {
return "Coke";
}
}
10.创建百事可乐类
public class Pepsi extends ColdDrink {
@Override
public float price() {
return 35.0f;
}
@Override
public String name() {
return "Pepsi";
}
}
11.创建菜单类
import java.util.ArrayList;
import java.util.List;
public class Meal {
private List<Item> items = new ArrayList<Item>();
public void addItem(Item item){
items.add(item);
}
public float getCost(){
float cost = 0.0f;
for (Item item : items) {
cost += item.price();
}
return cost;
}
public void showItems(){
for (Item item : items) {
System.out.print("Item : "+item.name());
System.out.print(", Packing : "+item.packing().pack());
System.out.println(", Price : "+item.price());
}
}
}
12.创建套餐类
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;
}
}
13.创建测试类，分别点了两种套餐
public class BuilderPatternDemo {
public static void main(String[] args) {
MealBuilder mealBuilder = new MealBuilder();
Meal vegMeal = mealBuilder.prepareVegMeal();
vegMeal.showItems();
System.out.println("Total Cost: " +vegMeal.getCost());
System.out.println("---------");
Meal nonVegMeal = mealBuilder.prepareNonVegMeal();
nonVegMeal.showItems();
System.out.println("Total Cost: " +nonVegMeal.getCost());
}
}
15.运行结果
golang实现
package BuilderPattern
import "fmt"
// Item 创建食物条目接口
type Item interface {
name() string
packing() Packing
price() float64
}
// Packing 创建食物包装接口
type Packing interface {
pack() string
}
// Wrapper 创建纸盒包装类
type Wrapper struct {}
func (*Wrapper) pack() string {
return "Wrapper"
}
// Bottle 创建瓶子包装类
type Bottle struct {}
func (*Bottle) pack() string {
return "Bottle"
}
// Burger 创建汉堡类
type Burger struct {
Item
}
func (*Burger) packing() Packing {
return &Wrapper{}
}
// ColdDrink 创建冷饮类
type ColdDrink struct {
Item
}
func (*ColdDrink) packing() Packing {
return &Bottle{}
}
// VegBurger 创建蔬菜汉堡类
type VegBurger struct {
Burger
}
func (*VegBurger) price() float64 {
return 25.0
}
func (*VegBurger) name() string {
return "Veg Burger"
}
// ChickenBurger 创建鸡肉汉堡类
type ChickenBurger struct {
Burger
}
func (*ChickenBurger) price() float64 {
return 50.5
}
func (*ChickenBurger) name() string {
return "Chicken Burger"
}
// Coke 创建可口可乐类
type Coke struct {
ColdDrink
}
func (*Coke) price() float64 {
return 30.0
}
func (*Coke) name() string {
return "Coke"
}
// Pepsi 创建百事可乐类
type Pepsi struct {
ColdDrink
}
func (*Pepsi) price() float64 {
return 35.0
}
func (*Pepsi) name() string {
return "Pepsi"
}
// Meal 创建菜单类
type Meal struct {
items []Item
}
func (m *Meal) addItem(item Item) {
m.items = append(m.items, item)
}
func (m *Meal) getCost() float64 {
cost := 0.0
for _, item := range m.items {
cost += item.price()
}
return cost
}
func (m *Meal) showItems() {
for _, item := range m.items {
fmt.Print("Item: ", item.name())
fmt.Print(", Packing: ", item.packing().pack())
fmt.Println(", Price: ", item.price())
}
}
// MealBuilder 创建套餐类
type MealBuilder struct {}
func (m *MealBuilder) prepareVegMeal() Meal {
meal := Meal{}
meal.addItem(&VegBurger{})
meal.addItem(&Coke{})
return meal
}
func (m *MealBuilder) prepareNonVegMeal() Meal {
meal := Meal{}
meal.addItem(&ChickenBurger{})
meal.addItem(&Pepsi{})
return meal
}
package BuilderPattern
import (
"fmt"
"testing"
)
func TestBuildPatternDemo(t *testing.T) {
mealBuilder := MealBuilder{}
vegMeal := mealBuilder.prepareVegMeal()
vegMeal.showItems()
fmt.Println("Total cost: ", vegMeal.getCost())
}
