4建造者模式

建造者模式

建造者模式(Builder Pattern) 也叫作生成器模式。

1建造者模式的定义

建造者模式的英文原话是：

Separate the construction of a complex object from its representation so that the same construction process can create different representations.

意思是:将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

在建造者模式中，有如下4个角色。

• 抽象建造者(Builder) 角色：该角色用于规范产品的各个组成部分，并进行抽象，一般是独立于应用程序的逻辑。
• 具体建造者(Concrete Builder)角色：该角色实现重选ing建造者中定义的所有方法，并且返回一个组建好的产品实例。
• 产品(Product)角色：该角色是建造者中的复杂对象，一个系统终会有多于一个的产品类，这类产品并不一定有共同的接口，完全可以使不相关联的。
• 导演者(Director)角色：该角色负责安排已有模块的顺序，然后告诉Builder开始建造。

整体的结构

产品类

Product.java

package com.eric.创建型模式.建造者模式.引例;

/**
 * @author Eric
 * @ProjectName my_design_23
 * @description 产品类
 * @CreateTime 2020-11-25 20:58:00
 */
public class Product {
    //产品类的业务处理方法
}

抽象建造者

Builder.java

package com.eric.创建型模式.建造者模式.引例;

/**
 * @author Eric
 * @ProjectName my_design_23
 * @description 抽象建造者
 * @CreateTime 2020-11-25 20:58:47
 */
public abstract class Builder {
    //设置产品的不同部分，以获得不同的产品
    public abstract void setPart1();
    public abstract void setPart2();
    public abstract void setPart3();
    //...其他部件
    //建造产品
    public abstract Product builderProduct();

}

具体建造者

ConcreteBuilder.java

package com.eric.创建型模式.建造者模式.引例;

/**
 * @author Eric
 * @ProjectName my_design_23
 * @description 具体建造者
 * @CreateTime 2020-11-25 21:01:32
 */
public class ConcreteBuilder extends Builder {
    private Product product = new Product();
    //设置产品零件
    @Override
    public void setPart1() {
        //为Product安装部件1
    }

    @Override
    public void setPart2() {
        //为Product安装部件2
    }

    @Override
    public void setPart3() {
        //为Product安装部件3
    }
    //。。。其他部件
    //建造一个产品
    @Override
    public Product builderProduct() {
        return product;
    }
}

导演者类

Director.java

package com.eric.创建型模式.建造者模式.引例;

/**
 * @author Eric
 * @ProjectName my_design_23
 * @description 导演者类
 * @CreateTime 2020-11-25 21:04:33
 */
public class Director {
    private Builder builder = new ConcreteBuilder();
    //构造产品，负责调用各个零件建造方法
    public Product build(){
        builder.setPart1();
        builder.setPart2();
        builder.setPart3();
        //...其他部件
        return builder.builderProduct();
    }
}

2建造者模式应用

    A.建造者模式的优点

        建造者模式的优点有以下几个方面

•     封装性，使用建造者模式可以使客户端不必知道产品内部组成的细节。
•     建造者独立，容易扩展。
•     便于控制细节风险，由于具体的建造者是独立的，因此可以对建造过程逐步细化，而不对其他的模块产生任何影响。

    B.建造者模式使用场景

        使用建造者模式的典型场景如下

• 相同的方法，不同的执行顺序，产生不同的结果时，可以采用。
• 多个部件或零件，都可以装配到一个对象中，但是产生的运行结果有不同时，则可以使用该模式。
• 产品类非常复杂，或者产品类中的方法调用顺序不同产生了不同的效能，这时候使用建造者模式。
• 在对象的创建过程中会使用到系统的一些其他对象，这些对象在产品对象的创建过程中不易得到时，也可以采用建造者模式封装该对象的创建过程。这种场景只能是一个补偿方法，因为一个对象不容易获得，而在设计阶段没有发现，要通过创建者模式柔化创建过程，本身已经违反设计的最初目标。            

    建造者模式关注的是零件类型和装配工艺顺序，这是与工厂方法最大的不同之处，虽然同为创建类，但重点不同。

