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模式，我們可以更加靈活、精細地控制對象的創建過程。

原創文章，作者：小藍，如若轉載，請註明出處：https://www.506064.com/zh-hant/n/196474.html