设计模式---建造者模式

建造者模式

建造者模式属于创建型模式的的一种。我们可以使用多个简单的对象逐步构建成复杂的对象，Builder类会慢慢的构造成最终的对象，该Builder类是独立于其他对象。

什么时候会用到建造者模式？ 通常当一些基本物料不会变，其组合经常改变的时候，这既可以当成优点，也可以当成缺点。建造者模式满足单一职责原则和可复用性，建造者之间相对独立。但是随着物料以及组合逐渐增多，维护起来会相对麻烦。

在日常生活中，新房子的装修风格，肯德基麦当劳的汉堡套餐，或者是星巴克的下午茶套餐，这些例子的物料通常是固定， 可以通过组合产生不同的套餐。

在星巴克下午茶套餐中，分别包含了咖啡和蛋糕，它们都有不同的种类，包装和价格，我们可以通过对不同种类的咖啡和蛋糕进行组合来实现建造者模式。

星巴克套餐实现建造者模式：

//套餐接口
public interface Item {

    String name();

    Package packaging();

    float price();

}

//包装接口
public interface Package {

    String packaging();
}

紧接着我们对不同物品的包装进行定义

//瓶子
public class Bottle implements Package {
    @Override
    public String packaging() {
        return "Bottle";
    }
}

//盒子
public class Wrapper implements Package {
    @Override
    public String packaging() {
        return "Wrapper";
    }
}

定义好包装的接口后，我们需要对物品进行定义

//拿铁咖啡
public class Latte extends Coffee {
    @Override
    public String name() {
        return "Latte";
    }

    @Override
    public float price() {
        return 32;
    }
}

//卡布奇诺
public class Cappuccino extends Coffee {
    @Override
    public String name() {
        return "Cappuccino";
    }

    @Override
    public float price() {
        return 36;
    }
}

//汤圆蛋糕
public class Socake extends Cake {
    @Override
    public String name() {
        return "Socake";
    }

    @Override
    public float price() {
        return 35;
    }
}

//草莓蛋糕
public class StrawberryCake extends Cake {
    @Override
    public String name() {
        return "StrawberryCake";
    }

    @Override
    public float price() {
        return 36;
    }
}

这些商品可以组成不同的套餐，接下来创建套餐

public class Order {
    //订单存放coffee 和 cake
    private List<Item> itemList = new ArrayList<>();

    //商品添加到套餐中
    public void add(Item item){
        itemList.add(item);
    }
    //获取总价
    public float getTotal(){
        float total = 0;
        for (Item i: itemList) {
            total += i.price();
        }
        return total;
    }
    //打印订单
    public void print(){
        for (Item item : itemList) {
            System.out.print("Item : "+item.name());
            System.out.print(", Packing : "+item.packaging().packaging());
            System.out.println(", Price : "+item.price());
        }
    }
}

创建Builder类

//创建套餐Builder
public class OrderBuilder {

    //汤圆蛋糕配卡布奇诺套餐
    public Order SoCake_Cappuccino(){
        Order order = new Order();
        order.add(new Cappuccino());
        order.add(new Socake());
        return order;
    }
    
    //拿铁配草莓蛋糕套餐
    public Order Strawberry_Latte(){
        Order order = new Order();
        order.add(new StrawberryCake());
        order.add(new Latte());
        return order;
    }
    
    //汤圆蛋糕配拿铁套餐
    public Order SoCake_Latte(){
        Order order = new Order();
        order.add(new Socake());
        order.add(new Latte());
        return order;
    }
}

//根据多种物料可以进行多种组合

最后创建测试类进行测试

//测试类测试
public class BuilderPatternTest{

    public static void main(String[] args) {
        OrderBuilder orderBuilder = new OrderBuilder();
        Order Socake_Latte = orderBuilder.SoCake_Latte();
        Socake_Latte.print();
        System.out.println("Total Price:" + Socake_Latte.getTotal());
    }
}

//输出结果
//Item : Socake, Packing : Wrapper, Price : 35.0
//Item : Latte, Packing : Bottle, Price : 32.0
//Total Price:67.0

优点：

1.良好的封装性，建造者模式使得客户端无需知道产品的构建过程和组成部分，符合设计原则中的迪米特法则。
2.建造者易扩展同时也相对独立。

总结：所谓建造者模式，就是通过Builder类来创建我们需要的复杂的对象，这些细节是被我们所隐蔽的。如果一个对象内部的创建非常复杂，这时可以考虑使用建造者模式，相反，如果比较简单，就不需要使用建造者模式， 不要为了设计模式而硬凑设计模式，可能会适得其反。