3建造者模式实例

（例1：计算机、例2：模拟快餐店、例3：利用建造者生成网页(html)）

例1：使用建造者模式完成计算机的生产。

计算机生产过程中，计算机就是产品(Product),具有不同的型号，如T410和X201是两种型号的计算机，各种类型计算机的具体配置是不同的。

计算机产品类图

步骤1

Computer是计算机的抽象类

Computer.java

package com.eric.创建型模式.建造者模式.例1.product;

/**
 * @author Eric
 * @ProjectName my_design_23
 * @description 电脑抽象类
 * @CreateTime 2020-11-26 09:34:03
 */
public abstract class Computer {
    private String type;
    private String cpu;
    private String ram;
    private String hardDisk;
    private String monitor;
    private String os;

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public String getCpu() {
        return cpu;
    }

    public void setCpu(String cpu) {
        this.cpu = cpu;
    }

    public String getRam() {
        return ram;
    }

    public void setRam(String ram) {
        this.ram = ram;
    }

    public String getHardDisk() {
        return hardDisk;
    }

    public void setHardDisk(String hardDisk) {
        this.hardDisk = hardDisk;
    }

    public String getMonitor() {
        return monitor;
    }

    public void setMonitor(String monitor) {
        this.monitor = monitor;
    }

    public String getOs() {
        return os;
    }

    public void setOs(String os) {
        this.os = os;
    }
}

T410和X201都是继承了Computer的实现类

T410.java

package com.eric.创建型模式.建造者模式.例1.product.impl;

import com.eric.创建型模式.建造者模式.例1.product.Computer;

/**
 * @author Eric
 * @ProjectName my_design_23
 * @description T410型号电脑
 * @CreateTime 2020-11-26 09:37:25
 */
public class T410 extends Computer {
    private String graphicsCard; //显卡
    public T410(){
        this.setType("ThinkPad T410i");
    }
    public String getGraphicsCard(){
        return graphicsCard;
    }
    public void setGraphicsCard(String graphicsCard){
        this.graphicsCard = graphicsCard;
    }
    @Override
    public String toString() {
        return "型号:	"+this.getType() + "
CPU:	"+this.getCpu()+
                "
内存:	"+this.getRam()+"
硬盘:	"+this.getHardDisk()+
                "
显卡:	"+this.getGraphicsCard()+"
显示器:	"+this.getMonitor()+
                "
操作系统:	"+this.getOs();
    }
}

X201.java

package com.eric.创建型模式.建造者模式.例1.product.impl;

import com.eric.创建型模式.建造者模式.例1.product.Computer;

/**
 * @author Eric
 * @ProjectName my_design_23
 * @description X201型电脑
 * @CreateTime 2020-11-26 09:46:12
 */
public class X201 extends Computer {
    public X201(){this.setType("ThinkPad X201i");}
    @Override
    public String toString() {
        return "型号:	"+this.getType() + "
CPU:	"+this.getCpu()+
                "
内存:	"+this.getRam()+"
硬盘:	"+this.getHardDisk()+
                "
显示器:	"+this.getMonitor()+ "
操作系统:	"+this.getOs();
    }
}

其中T410和X201两种型号的计算机内部构造不同，例如，X201中没有独立显卡，所以X201中没有graphicsCard属性。

在计算机产品类图的基础上增加一个ComputerBuilder接口，以及两个实现类，以便对计算机进行生产。

增加建造者后的类图

步骤2

计算机建造者的接口

ComputerBuilder.java

package com.eric.创建型模式.建造者模式.例1.builder;

import com.eric.创建型模式.建造者模式.例1.product.Computer;

/**
 * @author Eric
 * @ProjectName my_design_23
 * @description 计算机建造者接口
 * @CreateTime 2020-11-26 09:49:42
 */
