目录

• • 一、 啥是建造者模式？
  • 二、 为什么要用建造者模式？
  • 三、 建造者模式怎么实现？
  • 四、 建造者模式的应用场景
  • 五、 建造者模式的优点和缺点
  • 六、 总结

🌟我的其他文章也讲解的比较有趣😁，如果喜欢博主的讲解方式，可以多多支持一下，感谢🤗！
🌟了解原型模式请看： (四)趣学设计模式 之 原型模式！

这篇文章带你详细认识一下设计模式中的建造者模式

一、 啥是建造者模式？

建造者模式，就像组装乐高玩具 🧸！ 你有一堆零件，想要拼出一个复杂的模型，比如一辆汽车 🚗 或者一栋房子 🏠，但是直接拼太麻烦了，容易出错，而且不同的汽车和房子，拼装步骤可能不一样。 建造者模式就是把组装过程分解成一步一步的，每一步负责一部分，比如安装引擎、安装轮胎、刷油漆等等，每一步都由专门的工人（具体建造者）来完成，最后把所有部分组合起来，就得到了完整的模型！

• 对象创建过程复杂： 就像盖房子 🏠，需要打地基、砌墙、安装门窗、装修等等，一步都不能少，而且顺序也很重要！
• 需要灵活控制对象创建过程： 就像定制汽车 🚗，可以根据自己的喜好选择不同的引擎、轮胎、颜色等等，每个配置都会影响最终的汽车！
• 希望隐藏对象内部的构建细节： 就像吃汉堡 🍔，你只想吃，不想知道它是怎么做的，更不想知道厨师是怎么一步一步把汉堡做出来的！

二、 为什么要用建造者模式？

用建造者模式，好处多多：

• 分工明确： 每个建造者负责一部分，职责清晰，代码更易维护！ 就像盖房子，有专门的泥瓦匠砌墙，有专门的木匠安装门窗，每个人都只负责自己的部分，不会互相干扰！
• 灵活定制： 可以根据需要选择不同的建造者，创建不同配置的对象！ 就像定制汽车，可以选择不同的引擎、轮胎、颜色等等，最终得到一辆完全符合自己需求的汽车！
• 隐藏细节： 客户端不用关心对象的构建过程，只需要知道最终的结果！ 就像吃汉堡，你只需要知道汉堡很好吃，不用关心厨师是怎么一步一步把汉堡做出来的！
• 代码复用： 相同的构建步骤可以被不同的建造者复用！ 就像盖房子，不同的房子可能都需要打地基，这个步骤就可以被不同的建造者复用！

三、 建造者模式怎么实现？

建造者模式主要包含以下几个角色：

• 产品（Product）： 最终要创建的对象，就像乐高模型、汽车、房子等等！
• 抽象建造者（Builder）： 定义了构建产品的接口，就像乐高说明书、汽车设计图纸、房屋设计图纸等等！ 它规定了构建产品的各个步骤，但是具体的实现由具体建造者来完成！
• 具体建造者（ConcreteBuilder）： 实现了抽象建造者的接口，负责构建产品的各个部分，就像乐高工人、汽车工人、建筑工人等等！ 他们按照抽象建造者的规定，一步一步地构建产品！
• 指挥者（Director）： 负责安排构建的顺序，就像乐高设计师、汽车设计师、房屋设计师等等！ 他们知道构建产品的正确顺序，并指挥具体建造者按照这个顺序来构建产品！

代码示例：

// 1. 产品类 (Product)
class Computer {
    private String cpu; // CPU
    private String ram; // 内存
    private String hardDisk; // 硬盘
    private String graphicsCard; // 显卡

    // 设置 CPU
    public void setCpu(String cpu) {
        this.cpu = cpu;
    }

    // 设置 内存
    public void setRam(String ram) {
        this.ram = ram;
    }

    // 设置 硬盘
    public void setHardDisk(String hardDisk) {
        this.hardDisk = hardDisk;
    }

    // 设置 显卡
    public void setGraphicsCard(String graphicsCard) {
        this.graphicsCard = graphicsCard;
    }

    // 重写 toString 方法，方便打印电脑信息
    @Override
    public String toString() {
        return "Computer{" +
                "cpu='" + cpu + '\'' +
                ", ram='" + ram + '\'' +
                ", hardDisk='" + hardDisk + '\'' +
                ", graphicsCard='" + graphicsCard + '\'' +
                '}';
    }
}

// 2. 抽象建造者 (Builder)
interface ComputerBuilder {
    void buildCpu(String cpu); // 构建 CPU
    void buildRam(String ram); // 构建 内存
    void buildHardDisk(String hardDisk); // 构建 硬盘
    void buildGraphicsCard(String graphicsCard); // 构建 显卡
    Computer build(); // 返回最终产品
}

// 3. 具体建造者 (ConcreteBuilder)
class GamingComputerBuilder implements ComputerBuilder {
    private Computer computer = new Computer(); // 创建一个电脑对象

    // 构建 CPU
    @Override
    public void buildCpu(String cpu) {
        computer.setCpu(cpu);
    }

    // 构建 内存
    @Override
    public void buildRam(String ram) {
        computer.setRam(ram);
    }

    // 构建 硬盘
    @Override
    public void buildHardDisk(String hardDisk) {
        computer.setHardDisk(hardDisk);
    }

