设计模式之建造者模式（通俗易懂—代码辅助理解【Java版】）

引言

设计模式是解决软件设计中常见问题的典型方法和方案。建造者模式（Builder Pattern）是一种创建型设计模式，旨在分离复杂对象的构建和表示，使得相同的构建过程可以创建不同的表示。本文将通过Java语言对建造者模式进行深入讲解，并通过具体实例来帮助理解。

建造者模式简介

建造者模式是将一个复杂对象的构建过程分解为多个简单的步骤，允许你按步骤逐步构建一个复杂的对象。这个模式通常用于创建复杂对象时，通过构建的不同阶段来细化对象的构建过程，从而使得创建对象的代码更具灵活性和可维护性。

主要角色

产品（Product）：被创建的复杂对象。
建造者（Builder）：定义了创建产品的各个部件的抽象接口。
具体建造者（ConcreteBuilder）：实现了建造者接口，构造和装配产品的各个部件。
指挥者（Director）：负责按照一定的顺序使用建造者接口来构建产品。

建造者模式的组成

1. 产品（Product）

产品类是最终要被创建的复杂对象。它定义了产品的基本属性和构造的各个部分。

2. 建造者（Builder）

建造者接口定义了创建产品的各个部分的方法，包括初始化、组装以及最后获取产品等步骤。它通常包含方法定义，不涉及具体的实现。

3. 具体建造者（ConcreteBuilder）

具体建造者实现了建造者接口中的各个方法，并在这些方法中构建具体的产品。它通常会持有一个产品的实例，并提供获取产品的方法。

4. 指挥者（Director）

指挥者类负责调用具体建造者的方法来创建复杂的产品。它通常会定义构建产品的步骤和顺序。

建造者模式的优缺点

优点

分离复杂对象的构建与表示：建造者模式通过分离对象的构建过程和表示，增强了系统的灵活性。
构建过程独立于产品表示：可以使用不同的建造者来创建不同的表示，满足不同的需求。
易于维护和扩展：新增或修改产品的构建过程不会影响其他部分的代码。

缺点

建造者类多：每种产品都需要一个具体的建造者，可能导致建造者类的数量较多。
复杂的代码管理：若产品对象的构建过程非常复杂，建造者的代码也可能会变得难以维护。

建造者模式的应用场景

对象构建过程复杂：当创建一个复杂对象时，其构建过程分步骤进行更为方便。
需要创建多个不同的表示：同样的构建过程可以创建不同的表示或形式。
希望构建过程独立于产品表示：希望构建过程和最终产品的表示可以独立处理。

Java版建造者模式实例

下面我们将通过两个实例来演示建造者模式的实际应用。

实例 1：复杂对象的构建

假设我们要创建一个复杂的房屋对象。房屋包含多个部分，如地基、墙体、屋顶等。我们可以使用建造者模式来分步骤创建这个复杂的房屋对象。

产品类：House

javaCopy Code
public class House {
    private String foundation;
    private String walls;
    private String roof;

    // Getters and Setters
    public String getFoundation() { return foundation; }
    public void setFoundation(String foundation) { this.foundation = foundation; }

    public String getWalls() { return walls; }
    public void setWalls(String walls) { this.walls = walls; }

    public String getRoof() { return roof; }
    public void setRoof(String roof) { this.roof = roof; }

    @Override
    public String toString() {
        return "House [foundation=" + foundation + ", walls=" + walls + ", roof=" + roof + "]";
    }
}

建造者接口：HouseBuilder

javaCopy Code
public interface HouseBuilder {
    void buildFoundation();
    void buildWalls();
    void buildRoof();
    House getHouse();
}

具体建造者：ConcreteHouseBuilder

javaCopy Code
public class ConcreteHouseBuilder implements HouseBuilder {
    private House house;

    public ConcreteHouseBuilder() {
        this.house = new House();
    }

    @Override
    public void buildFoundation() {
        house.setFoundation("Concrete Foundation");
    }

    @Override
    public void buildWalls() {
        house.setWalls("Brick Walls");
    }

    @Override
    public void buildRoof() {
        house.setRoof("Wooden Roof");
    }

    @Override
    public House getHouse() {
        return this.house;
    }
}

指挥者：Director

javaCopy Code
public class Director {
    private HouseBuilder builder;

    public Director(HouseBuilder builder) {
        this.builder = builder;
    }

    public House constructHouse() {
        builder.buildFoundation();
        builder.buildWalls();
        builder.buildRoof();
        return builder.getHouse();
    }
}

客户端代码：Client

javaCopy Code
public class Client {
    public static void main(String[] args) {
        HouseBuilder builder = new ConcreteHouseBuilder();
        Director director = new Director(builder);
        House house = director.constructHouse();
        System.out.println(house);
    }
}

实例 2：产品的可变部分

在另一个例子中，我们将演示如何使用建造者模式来创建不同配置的电脑系统。电脑系统包含不同的硬件组件，如CPU、内存和存储。

产品类：Computer

javaCopy Code
public class Computer {
    private String cpu;
    private String memory;
    private String storage;

    // Getters and Setters
    public String getCpu() { return cpu; }
    public void setCpu(String cpu) { this.cpu = cpu; }

    public String getMemory() { return memory; }
    public void setMemory(String memory) { this.memory = memory; }

    public String getStorage() { return storage; }
    public void setStorage(String storage) { this.storage = storage; }

    @Override
    public String toString() {
        return "Computer [cpu=" + cpu + ", memory=" + memory + ", storage=" + storage + "]";
    }
}

建造者接口：ComputerBuilder

javaCopy Code
public interface ComputerBuilder {
    void buildCpu();
    void buildMemory();
    void buildStorage();
    Computer getComputer();
}

具体建造者：GamingComputerBuilder

javaCopy Code
public class GamingComputerBuilder implements ComputerBuilder {
    private Computer computer;

    public GamingComputerBuilder() {
        this.computer = new Computer();
    }

    @Override
    public void buildCpu() {
        computer.setCpu("High-end Gaming CPU");
    }

    @Override
    public void buildMemory() {
        computer.setMemory("32GB RAM");
    }

    @Override
    public void buildStorage() {
        computer.setStorage("1TB SSD");
    }

    @Override
    public Computer getComputer() {
        return this.computer;
    }
}

具体建造者：OfficeComputerBuilder

javaCopy Code
public class OfficeComputerBuilder implements ComputerBuilder {
    private Computer computer;

    public OfficeComputerBuilder() {
        this.computer = new Computer();
    }

    @Override
    public void buildCpu() {
        computer.setCpu("Mid-range CPU");
    }

    @Override
    public void buildMemory() {
        computer.setMemory("16GB RAM");
    }

    @Override
    public void buildStorage() {
        computer.setStorage("512GB SSD");
    }

    @Override
    public Computer getComputer() {
        return this.computer;
    }
}

指挥者：ComputerDirector

javaCopy Code
public class ComputerDirector {
    private ComputerBuilder builder;

    public ComputerDirector(ComputerBuilder builder) {
        this.builder = builder;
    }

    public Computer constructComputer() {
        builder.buildCpu();
        builder.buildMemory();
        builder.buildStorage();
        return builder.getComputer();
    }
}