//计算机Builder
public interface ComputerBuilder {
    void buildCpu();//建造cpu
    void buildRam();//建造内存
    void buildHardDisk();//建造硬盘
    void buildGraphicCard();//建造显卡
    void buildMonitor();//建造显示器
    void buildOs();//建造操作系统
    Computer getResult();//得到建造好的电脑
}

计算机的具体建造者T410Builder和X201Builder实现了ComputerBuilder接口，分别完成两种型号计算机的建造。

T410Builder.java

package com.eric.创建型模式.建造者模式.例1.builder.impl;

import com.eric.创建型模式.建造者模式.例1.builder.ComputerBuilder;
import com.eric.创建型模式.建造者模式.例1.product.Computer;
import com.eric.创建型模式.建造者模式.例1.product.impl.T410;

/**
 * @author Eric
 * @ProjectName my_design_23
 * @description T410型电脑的建造者
 * @CreateTime 2020-11-26 09:54:39
 */
public class T410Builder implements ComputerBuilder {
    private T410 computer = new T410();
    @Override
    public void buildCpu() {
        computer.setCpu("i5-450");
    }

    @Override
    public void buildRam() {
        computer.setRam("4GB 1333MHz");
    }

    @Override
    public void buildHardDisk() {
        computer.setHardDisk("500GB 7200转");
    }

    @Override
    public void buildGraphicCard() {
        computer.setGraphicsCard("Nvidia NVS 3100M");
    }

    @Override
    public void buildMonitor() {
        computer.setMonitor("14英寸 1280*800");
    }

    @Override
    public void buildOs() {
        computer.setOs("Windows 7 旗舰版");
    }

    @Override
    public T410 getResult() {
        return computer;
    }
}

X201Builder.java

package com.eric.创建型模式.建造者模式.例1.builder.impl;

import com.eric.创建型模式.建造者模式.例1.builder.ComputerBuilder;
import com.eric.创建型模式.建造者模式.例1.product.impl.X201;

/**
 * @author Eric
 * @ProjectName my_design_23
 * @description X201型电脑的建造者
 * @CreateTime 2020-11-26 10:01:43
 */
public class X201Builder implements ComputerBuilder {
    private X201 computer = new X201();

    @Override
    public void buildCpu() {
        computer.setCpu("i3-350");
    }

    @Override
    public void buildRam() {
        computer.setRam("2GB 1333MHz");
    }

    @Override
    public void buildHardDisk() {
        computer.setHardDisk("250GB 5400转");
    }

    @Override
    public void buildGraphicCard() {
       //无显卡
    }

    @Override
    public void buildMonitor() {
        computer.setMonitor("12英寸 1280*800");
    }

    @Override
    public void buildOs() {
        computer.setOs("Windows 7 Home版");
    }


    @Override
    public X201 getResult() {
        return computer;
    }
}

增加建造者之后，再增加导演者ComputerDirector类，对已有的模块进行封装。

增加导演类后的类图

步骤3

建造计算机的导演类

ComputerDirector.java

package com.eric.创建型模式.建造者模式.例1.director;

import com.eric.创建型模式.建造者模式.例1.builder.ComputerBuilder;
import com.eric.创建型模式.建造者模式.例1.builder.impl.T410Builder;
import com.eric.创建型模式.建造者模式.例1.builder.impl.X201Builder;
import com.eric.创建型模式.建造者模式.例1.product.impl.T410;
import com.eric.创建型模式.建造者模式.例1.product.impl.X201;

/**
 * @author Eric
 * @ProjectName my_design_23
 * @description 建造计算机的导演类
 * @CreateTime 2020-11-26 10:05:34
 */
