不想一次性得到完整的复杂对象？一步一步地创造出你需要的每个部分，最后组合成完整的大作。

你是不是曾经尝试过做一道非常复杂的菜肴？比如大餐中的“北京烤鸭”，其中的每个步骤都需要精细的工艺、每个配料的搭配都至关重要。你不会一次性把所有食材、工具、步骤混在一起做吧？你会一步一步地准备，每次加入一个元素，然后慢慢完成整个过程，最终呈现出完美的成品。

这就像是建造者模式：它允许你一步一步地构建复杂对象，而不是一次性地将一切都交给你。这不仅能帮助你更好地控制每个细节，还能确保最终的产品在每个环节都符合预期。

趣味解读：像做大餐一样，慢慢来！

想象一下，你在做一份盛大的宴会菜单。你打算做一道非常复杂的三明治，每一层都要用不同的食材：生菜、番茄、烤鸡肉、芝士、酱料……你不会一开始就把所有的食材直接堆成一堆，而是慢慢地，每放一层，都会检查一下，确保每一部分都做得完美。这样，最后你就能吃到一份层次分明、味道绝妙的三明治。

在这里，你就是建造者，而三明治就是你一步一步“建造”出来的复杂对象。每放一层，都像是建造者模式中的一步，最后形成完美的“大作”。你完全掌控了制作过程，并且每个细节都能自定义。

Java代码案例：电脑建造者

假设你正在开发一个应用，让用户根据自己的需求来定制一台电脑。每台电脑都有多个组成部分（如主机、显示器、键盘、鼠标等），而每个组成部分又可以有不同的配置（比如显示器的尺寸、键盘的类型）。你不想让用户一次性创建完整的电脑，而是希望通过一步步地选择不同的配件，最终组合成一台完整的电脑。

// 1. 定义电脑的各个组件
class CPU {
    private String model;
​
    public CPU(String model) {
        this.model = model;
    }
​
    public void show() {
        System.out.println("CPU: " + model);
    }
}
​
class RAM {
    private String size;
​
    public RAM(String size) {
        this.size = size;
    }
​
    public void show() {
        System.out.println("RAM: " + size);
    }
}
​
class Monitor {
    private String resolution;
​
    public Monitor(String resolution) {
        this.resolution = resolution;
    }
​
    public void show() {
        System.out.println("Monitor: " + resolution);
    }
}
​
// 2. 定义建造者接口
interface ComputerBuilder {
    void buildCPU();
    void buildRAM();
    void buildMonitor();
    Computer getResult();
}
​
// 3. 具体建造者
class GamingComputerBuilder implements ComputerBuilder {
    private Computer computer = new Computer();
​
    @Override
    public void buildCPU() {
        computer.setCpu(new CPU("Intel Core i9"));
    }
​
    @Override
    public void buildRAM() {
        computer.setRam(new RAM("32GB"));
    }
​
    @Override
    public void buildMonitor() {
        computer.setMonitor(new Monitor("4K"));
    }
​
    @Override
    public Computer getResult() {
        return computer;
    }
}
​
// 4. 电脑类，包含组成部分
class Computer {
    private CPU cpu;
    private RAM ram;
    private Monitor monitor;
​
    public void setCpu(CPU cpu) {
        this.cpu = cpu;
    }
​
    public void setRam(RAM ram) {
        this.ram = ram;
    }
​
    public void setMonitor(Monitor monitor) {
        this.monitor = monitor;
    }
​
    public void show() {
        cpu.show();
        ram.show();
        monitor.show();
    }
}
​
// 5. 导演类
class Director {
    private ComputerBuilder builder;
​
    public Director(ComputerBuilder builder) {
        this.builder = builder;
    }
​
    public Computer construct() {
        builder.buildCPU();
        builder.buildRAM();
        builder.buildMonitor();
        return builder.getResult();
    }
}
​
public class Main {
    public static void main(String[] args) {
        ComputerBuilder gamingComputerBuilder = new GamingComputerBuilder();
        Director director = new Director(gamingComputerBuilder);
        
        Computer gamingPC = director.construct();
        gamingPC.show();
    }
}

解析：

  • 建造者接口（ComputerBuilder）：定义了构建电脑的各个部分（CPU、RAM、Monitor）的方法。

  • 具体建造者（GamingComputerBuilder）：负责实际构建一台游戏电脑，逐步添加不同的组件。

  • 电脑类（Computer）：最终的产品类，包含所有的电脑组件。

  • 导演类（Director）：负责指挥整个建造过程，确保每个步骤按照顺序进行，并最终获得完整的电脑对象。

在这个例子中，用户不需要一步到位就得到一个完整的电脑，而是通过建造者模式，逐步添加不同的配件，最后组合成一台符合需求的高端游戏电脑。

实际应用场景：

  • 复杂对象构建：如果你正在开发一个复杂的对象，它有多个不同的部分，且每部分有不同的配置，建造者模式可以让你按需逐步构建，避免一开始就让用户面临所有的选择。

  • 订单系统：比如一个在线购物平台，用户可以选择不同的商品、数量、包装方式等。建造者模式可以帮助你逐步创建最终的订单，确保每个选择都符合用户的需求。

  • 游戏角色创建：在游戏中，角色通常有很多可选项（如武器、装备、技能等），通过建造者模式，可以让玩家一步步定制自己的角色，而不需要一开始就决定好所有的内容。

总结

建造者模式就像是做一道复杂的菜肴或制作一款定制商品。你不需要一开始就决定所有细节，而是通过一步步的操作，慢慢构建出符合你需求的完整对象。通过建造者模式，我们可以更灵活地创建复杂对象，保持代码的清晰和可扩展性，同时也让用户体验更加顺畅。