设计模式之建造者模式

1、定义

你有没有出现过点了个外卖，结果外卖送过来的时候发现忘了点个米饭。结果只能屁颠屁颠再点一份米饭，再等一个小时。你有没有经历炒好了全部的菜以后，发现你尚未煮饭的尴尬？来看看建造者模式是怎么来建立对象的。

定义（百度百科）：建造者模式是设计模式的一种，将一个复杂对象的构建与它的表示分离，使得一样的构建过程能够建立不一样的表示。

核心有两点：

一、将建立对象的代码，过程与对象分离。

二、可构建出不一样的对象。

2、UML

如图，定义了各类菜品，建造者模式相关的为图中框出来的部分，Meal套餐中能够有各类菜品，真正去构建Meal的是在MealABuilder中去进行构建（实现了定义中核心点1，Meal与构建Meal代码分离）。使用不一样的建造器，构建出来的菜单是不同的（实现了定义中核心点2），Director是构建的指挥类，负责控制菜单对象的生成过程。

是否是看着还不太理解各种的做用？？别急，接着往下看例子.....

3、代码实现

咱们来看下建立外卖订单怎么来抽象，并保证咱们的订单必定预约了米饭。

一、咱们先定义各类菜品及套餐类，假设能够点的菜为：米饭、红烧鱼、土豆、番茄炒鸡蛋

package com.design.builder;

public abstract class Food {
    private String foodName;
    private int price;

    public Food(String foodName, int price) {
        this.foodName = foodName;
        this.price = price;
    }

    public String getFoodName() {
        return foodName;
    }
    public void setFoodName(String foodName) {
        this.foodName = foodName;
    }
    public int getPrice() {
        return price;
    }
    public void setPrice(int price) {
        this.price = price;
    }

    public void showTheFood(){
        System.out.println("食物："+foodName+"，价格："+price);
    }
}
复制代码

package com.design.builder;

/**
 * 米饭
 */
public class Rice extends Food {
    public Rice() {
        super("米饭", 3);
    }
}
复制代码

package com.design.builder;

public class Fish extends Food {
    public Fish() {
        super("红烧鱼", 20);
    }
}
复制代码

package com.design.builder;

/**
 * 土豆
 */
public class Potato extends Food{

    public Potato() {
        super("土豆", 8);
    }
}
复制代码

package com.design.builder;

/**
 * 番茄炒蛋
 */
public class TomatoWithEgg extends Food{

    public TomatoWithEgg() {
        super("番茄炒蛋", 15);
    }
}复制代码

package com.design.builder;
/**
套餐类
*/
public class Meal {

    private Rice rice;

    private Fish fish;

    private Potato potato;

    private TomatoWithEgg tomatoWithEgg;

    public Rice getRice() {
        return rice;
    }

    public void setRice(Rice rice) {
        this.rice = rice;
    }

    public Fish getFish() {
        return fish;
    }

    public void setFish(Fish fish) {
        this.fish = fish;
    }

    public Potato getPotato() {
        return potato;
    }

    public void setPotato(Potato potato) {
        this.potato = potato;
    }

    public TomatoWithEgg getTomatoWithEgg() {
        return tomatoWithEgg;
    }

    public void setTomatoWithEgg(TomatoWithEgg tomatoWithEgg) {
        this.tomatoWithEgg = tomatoWithEgg;
    }

    public void showMeal(){
        System.out.println("=========套餐===========");
        if (rice != null){
            rice.showTheFood();
        }
        if(fish != null){
            fish.showTheFood();
        }
        if(potato != null){
            potato.showTheFood();
        }
        if(tomatoWithEgg != null){
            tomatoWithEgg.showTheFood();
        }
        System.out.println("========套餐结束=========");

    }
}
复制代码

二、构建类，即建立套餐的类，在定义中，咱们知道对象的建立是与对象分离的。因而咱们就在该构建类中来定义套餐对象。

1）、先定义接口，构建类中，咱们定义了增长米饭，增长菜的方法。

package com.design.builder;
//构造者抽象类
public interface IBuilder {
    //給套餐增长米饭
    public void addRice();
    //給套餐增长菜
    public void addFood();
    public Meal build();
}

复制代码

2）、构建类

package com.design.builder;

/**
 * 套餐A建造者
 */
public class MealABuilder implements IBuilder{

    private Meal meal;

    public MealABuilder() {
        meal = new Meal();
    }

    @Override
    public void addRice(){
        meal.setRice(new Rice());
    }

    //点菜的方法
    @Override
    public void addFood() {
        //套餐A，红烧鱼，爆炒土豆
        meal.setPotato(new Potato());
        meal.setFish(new Fish());
    }

    @Override
    public Meal build(){
        return meal;
    }
}

复制代码

package com.design.builder;

/**
 * 套餐B建造者
 */
public class MealBBuilder implements IBuilder {

    private Meal meal;

    public MealBBuilder() {
        meal = new Meal();
    }

    @Override
    public void addRice() {
        meal.setRice(new Rice());
    }

    //点菜的方法
    @Override
    public void addFood() {
        //套餐B，西红柿炒鸡蛋，红烧鱼
        meal.setTomatoWithEgg(new TomatoWithEgg());
        meal.setFish(new Fish());
    }

    @Override
    public Meal build() {
        return meal;
    }
}复制代码

三、指挥类，用来定义构建的过程，套餐构建为：增长米饭，增长菜。

package com.design.builder;

public class Director {

    private IBuilder mealBuilder;

    public Director(IBuilder mealBuilder){
        this.mealBuilder = mealBuilder;
    }

    /**
     * 构建套餐
     */
    public void buildMeal(){
        mealBuilder.addRice();
        mealBuilder.addFood();
    }

}

复制代码

四、测试

package com.design.builder;

import javafx.util.Builder;

public class TestMain {

    public static void main(String[] args) {
        MealBuilder builder = new MealBuilder();
        Director director = new Director(builder);
        director.buildMealA();
        builder.build().showMeal();

        MealBuilder builder2 = new MealBuilder();
        Director director2 = new Director(builder2);
        director2.buildMealB();
        builder2.build().showMeal();
    }
}
复制代码

执行结果

4、总结

建造者模式，适用于建造复杂对象。与静态工厂方法模式相比，建造者模式更注重零件装配，主要目的是经过组装零配件而产生一个新产品。如上，米饭、菜品至关与菜单类的零配件，经过往菜单中增长米饭，菜来构建一个菜单。

看到一篇文章，里面对建造者模式、静态工厂方法模式的区别描述得比较巧妙，这里引用一下：

若是将抽象工厂模式当作汽车配件生产工厂，生产一个产品族的产品，那么建造者模式就是一个汽车组装工厂，经过对部件的组装能够返回一辆完整的汽车

优势：

一、使用建造者模式中客户端不须要知道建立对象的构造过程。

二、产品建立与产品自己解耦，相同的建立过程可建立不一样对象。（Director中建立菜单的步骤都是同样的，都是增长米饭，增长菜品）。

三、扩展性好，要新增新的套餐，只需新增Builder（建造器）便可。

缺点：

一、若是要建立的对象可变因素较多，则可能有不少种套餐可能，须要定义的建造器较多。