public class ComputerDirector {
    ComputerBuilder builder;
    //构造T410型计算机
    public T410 constructT410(){
         builder = new T410Builder();
         builder.buildCpu();
         builder.buildRam();
         builder.buildHardDisk();
         builder.buildGraphicCard();
         builder.buildMonitor();
         builder.buildOs();
         return (T410) builder.getResult();
    }
    //构造X201型计算机
    public X201 constructX201(){
        builder = new X201Builder();
        builder.buildCpu();
        builder.buildRam();
        builder.buildHardDisk();
        //无显卡
        builder.buildMonitor();
        builder.buildOs();
        return (X201) builder.getResult();
    }
}

导演类实现了对建造两种型号计算机的封装 

步骤4

测试类

ComputerTest.java

package com.eric.创建型模式.建造者模式.例1.test;

import com.eric.创建型模式.建造者模式.例1.director.ComputerDirector;
import com.eric.创建型模式.建造者模式.例1.product.impl.T410;
import com.eric.创建型模式.建造者模式.例1.product.impl.X201;

/**
 * @author Eric
 * @ProjectName my_design_23
 * @description 测试类
 * @CreateTime 2020-11-26 10:10:10
 */
public class ComputerTest {
    public static void main(String[] args) {
        //得到导演类
        ComputerDirector director = new ComputerDirector();
        //创建并拿到T410型电脑
        T410 t410 = director.constructT410();
        System.out.println(t410);
        //无情分割线
        System.out.println("----------------------------");
        //创建并拿到X201型电脑
        X201 x201 = director.constructX201();
        System.out.println(x201);
    }
}

测试结果

完成计算机的建造。

例2：使用建造者模式完成一个快餐店的商业案例。

首先我们先假设一个快餐店场景。其中，一个典型的套餐可以是汉堡(Burger)和一杯冷饮(Cold drink)。汉堡(Burger)可以是素食汉堡(Veg Burger)或鸡肉汉堡(Chicken Burger),他们是包在纸盒中的。 冷饮(Cold Drink)可以是可口可乐(Coke)或百事可乐(Pepsi),它们是装在瓶子里的。

我们将创建一个表示事物条目(比如汉堡和冷饮)的Item接口和实现Item接口的实体类，以及一个表示食物包装的Packing接口和实现Packing接口的实体类，汉堡是包在纸盒中，冷饮是装在瓶子中。

然后创建Meal类，带有Item的ArrayList和一个通过结合Item来创建不同类型的Meal对象的MealBuilder类。

BuilderPatternDemo类使用MealBuilder来创建一个Meal。

快餐店的建造者模式

步骤1

创建Packing与Item接口

Packing.java  包装

package com.eric.创建型模式.建造者模式.例2.pack;

/**
 * @author Eric
 * @ProjectName my_design_23
 * @description 食物包装的接口
 * @CreateTime 2020-11-26 10:55:06
 */
public interface Packing {
    public String pack();
}

Item.java   快餐购物项

package com.eric.创建型模式.建造者模式.例2.item;

import com.eric.创建型模式.建造者模式.例2.pack.Packing;

/**
 * @author Eric
 * @ProjectName my_design_23
 * @description 食物清单的接口
 * @CreateTime 2020-11-26 10:53:46
 */
public interface Item {
    public String name();
    public Packing packing();
    public float price();
}

步骤2

创建Packing的实现类Bottle和Wrapper

Bottle.java    瓶子

package com.eric.创建型模式.建造者模式.例2.pack.impl;

import com.eric.创建型模式.建造者模式.例2.pack.Packing;

/**
 * @author Eric
 * @ProjectName my_design_23
 * @description 瓶子类
 * @CreateTime 2020-11-26 10:57:31
 */
public class Bottle implements Packing {
    @Override
    public String pack() {
        return "Bottle";
    }
}

Wrapper.java    包装纸

package com.eric.创建型模式.建造者模式.例2.pack.impl;

import com.eric.创建型模式.建造者模式.例2.pack.Packing;

/**
 * @author Eric
 * @ProjectName my_design_23
 * @description 包装纸类
 * @CreateTime 2020-11-26 10:56:34
 */
