关于设计模式:设计模式建造者模式

1. 建造者模式概述

应用多个简略对象来结构一个简单的对象。

(1) 实用状况

结构一个简单对象的外部组件不变，然而这些外部组建的组合形式常常变动的时候，能够思考应用建造者模式。

(2) 长处

建造者独立，易扩大

(3) 毛病

1. 产品必须有共同点，范畴有限度
2. 不适用于外部组件常常产生变动的状况

2. 建造者模式实例

咱们当初要设计一个简略的外卖零碎，零碎中提供各种套餐，套餐中能够蕴含食物和饮料。
(1) 先实现一个 Item 类，示意所有的食物和饮料的基类，它还实现了 Packing 接口，这样每个 Item 就能够进行打包了

public abstract class Item implements Packing {
    // 物品名称
    private String name;

    // 物品价格
    private int price;

    public String getName() {return name;}

    public void setName(String name) {this.name = name;}

    public int getPrice() {return price;}

    public void setPrice(int price) {this.price = price;}
}

public interface Packing {
    // 打包
    String packing();}

(2) 外卖中能够包含食物 Food 和饮料 Drink，它们都继承于 Item 类，且实现不同的打包形式

public abstract class Food extends Item implements Box {// 食物是用盒子打包}

public abstract class Drink extends Item implements Bottle {// 饮料是用瓶子打包}

(3) 打包形式能够分为盒装和瓶装

public interface Box extends Packing {
    @Override
    default String packing() {
        // 盒装
        return "Box";
    }
}

public interface Bottle extends Packing {
    @Override
    default String packing() {
        // 瓶装
        return "Bottle";
    }
}

(4) 实现具体的食物和饮料

public class Rice extends Food {public Rice() {
        // 米饭价格 15 元
        this.setName("Rice");
        this.setPrice(15);
    }
}

public class Noodles extends Food{public Noodles() {
        // 面条价格 12 元
        this.setName("Noodles");
        this.setPrice(12);
    }
}

public class Coke extends Drink {public Coke() {
        // 可乐价格 4 元
        this.setName("Coke");
        this.setPrice(4);
    }
}

public class Spirit extends Drink {public Spirit() {
        // 雪碧价格 3 元
        this.setName("Spirit");
        this.setPrice(3);
    }
}

(5) 实现套餐类

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

    // 打印套餐总价
    public void printCost() {
        int cost = 0;
        for (Item item : items) {cost += item.getPrice();
        }
        System.out.println("Cost:" + cost);
    }

    // 打印套餐内容
    public void printItems() {for (Item item : items) {System.out.print("Item:" + item.getName());
            System.out.print(", Packing:" + item.packing());
            System.out.println(", Price :" + item.getPrice());
        }
    }

    // 套餐减少内容
    public void addItem(Item item) {this.items.add(item);
    }
}

(6) 实现套餐的建造者类

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

    public Meal buyMeal2() {Meal meal = new Meal();
        meal.addItem(new Noodles());
        meal.addItem(new Spirit());
        return meal;
    }
}

(7) 点外卖

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

        Meal meal1 = builder.buyMeal1();
        meal1.printItems();
        meal1.printCost();

        Meal meal2 = builder.buyMeal2();
        meal2.printItems();
        meal2.printCost();}
}

3. 一些思考

这个例子中的简单对象就是套餐，而简略对象就是各种食物和饮料。

它们都是派生自 Item 类，即都有共同点。

食物和饮料不会常常变动，而套餐却常常会变。
如果须要减少新的套餐，只须要在 MealBuilder 类中减少套餐即可。

参考援用

建造者模式：http://it028.com/builder-patt…