建造者模式

理解

提取出一个接口中，经常变的，不经常变得，不变的。通过抽象类将这个接口中的方法实现，不经常变的方法，就新建几个类，在抽象类中写定返回参数，经常变得，就将这个方法抽象出来。最后新建一个匹配的对象继承这个抽象类，然后将其经常变的方法和很少变的方法进行实现。（在这之前觉得像策略模式），然后建造一个容器类，将新建的对象丢入到容器类中。

Item.java

package BuildPattern.FactoryPattern.BuildPatter;


/**
 * 每一种食物的条目
 */
public interface Item {

    public String name();//经常变的方法（吃的名字）

    public Packing pack();//只有2种的返回（吃的打包方式） 只有2种 盒子和袋子

    public float price();//经常变  价格
}

Packing.java

package BuildPattern.FactoryPattern.BuildPatter;


/**
 * 打包方式
 */
public interface Packing  {
    String pack();
}

Wrapper.java

package BuildPattern.FactoryPattern.BuildPatter;

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

Bottle.java

package BuildPattern.FactoryPattern.BuildPatter;

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

Hurber.java

package BuildPattern.FactoryPattern.BuildPatter;


/**
 *汉堡包类，统一是纸盒包装的，价格不一样
 */
public  abstract class Hurber implements Item{

    public Packing pack() {
        return new Wrapper();
    }

    public abstract float price();
}

ColdDrink.java

package BuildPattern.FactoryPattern.BuildPatter;


/**
 * 冷饮类是杯子包装的，价格不一样
 */
public abstract class ColdDrink implements Item {

    public Packing pack(){
        return new Bottle();
    }

    public abstract float price();
}

VegeBurger.java

package BuildPattern.FactoryPattern.BuildPatter;


/**
 * 蔬菜汉堡
 */
public class VegeBurger extends Hurber {
    public float price() {
        return 25.0f;
    }

    public String name() {
        return "蔬菜汉堡";
    }
}

ChickenHurger.java

package BuildPattern.FactoryPattern.BuildPatter;

public class ChickenHurger extends Hurber {
    public float price() {
        return 42.0f;
    }

    public String name() {
        return "鸡肉汉堡";
    }
}

Coke.java

package BuildPattern.FactoryPattern.BuildPatter;

public class Coke extends ColdDrink {
    public float price() {
        return 3.0f;
    }

    public String name() {
        return "可乐";
    }

}

Juice.java

package BuildPattern.FactoryPattern.BuildPatter;

public class Juice extends ColdDrink {
    public float price() {
        return 10.0f;
    }

    public String name() {
        return "果汁";
    }
}

Meal.java

package BuildPattern.FactoryPattern.BuildPatter;


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 a = 0.0f;
        for(Item item:items){
            a +=item.price();
        }
        return a;
    }

    //展示全部的条目数
    public void showItems(){
        for (Item item:items) {
            System.out.println(item.name());
            System.out.println(item.pack().pack());
            System.out.println(item.price());
        }
    }
}

MealBuilder.java

package BuildPattern.FactoryPattern.BuildPatter;

public class MealBuilder {

    public Meal preMeal(){
        Meal meal = new Meal();
        meal.addItem(new Coke());
        meal.addItem(new ChickenHurger());
        return  meal;
    }
}

建造者模式的好处

1、建造者独立，易扩展。
2、便于控制细节风险。