public class Wrapper implements Packing {
    @Override
    public String pack() {
        return "Wrapper";
    }
}

步骤3

创建两个实现Item接口的抽象实现类。--Burger和ColdDrink

Burger.java    汉堡包

package com.eric.创建型模式.建造者模式.例2.item.Burger;

import com.eric.创建型模式.建造者模式.例2.item.Item;
import com.eric.创建型模式.建造者模式.例2.pack.Packing;
import com.eric.创建型模式.建造者模式.例2.pack.impl.Wrapper;

/**
 * @author Eric
 * @ProjectName my_design_23
 * @description 汉堡的抽象类
 * @CreateTime 2020-11-26 10:59:15
 */
public abstract class Burger implements Item {
    //汉堡的包装
    @Override
    public Packing packing() {
        return new Wrapper();
    }
    //汉堡的价格
    @Override
    public abstract float price();
}

ColdDrink.java    冷饮

package com.eric.创建型模式.建造者模式.例2.item.ColdDrink;

import com.eric.创建型模式.建造者模式.例2.item.Item;
import com.eric.创建型模式.建造者模式.例2.pack.Packing;
import com.eric.创建型模式.建造者模式.例2.pack.impl.Bottle;

/**
 * @author Eric
 * @ProjectName my_design_23
 * @description 冷饮抽象类
 * @CreateTime 2020-11-26 11:02:31
 */
public abstract class ColdDrink implements Item {

    @Override
    public Packing packing() {
        return new Bottle();
    }

    @Override
    public abstract float price();
}

步骤4

创建继承Burger和ColdDrink的实现类

ChickenBurger.java    鸡肉堡

package com.eric.创建型模式.建造者模式.例2.item.Burger.impl;

import com.eric.创建型模式.建造者模式.例2.item.Burger.Burger;

/**
 * @author Eric
 * @ProjectName my_design_23
 * @description 鸡肉堡类
 * @CreateTime 2020-11-26 11:05:18
 */
public class ChickenBurger extends Burger {
    @Override
    public String name() {
        return "Chicken Burger";
    }

    @Override
    public float price() {
        return 13.5f;
    }
}

VegBurger.java    素汉堡

package com.eric.创建型模式.建造者模式.例2.item.Burger.impl;

import com.eric.创建型模式.建造者模式.例2.item.Burger.Burger;

/**
 * @author Eric
 * @ProjectName my_design_23
 * @description 素汉堡类
 * @CreateTime 2020-11-26 11:04:06
 */
public class VegBurger extends Burger {
    @Override
    public String name() {
        return "Veg Burger";
    }
    @Override
    public float price() {
        return 5.2f;
    }
}

Coke.java    可口可乐

package com.eric.创建型模式.建造者模式.例2.item.ColdDrink.impl;

import com.eric.创建型模式.建造者模式.例2.item.ColdDrink.ColdDrink;

/**
 * @author Eric
 * @ProjectName my_design_23
 * @description 可口可乐类
 * @CreateTime 2020-11-26 11:06:36
 */
public class Coke extends ColdDrink {
    @Override
    public String name() {
        return "Coke";
    }
    @Override
    public float price() {
        return 5.0f;
    }
}

Pepsi.java    百事可乐

package com.eric.创建型模式.建造者模式.例2.item.ColdDrink.impl;

import com.eric.创建型模式.建造者模式.例2.item.ColdDrink.ColdDrink;

/**
 * @author Eric
 * @ProjectName my_design_23
 * @description 百事可乐类
 * @CreateTime 2020-11-26 11:07:30
 */
public class Pepsi extends ColdDrink {
    @Override
    public String name() {
        return "Pepsi";
    }

    @Override
    public float price() {
        return 2.0f;
    }
}

步骤5

创建Meal类集中管理Item

Meal.java    购物清单

package com.eric.创建型模式.建造者模式.例2.meal;

