建造者模式（Builder Pattern）是一种创建型设计模式，用于创建一个复杂的对象，同时允许用户只通过指定复杂对象的类型和内容就能构建它们

建造者模式（Builder Pattern）是一种创建型设计模式，用于创建一个复杂的对象，同时允许用户只通过指定复杂对象的类型和内容就能构建它们，隐藏了对象内部的构建细节。建造者模式将对象的构建过程与对象的表示分离，使得相同的构建过程可以创建不同的表示。

1. 建造者模式的主要角色

• 产品角色（Product）：表示被构造的复杂对象，通常包含多个成员变量。
• 抽象建造者（Builder）：定义创建一个产品对象各个部件的抽象接口，通常是一个接口或抽象类。
• 具体建造者（ConcreteBuilder）：实现抽象建造者接口，构造和装配各个部件，定义并明确它所创建的表示，并提供一个接口用于获取其创建的产品。
• 指挥者（Director）：构造一个使用Builder接口的对象，它主要负责调用建造者对象的方法，协调各个部件的构建，但不涉及具体的产品信息。

2. 建造者模式的实现步骤

1. 定义产品类：定义一个复杂对象的类，包含多个成员变量。
2. 定义抽象建造者类：定义一个接口或抽象类，声明创建产品各个部件的方法。
3. 实现具体建造者类：实现抽象建造者接口，具体实现创建产品各个部件的方法，并提供一个方法返回最终的产品。
4. 定义指挥者类：负责调用具体建造者的方法来构建产品，但不涉及具体的产品信息。
5. 客户端代码：通过指挥者类来构建产品，最终获取到具体的产品对象。

3. 示例代码

假设我们要构建一个汽车对象，汽车包含多个部件，如发动机、轮胎、座椅等。我们将使用建造者模式来实现这个需求。

3.1 定义产品类

public class Car {
    private String engine;
    private String tires;
    private String seats;

    public void setEngine(String engine) {
        this.engine = engine;
    }

    public void setTires(String tires) {
        this.tires = tires;
    }

    public void setSeats(String seats) {
        this.seats = seats;
    }

    @Override
    public String toString() {
        return "Car{" +
                "engine='" + engine + '\'' +
                ", tires='" + tires + '\'' +
                ", seats='" + seats + '\'' +
                '}';
    }
}

3.2 定义抽象建造者类

public abstract class CarBuilder {
    protected Car car;

    public Car getCar() {
        return car;
    }

    public abstract void buildEngine();
    public abstract void buildTires();
    public abstract void buildSeats();
}

3.3 实现具体建造者类

public class ConcreteCarBuilder extends CarBuilder {
    public ConcreteCarBuilder() {
        car = new Car();
    }

    @Override
    public void buildEngine() {
        car.setEngine("V8 Engine");
    }

    @Override
    public void buildTires() {
        car.setTires("High-performance Tires");
    }

    @Override
    public void buildSeats() {
        car.setSeats("Leather Seats");
    }
}

3.4 定义指挥者类

public class CarDirector {
    private CarBuilder carBuilder;

    public CarDirector(CarBuilder carBuilder) {
        this.carBuilder = carBuilder;
    }

    public Car constructCar() {
        carBuilder.buildEngine();
        carBuilder.buildTires();
        carBuilder.buildSeats();
        return carBuilder.getCar();
    }
}

3.5 客户端代码

public class Main {
    public static void main(String[] args) {
        CarBuilder carBuilder = new ConcreteCarBuilder();
        CarDirector carDirector = new CarDirector(carBuilder);
        Car car = carDirector.constructCar();
        System.out.println(car);
    }
}

4. 输出结果

运行客户端代码，输出结果如下：

Car{engine='V8 Engine', tires='High-performance Tires', seats='Leather Seats'}

5. 建造者模式的优点

• 封装性好：将复杂对象的构建过程与表示分离，隐藏了对象内部的构建细节。
• 易于扩展：新增产品时，只需添加新的具体建造者类，无需修改现有代码。
• 便于控制细节：客户端可以通过指挥者类来控制构建过程，灵活地选择构建哪些部件。

6. 适用场景

建造者模式适用于以下场景：

• 当需要构建一个复杂对象，且对象的构建过程复杂，包含多个步骤和多个部件时。
• 当需要隐藏对象的构建细节，只暴露一个简单的接口给客户端时。
• 当需要构建的对象有多种不同的表示时。

通过建造者模式，可以清晰地分离对象的构建过程和表示，使得代码更加模块化、易于维护和扩展。
建造者模式（Builder Pattern）是一种创建型设计模式，它允许你将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。这种模式特别适用于创建复杂对象，这些对象的构建过程涉及多个步骤或组件。

核心概念

• 产品（Product）：要构建的复杂对象。
• 抽象建造者（Builder）：定义构建产品各个部分的抽象接口。
• 具体建造者（Concrete Builder）：实现抽象建造者接口，构建和装配产品的各个部分。
• 指挥者（Director）：负责使用建造者接口构建产品，控制构建过程的顺序。

主要作用

1. 分离复杂对象的构建和表示：使得构建过程可以独立于表示，方便扩展和维护。
2. 分步构建对象：将对象构建过程分解为多个步骤，简化构建逻辑。
3. 控制构建过程：通过指挥者类可以精确控制构建步骤的顺序和方式。

典型场景

• 对象构建过程复杂：当一个对象需要多个步骤才能完成构建时。
• 构建不同表示：同一构建过程需要创建不同配置或表示的对象。
• 参数配置灵活：对象有很多可选参数，使用建造者模式可以避免构造函数参数过多的问题。

示例结构

下面是建造者模式的一个简单示例结构（Python 伪代码）：

# 产品类
class Product:
    def __init__(self):
        self.parts = []
    
    def add_part(self, part):
        self.parts.append(part)
    
    def show(self):
        print("产品组成部分：")
        for part in self.parts:
            print(f"- {part}")

# 抽象建造者
class Builder:
    def build_part_a(self):
        pass
    
    def build_part_b(self):
        pass
    
    def get_result(self):
        pass

# 具体建造者
class ConcreteBuilder1(Builder):
    def __init__(self):
        self.product = Product()
    
    def build_part_a(self):
        self.product.add_part("部件A1")
    
    def build_part_b(self):
        self.product.add_part("部件B1")
    
    def get_result(self):
        return self.product

# 指挥者
class Director:
    def __init__(self, builder):
        self.builder = builder
    
    def construct(self):
        self.builder.build_part_a()
        self.builder.build_part_b()
        return self.builder.get_result()

# 使用示例
builder = ConcreteBuilder1()
director = Director(builder)
product = director.construct()
product.show()

优点

• 解耦构建过程和表示：产品的构建和表示分离，易于扩展新的表示。
• 分步构建：复杂对象的构建被分解为多个步骤，便于控制和理解。
• 控制细节：指挥者类可以精确控制构建过程，隐藏产品的创建细节。

缺点

• 增加代码复杂度：需要创建多个类（建造者、具体建造者、指挥者），增加了代码量。
• 适用范围有限：只适用于构建过程稳定的对象，如果构建过程经常变化，可能需要频繁修改建造者接口。

与工厂模式的区别

• 工厂模式：关注整体对象的创建，通常是一个方法创建整个对象。
• 建造者模式：关注对象的分步构建，允许更精细地控制构建过程，适合创建复杂对象。

建造者模式在实际开发中常用于创建配置对象、UI组件、复杂数据结构等，特别是当对象构建过程涉及多个可选参数或复杂步骤时。