建造者模式：程序员界的“乐高大师”，如何一步步拼出完美对象？-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_40099340/article/details/145895278

引言

在程序员的工具箱里，有一种设计模式叫建造者模式，它就像是一个“乐高大师”，通过一步步的拼装，最终构建出一个完美的对象。今天，就来聊聊这个“乐高大师”的神奇能力，看看它是如何一步步拼出完美对象的！

1. 建造者模式：为什么需要“乐高大师”？

在代码的世界里，有时候我们需要创建一个复杂的对象，比如一台电脑、一辆汽车或者一份汉堡套餐。如果直接 new，代码会变得又臭又长。这时候，建造者模式就像是一个“乐高大师”，帮你一步步拼出完美对象。

核心思想：
- 将一个复杂对象的构建过程分解为多个简单步骤。
- 通过指挥者（Director）控制构建过程，最终生成对象。
使用场景：
- 需要创建复杂对象，且对象的构建过程需要分步骤进行。
- 对象的构建过程需要灵活配置。

2. 建造者模式的“乐高大师”法则

建造者模式的实现方式有很多，但每一种都有自己的“乐高法则”。下面我们来看看几种经典的实现方式，看看它们是如何在代码的世界里“拼装”的！

2.1 基础版：汉堡套餐建造者

假设我们需要构建一个汉堡套餐，包括汉堡、薯条和饮料。建造者模式可以帮我们轻松实现。

代码实现：

// 产品：汉堡套餐
public class Meal {
    private String burger;
    private String fries;
    private String drink;

    public void setBurger(String burger) {
        this.burger = burger;
    }

    public void setFries(String fries) {
        this.fries = fries;
    }

    public void setDrink(String drink) {
        this.drink = drink;
    }

    @Override
    public String toString() {
        return "Meal{" +
                "burger='" + burger + '\'' +
                ", fries='" + fries + '\'' +
                ", drink='" + drink + '\'' +
                '}';
    }
}

// 抽象建造者
public interface MealBuilder {
    void buildBurger();
    void buildFries();
    void buildDrink();
    Meal getMeal();
}

// 具体建造者：经典套餐
public class ClassicMealBuilder implements MealBuilder {
    private Meal meal = new Meal();

    @Override
    public void buildBurger() {
        meal.setBurger("Classic Burger");
    }

    @Override
    public void buildFries() {
        meal.setFries("Medium Fries");
    }

    @Override
    public void buildDrink() {
        meal.setDrink("Coke");
    }

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

// 指挥者
public class MealDirector {
    private MealBuilder builder;

    public MealDirector(MealBuilder builder) {
        this.builder = builder;
    }

    public void constructMeal() {
        builder.buildBurger();
        builder.buildFries();
        builder.buildDrink();
    }
}

优点：
- 可以灵活配置对象的构建过程。
缺点：
- 类的数量增多，代码复杂度增加。

2.2 进阶版：自定义套餐建造者

如果我们需要支持自定义套餐，建造者模式可以轻松扩展。

代码实现：

// 具体建造者：自定义套餐
public class CustomMealBuilder implements MealBuilder {
    private Meal meal = new Meal();

    @Override
    public void buildBurger() {
        meal.setBurger("Custom Burger");
    }

    @Override
    public void buildFries() {
        meal.setFries("Large Fries");
    }

    @Override
    public void buildDrink() {
        meal.setDrink("Sprite");
    }

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

优点：
- 支持自定义配置，灵活性更高。
缺点：
- 类的数量进一步增多，代码复杂度更高。

2.3 终极版：链式调用建造者

如果我们需要更简洁的代码，可以使用链式调用建造者。

代码实现：

public class Meal {
    private String burger;
    private String fries;
    private String drink;

    public Meal setBurger(String burger) {
        this.burger = burger;
        return this;
    }

    public Meal setFries(String fries) {
        this.fries = fries;
        return this;
    }

    public Meal setDrink(String drink) {
        this.drink = drink;
        return this;
    }

    @Override
    public String toString() {
        return "Meal{" +
                "burger='" + burger + '\'' +
                ", fries='" + fries + '\'' +
                ", drink='" + drink + '\'' +
                '}';
    }
}

public class MealBuilder {
    private Meal meal = new Meal();

    public MealBuilder buildBurger(String burger) {
        meal.setBurger(burger);
        return this;
    }

    public MealBuilder buildFries(String fries) {
        meal.setFries(fries);
        return this;
    }

    public MealBuilder buildDrink(String drink) {
        meal.setDrink(drink);
        return this;
    }

    public Meal getMeal() {
        return meal;
    }
}