import com.eric.创建型模式.建造者模式.例2.item.Item;

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

/**
 * @author Eric
 * @ProjectName my_design_23
 * @description 购物清单
 * @CreateTime 2020-11-26 11:09:05
 */
public class Meal {
    private List<Item> items = new ArrayList<Item>();
    //添加物品
    public void addItem(Item item){
        items.add(item);
    }
    //计算金额
    public float getCost(){
        float cost = 0.0f;
        for (Item item : items) {
            cost += item.price();
        }
        return cost;
    }
    //列出清单
    public void showItems(){
        for (Item item : items) {
            System.out.print("Item:"+item.name());
            System.out.print(" -- Packing:"+item.packing().pack());
            System.out.println(" -- Price:"+item.price());
        }
    }
}

步骤6

创建Meal的建造者实现快餐店的套餐

MealBuilder.java    结算

package com.eric.创建型模式.建造者模式.例2.meal;

import com.eric.创建型模式.建造者模式.例2.item.Burger.impl.ChickenBurger;
import com.eric.创建型模式.建造者模式.例2.item.Burger.impl.VegBurger;
import com.eric.创建型模式.建造者模式.例2.item.ColdDrink.impl.Coke;
import com.eric.创建型模式.建造者模式.例2.item.ColdDrink.impl.Pepsi;
import com.eric.创建型模式.建造者模式.例2.item.Item;

/**
 * @author Eric
 * @ProjectName my_design_23
 * @description 实际的Builder类负责创建Meal对象
 * @CreateTime 2020-11-26 11:15:46
 */
public class MealBuilder {
    public Meal prepareVegMeal(){
        Meal meal = new Meal();
        meal.addItem(new VegBurger());
        meal.addItem(new Coke());
        return meal;
    }
    public Meal prepareNonVegMeal(){
        Meal meal = new Meal();
        meal.addItem(new ChickenBurger());
        meal.addItem(new Pepsi());
        return meal;
    }
}

步骤7

测试类

BuilderPatternDemo.java

package com.eric.创建型模式.建造者模式.例2;

import com.eric.创建型模式.建造者模式.例2.meal.Meal;
import com.eric.创建型模式.建造者模式.例2.meal.MealBuilder;

/**
 * @author Eric
 * @ProjectName my_design_23
 * @description 使用MealBuilder来演示建造者模式
 * @CreateTime 2020-11-26 11:19:29
 */
public class BuilderPatternDemo {
    public static void main(String[] args) {

        MealBuilder mealBuilder = new MealBuilder();

        Meal vegMeal = mealBuilder.prepareVegMeal();
        System.out.println("Veg Meal");
        vegMeal.showItems();
        System.out.println("Total Cost:"+vegMeal.getCost());
        //无情分割线
        System.out.println("---------------------------------------");

        Meal nonVegMeal = mealBuilder.prepareNonVegMeal();
        System.out.println("non-Veg Meal");
        nonVegMeal.showItems();
        System.out.println("Total Cost:"+nonVegMeal.getCost());
    }
}

例3：建造者模式的高级应用案例----生成网页

我们可以利用建造者模式，提取出文本与html页面的共性，并使用建造者模式分别生成。

网页与文本的建造者模式

步骤1

创建建造者的抽象类：

Builder.java

package com.eric.创建型模式.建造者模式.例3;

/**
 * @author Eric
 * @ProjectName my_design_23
 * @description 建造抽象类
 * @CreateTime 2020-11-26 12:26:42
 */
public abstract class Builder {
    //设置标题
    public abstract void makeTitle(String title);
    //设置字段
    public abstract void makeString(String str);
    //设置条目项
    public abstract void makeItems(String[] items);
    //结束操作
    public abstract void close();
    //返回结果
    public abstract String getResult();
}

步骤2

创建继承Builder的实现类HtmlBuilder和TextBuilder

HtmlBuilder.java

package com.eric.创建型模式.建造者模式.例3;