    // 构建 显卡
    @Override
    public void buildGraphicsCard(String graphicsCard) {
        computer.setGraphicsCard(graphicsCard);
    }

    // 返回最终产品
    @Override
    public Computer build() {
        return computer;
    }
}

// 4. 指挥者 (Director)
class ComputerDirector {
    private ComputerBuilder builder; // 依赖一个 ComputerBuilder

    // 构造函数，传入一个 ComputerBuilder
    public ComputerDirector(ComputerBuilder builder) {
        this.builder = builder;
    }

    // 构建电脑
    public Computer construct(String cpu, String ram, String hardDisk, String graphicsCard) {
        builder.buildCpu(cpu); // 构建 CPU
        builder.buildRam(ram); // 构建 内存
        builder.buildHardDisk(hardDisk); // 构建 硬盘
        builder.buildGraphicsCard(graphicsCard); // 构建 显卡
        return builder.build(); // 返回最终产品
    }
}

// 5. 客户端使用
public class Client {
    public static void main(String[] args) {
        // 创建具体建造者
        GamingComputerBuilder gamingComputerBuilder = new GamingComputerBuilder();

        // 创建指挥者
        ComputerDirector computerDirector = new ComputerDirector(gamingComputerBuilder);

        // 构建电脑
        Computer gamingComputer = computerDirector.construct("Intel i9", "32GB", "1TB SSD", "Nvidia RTX 3080");

        // 打印电脑信息
        System.out.println("游戏电脑: " + gamingComputer);
    }
}

代码解释：

• Computer：产品类，表示电脑。 就像乐高模型，是最终要组装完成的东西！
• ComputerBuilder：抽象建造者，定义了构建电脑的接口。 就像乐高说明书，规定了组装电脑的各个步骤！
• GamingComputerBuilder：具体建造者，实现了 ComputerBuilder 接口，负责构建游戏电脑。 就像乐高工人，按照说明书一步一步地组装电脑！
• ComputerDirector：指挥者，负责安排构建的顺序。 就像乐高设计师，知道组装电脑的正确顺序，并指挥工人按照这个顺序来组装电脑！

输出结果：

游戏电脑: Computer{cpu='Intel i9', ram='32GB', hardDisk='1TB SSD', graphicsCard='Nvidia RTX 3080'}

分析：

客户端只需要告诉指挥者需要什么配置的电脑，指挥者会安排具体建造者一步一步地构建电脑，最后返回完整的电脑对象。 客户端不需要关心电脑是怎么一步一步组装起来的，只需要知道最终的结果！

四、 建造者模式的应用场景

• 创建复杂的对象： 就像创建汽车 🚗、房子 🏠、飞机 ✈️ 等等，需要多个步骤才能完成，而且每个步骤都很复杂！
• 需要灵活控制对象创建过程： 就像定制家具 🪑，可以根据自己的喜好选择不同的材料、颜色和尺寸，最终得到一件完全符合自己需求的家具！
• 需要隐藏对象内部的构建细节： 就像制作蛋糕 🎂，你只想吃，不想知道它是怎么做的，更不想知道厨师是怎么一步一步把蛋糕做出来的！
• 需要创建不同表示的对象： 就像创建不同风格的房子 🏘️，可以使用不同的建造者来创建，比如现代风格的房子、古典风格的房子等等！

五、 建造者模式的优点和缺点

优点：

• 分工明确： 每个建造者负责一部分，职责清晰，代码更易维护！ 就像一个团队，每个人都只负责自己的部分，不会互相干扰，提高了工作效率！
• 灵活定制： 可以根据需要选择不同的建造者，创建不同配置的对象！ 就像定制汽车，可以选择不同的引擎、轮胎、颜色等等，最终得到一辆完全符合自己需求的汽车！
• 隐藏细节： 客户端不用关心对象的构建过程，只需要知道最终的结果！ 就像吃汉堡，你只需要知道汉堡很好吃，不用关心厨师是怎么一步一步把汉堡做出来的！
• 代码复用： 相同的构建步骤可以被不同的建造者复用！ 就像盖房子，不同的房子可能都需要打地基，这个步骤就可以被不同的建造者复用，减少了代码的重复！
• 易于扩展： 可以很容易地添加新的建造者，来创建新的对象类型！ 就像乐高玩具，可以不断推出新的模型，只需要添加新的乐高说明书和乐高工人即可！

缺点：

• 代码复杂： 需要创建多个类，代码量比较大！ 就像一个团队，需要更多的人员，增加了管理的复杂性！
• 抽象性高： 理解起来比较抽象，需要一定的设计经验！ 就像学习乐高说明书，需要一定的空间想象能力！
• 修改困难： 如果需要修改产品的内部结构，可能需要修改多个类！ 就像修改乐高模型，可能需要修改乐高说明书和乐高零件！

六、 总结

• 建造者模式就像组装乐高玩具，把复杂的对象创建过程分解成一步一步的！
• 适用于对象创建过程复杂、需要灵活控制对象创建过程、希望隐藏对象内部的构建细节的场景！
• 主要包含产品、抽象建造者、具体建造者和指挥者四个角色！
• 优点是分工明确、灵活定制、隐藏细节、代码复用、易于扩展！
• 缺点是代码复杂、抽象性高、修改困难！

希望这篇文章能让你彻底理解建造者模式！ 👍