建造者模式

1.建造者模式简介

建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。这种类型的设计模式属于创建型模式，它提供了一种创
建对象的最佳方式。一个 Builder 类会一步一步构造最终的对象。该 Builder 类是独立于其他对象的。

意图：将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。
主要解决：主要解决在软件系统中，有时候面临着"一个复杂对象"的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变
化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。
何时使用：一些基本部件不会变，而其组合经常变化的时候。
如何解决：将变与不变分离开。

优点：(1)建造者独立，易扩展。(2)便于控制细节风险。
缺点：(1)产品必须有共同点，范围有限制。 (2)如内部变化复杂，会有很多的建造类。
使用场景：(1)需要生成的对象具有复杂的内部结构。 (2)需要生成的对象内部属性本身相互依赖。

注意事项：与工厂模式的区别是：建造者模式更加关注与零件装配的顺序。

2.创建者模式Demo
去肯德基，汉堡、可乐、薯条、炸鸡翅等是不变的，而其组合是经常变化的，生成出所谓的"套餐"。

继承关系图：

import java.util.ArrayList;
import java.util.List;

interface Packing {
    public String pack();
}

class Wraper implements Packing {
    public String pack() {
        return "Wraper";
    }
}

class Bottle implements Packing {
    public String pack() {
        return "Bottle";
    }
}

interface Item {
    public String name();
    public Packing pack();
    public float price(); 
}


abstract class Burger implements Item {
    @Override
    public Packing pack() {
        return new Wraper(); //效果是什么？
    }
}

class VegBurger extends Burger {
    @Override
    public String name() {
        return "VegBurger";
    }
    @Override
    public float price() {
        return 30.0f;
    }
}

class NonVegBurger extends Burger {
    @Override
    public String name() {
        return "NonVegBurger";
    }
    @Override
    public float price() {
        return 38.0f;
    }
}

abstract class ColdDrink implements Item {
    @Override
    public Packing pack() {
        return new Bottle(); //效果是什么？
    }
}

class Coke extends ColdDrink {
    @Override
    public String name() {
        return "Coke";
    }
    @Override
    public float price() {
        return 5.0f;
    }
}

class Pepsi extends ColdDrink {
    @Override
    public String name() {
        return "Pepsi";
    }
    @Override
    public float price() {
        return 6.0f;
    }
}


class Meal {
    private ArrayList<Item> items = new ArrayList<Item>();

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

    public float mealPrice() {
        float totalPrice = 0.0f;
        for (Item i : items) {
            totalPrice += i.price();
        }
        return totalPrice;
    }

    public String mealItemList() {
        String s = "";
        for (Item i : items) {
            s += "Name: ";
            s += i.name();
            s += ", Packing: ";
            s += i.pack().pack(); /*i.pack()返回的是Wraper类对象*/
            s += ", Price: ";
            s += i.price();
            s += "\n";
        }
        return s;
    }
}

class MealBuilder {
    public static Meal perpareVegMeal() {
        Meal meal = new Meal();
        meal.addItem(new VegBurger()); /*VegBurger是Item类的孙子，同样能表现出多态*/
        meal.addItem(new Coke());
        meal.addItem(new Pepsi()); /*若这个套餐中又加了一杯百世可乐，直接在这里加上一行即可。*/
        return meal;
    }
    public static Meal perpareNonVegMeal() {
        Meal meal = new Meal();
        meal.addItem(new NonVegBurger());
        meal.addItem(new Pepsi());
        return meal;
    }
}

public class BuilderPatternDemo {
    public static void main(String args[]) {
        Meal meal1 = MealBuilder.perpareVegMeal();
        System.out.print(meal1.mealItemList());
        System.out.println("TotalPrice: " + meal1.mealPrice());

        Meal meal2 = MealBuilder.perpareNonVegMeal();
        System.out.print(meal2.mealItemList());
        System.out.println("TotalPrice: " + meal2.mealPrice());
    }

}

/*
执行结果：
Name: VegBurger, Packing: Wraper, Price: 30.0
Name: Coke, Packing: Bottle, Price: 5.0
Name: Pepsi, Packing: Bottle, Price: 6.0
TotalPrice: 41.0
Name: NonVegBurger, Packing: Wraper, Price: 38.0
Name: Pepsi, Packing: Bottle, Price: 6.0
TotalPrice: 44.0
*/

 

 

参考：http://www.runoob.com/design-pattern/builder-pattern.html