Builder模式详解

一、Builder模式实验报告

Builder模式是一种创建型设计模式，该模式让你能够分步骤创建复杂对象。Builder模式的目的是将一个复杂对象的构建与它的表示分离，是对象构建更加灵活、更加易于扩展。

建议先做一个实验，通过实验来深入理解Builder模式。实验内容为：假设要构建一个早餐，需要选择一份汉堡（可以是鸡肉汉堡或者蔬菜汉堡）、一杯饮料（可以是可乐或者咖啡）、一份薯条或者沙拉。

以下是实验的代码示例：

// 定义汉堡类
public class Burger {
    private String name;

    public Burger(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

// 定义饮料类
public class Drink {
    private String name;

    public Drink(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

// 定义小吃类
public class Snack {
    private String name;

    public Snack(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

// 定义早餐类
public class Breakfast {
    private Burger burger;
    private Drink drink;
    private Snack snack;

    // 构造方法
    public Breakfast(Burger burger, Drink drink, Snack snack) {
        this.burger = burger;
        this.drink = drink;
        this.snack = snack;
    }

    // 获取汉堡
    public Burger getBurger() {
        return burger;
    }

    // 获取饮料
    public Drink getDrink() {
        return drink;
    }

    // 获取小吃
    public Snack getSnack() {
        return snack;
    }
}

// 定义早餐Builder类
public class BreakfastBuilder {
    private Burger burger;
    private Drink drink;
    private Snack snack;

    // 构造方法
    public BreakfastBuilder() {}

    // 设置汉堡
    public BreakfastBuilder setBurger(Burger burger) {
        this.burger = burger;
        return this;
    }

    // 设置饮料
    public BreakfastBuilder setDrink(Drink drink) {
        this.drink = drink;
        return this;
    }

    // 设置小吃
    public BreakfastBuilder setSnack(Snack snack) {
        this.snack = snack;
        return this;
    }

    // 构建早餐对象
    public Breakfast build() {
        return new Breakfast(burger, drink, snack);
    }
}

// 测试
public class Test {
    public static void main(String[] args) {
        BreakfastBuilder builder = new BreakfastBuilder();
        Breakfast breakfast = builder.setBurger(new Burger("蔬菜汉堡"))
                .setDrink(new Drink("咖啡"))
                .setSnack(new Snack("薯条"))
                .build();
        System.out.println("您的早餐包含：" + breakfast.getBurger().getName() + "、" +
                breakfast.getDrink().getName() + "、" + breakfast.getSnack().getName());
    }
}

二、Builder是什么意思

Builder是“构建者”的意思。在软件设计模式中，Builder模式解决的是对象的构建问题。在不同情况下，我们可能需要按照不同的构建流程、使用不同的组件来实现对象构建，而Builder模式允许我们通过定义接口或者抽象类的方式来统一了对象构建的流程，从而实现简单、可复用、可扩展的对象创建。

三、Builder设计模式

Builder模式是创建型设计模式的一种，它通过将一个复杂对象的构建过程分解为若干个简单的步骤来实现对象的构建。一个Builder类通常包括如下方法：

• 创建对象并初始化一些属性
• 设置或者添加一些属性
• 返回构建好的对象

Builder模式主要有以下几个角色：

• Product（产品）：需要被构建的复杂对象
• Builder（构建者）：定义对象构建流程的接口或者抽象类，具体的构建过程由其子类实现
• ConcreteBuilder（具体构建者）：实现Builder接口或者抽象类，构建复杂对象的每个部分
• Director（指挥者）：调用具体构建者来构建整个对象

在运用Builder模式时，主要需要考虑的问题有：

• 如何构建一个复杂对象？
• 构建对象需要哪些步骤？
• 构建对象的每个部分的变化点有哪些？

四、Builder软件下载

Builder是一种设计模式，不是指具体的软件。如果需要使用Builder模式，可以在Java中自己定义Builder类，或者借助第三方库来实现。比如，Apache Commons Lang库中提供了一个便于创建实例的Builder类：org.apache.commons.lang3.builder.Builder。

五、Builder模式抽象示意图

Builder模式的抽象示意图如下：

六、Builder模式使用HashMap

在Java中，可以将Builder模式与HashMap相结合使用。具体的实现方式是：定义一个Builder类，这个Builder类中存储一个HashMap，然后通过设置和生成方法对HashMap进行操作，最后通过build()方法返回HashMap。实现代码如下：

import java.util.HashMap;

public class Builder {
    private HashMap map = new HashMap<>();

    public Builder set(String key, Object value) {
        map.put(key, value);
        return this;
    }

    public HashMap
    build() {
        return map;
    }
}

public class Test {
    public static void main(String[] args) {
        HashMap
     map = new Builder()
                .set("name", "Tom")
                .set("age", 18)
                .build();
        System.out.println(map);
    }
}

    
   
  

七、Builder模式创建对象

Builder模式的主要作用是让对象的构建更加灵活、更加易于扩展。以下是一个简单的例子，演示了使用Builder模式创建对象，将对象的构建过程分解为若干个简单的步骤。

// Product（产品）：需要被构建的复杂对象
public class Student {
    private String name;
    private Integer age;
    private String sex;
    private String school;
    private String major;
    private String address;

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

    public void setAge(Integer age) {
        this.age = age;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public void setSchool(String school) {
        this.school = school;
    }

    public void setMajor(String major) {
        this.major = major;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public String getName() {
        return name;
    }

    public Integer getAge() {
        return age;
    }

    public String getSex() {
        return sex;
    }

    public String getSchool() {
        return school;
    }

    public String getMajor() {
        return major;
    }

    public String getAddress() {
        return address;
    }
}

// Builder（构建者）：定义对象构建流程的接口或者抽象类
public abstract class StudentBuilder {
    protected Student student;

    public Student getStudent() {
        return student;
    }

    public void createNewStudent() {
        student = new Student();
    }

    public abstract void setName();
    public abstract void setAge();
    public abstract void setSex();
    public abstract void setSchool();
    public abstract void setMajor();
    public abstract void setAddress();
}

// ConcreteBuilder（具体构建者）：实现Builder接口或者抽象类，构建复杂对象的每个部分
public class ZhStudentBuilder extends StudentBuilder {
    @Override
    public void setName() {
        student.setName("小明");
    }

    @Override
    public void setAge() {
        student.setAge(18);
    }

    @Override
    public void setSex() {
        student.setSex("男");
    }

    @Override
    public void setSchool() {
        student.setSchool("清华大学");
    }

    @Override
    public void setMajor() {
        student.setMajor("计算机科学与技术");
    }

    @Override
    public void setAddress() {
        student.setAddress("北京市海淀区");
    }
}

// Director（指挥者）：调用具体构建者来构建整个对象
public class StudentDirector {
    private StudentBuilder studentBuilder;

    public StudentDirector(StudentBuilder studentBuilder) {
        this.studentBuilder = studentBuilder;
    }

    public void constructStudent() {
        studentBuilder.createNewStudent();
        studentBuilder.setName();
        studentBuilder.setAge();
        studentBuilder.setSex();
        studentBuilder.setSchool();
        studentBuilder.setMajor();
        studentBuilder.setAddress();
    }

    public Student getStudent() {
        return studentBuilder.getStudent();
    }
}

// 测试代码
public class Test {
    public static void main(String[] args) {
        StudentDirector director = new StudentDirector(new ZhStudentBuilder());
        director.constructStudent();
        Student student = director.getStudent();
        System.out.println(student.getName());
        System.out.println(student.getAge());
        System.out.println(student.getSex());
        System.out.println(student.getSchool());
        System.out.println(student.getMajor());
        System.out.println(student.getAddress());
    }
}

八、Builder模式不同创建对象会有

在使用Builder模式构建对象时，不同的创建对象会有不同的实现方式，这主要取决于对象的属性以及对象构建的步骤。比如，在创建饮品时可能只需要一步，而创建汽车时可能需要十几步、甚至更多。因此，在不同的场景中，我们需要根据实际情况来选择合适的Builder实现方式。

九、Builder模式工厂模式

Builder模式与工厂模式是两种创建型设计模式，它们的区别在于：工厂模式是根据工厂方法创建对象，而Builder模式是通过Builder对象构建复杂对象。

工厂模式适用于创建同一种类型的对象，而Builder模式则适用于创建复杂、多属性的对象。通过工厂模式，我们可以快速地创建单一类型的对象，而通过Builder模式，我们可以更加灵活、精细地控制对象的创建过程。