import java.io.FileWriter;
import java.io.PrintWriter;

/**
 * @author Eric
 * @ProjectName my_design_23
 * @description 网页的建造类
 * @CreateTime 2020-11-26 12:28:31
 */
public class HtmlBuilder extends Builder{
    //文件全名
    private String filename;
    //写入到文件
    private PrintWriter pw;
    @Override
    public void makeString(String str) {
        pw.println("<p>"+str+"</p>");
    }
    @Override
    public void makeTitle(String title) {
        filename = "D:\"+title+".html";
        try {
           pw = new PrintWriter(new FileWriter(filename));
        }catch (Exception e){
            e.printStackTrace();
        }
        pw.println("<html><head><title>"+title+"</title></head><body>");
        pw.println("<h1>"+title+"</h1>");
    }
    @Override
    public void makeItems(String[] items) {
        pw.println("<ul>");
        for (String item : items) {
            pw.println("<li>"+item+"</li>");
        }
        pw.println("</ul>");
    }
    @Override
    public void close() {
        pw.println("</body></html>");
        pw.close();
    }
    //返回文件名
    public String getResult()
    {
        return filename;
    }
}

TextBuilder.java

package com.eric.创建型模式.建造者模式.例3;

/**
 * @author Eric
 * @ProjectName my_design_23
 * @description 文本的建造者
 * @CreateTime 2020-11-26 12:36:41
 */
public class TextBuilder extends Builder {
   StringBuffer sb =  new StringBuffer();
    @Override
    public void makeString(String str) {
        sb.append("~").append(str).append("
");
    }
    @Override
    public void makeTitle(String title) {
        sb.append("====================
");
        sb.append("     [").append(title).append("]").append("

");
    }
    @Override
    public void makeItems(String[] items) {
        for (String item : items) {
            sb.append("     -").append(item).append("
");
        }
    }
    @Override
    public void close() {
        sb.append("====================");
    }
    public String getResult(){
        return sb.toString();
    }
}

步骤3

创建监管者(导演类)

Director.java

package com.eric.创建型模式.建造者模式.例3;

/**
 * @author Eric
 * @ProjectName my_design_23
 * @description 监工类
 * @CreateTime 2020-11-26 12:42:06
 */
public class Director {
    private Builder builder;
    public Director(Builder builder){
        this.builder=builder;
    }

    public void conStruct(String[] itemsA,String[] itemsB){
        String[] items1 = itemsA;
        String[] items2= itemsB;
        builder.makeTitle("日记一则");
        builder.makeString("周一");
        builder.makeItems(items1);
        builder.makeString("周二");
        builder.makeItems(items2);
        builder.close();
    }
}

步骤4

测试类

testBuilder.java

package com.eric.创建型模式.建造者模式.例3;

/**
 * @author Eric
 * @ProjectName my_design_23
 * @description 测试类
 * @CreateTime 2020-11-26 12:47:53
 */
public class testBuilder {
    public static void main(String[] args) {
        //String choice = "plain";
        String choice = "html";
        Builder builder = null;
        Director director = null;
        String [] items1=new String[]{"吃饭","睡觉","打豆豆"};
        String [] items2=new String[]{"吃饭","打豆豆","睡觉"};
        switch(choice.equals("html")?1:0){
            case 0:
                builder = new TextBuilder();
                director= new Director(builder);
                director.conStruct(items1,items2);
                System.out.println(builder.getResult());
                break;
            case 1:
                builder = new HtmlBuilder();
                director= new Director(builder);
                director.conStruct(items1,items2);
                System.out.println(builder.getResult());
                break;
        }
    }
}

测试结果：

1.html(控制台返回结果、生成的html页面、页面展示)   

控制台返回结果

生成的html页面

页面展示

2.text结果(控制台返回结果)

文本的控制台返回结果

至此完成以上案例后，相信大家一定对建造者模式的理解又加深了一分。

来自为知笔记(Wiz)