对象创建_Builder

作者出版于 design_patterns

2023-07-15 约 1010 字预计阅读 3 分钟

对象创建模式

通过“对象创建”模式绕开 new，来避免对象创建(new)过程中所导致的紧耦合 (依赖具体类)，从而支持对象创建的稳定。它是接口抽象之后的第一步工作。

典型模式

Factory Method
Abstract Factory
Prototype
Builder

1 Builder 建造者模式

1.1 模式动机

在软件系统中，有时候面临着“一个复杂对象”的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。

如何应对这种变化？如何提供一种“封装机制“来隔离出“复杂对象的各个部分”的变化，从而保持系统中的“稳定构建算法”不随着需求改变而改变？

1.2 模式定义

将一个复杂对象的构建与其表示相分离，使得同样的构建过程(稳定)可以创建不同的表示(变化)。

1.3 模式示例代码

# include <iostream>
# include <string>

// 产品类：汽车
class Car {
public:
    void setBrand(const std::string& brand) {
        this->brand = brand;
    }

    void setModel(const std::string& model) {
        this->model = model;
    }

    void setColor(const std::string& color) {
        this->color = color;
    }

    void setYear(int year) {
        this->year = year;
    }

    void printInfo() {
        std::cout << "汽车信息：" << std::endl;
        std::cout << "品牌：" << brand << std::endl;
        std::cout << "型号：" << model << std::endl;
        std::cout << "颜色：" << color << std::endl;
        std::cout << "年份：" << year << std::endl;
    }

private:
    std::string brand;
    std::string model;
    std::string color;
    int year;
};

// 抽象建造者类：汽车建造者
class CarBuilder {
public:
    virtual void buildBrand() = 0;
    virtual void buildModel() = 0;
    virtual void buildColor() = 0;
    virtual void buildYear() = 0;
    virtual Car* getCar() = 0;
};

// 具体建造者类：SUV汽车建造者
class SUVBuilder : public CarBuilder {
public:
    SUVBuilder() {
        car = new Car();
    }

    void buildBrand() {
        car->setBrand("SUV");
    }

    void buildModel() {
        car->setModel("X5");
    }

    void buildColor() {
        car->setColor("黑色");
    }

    void buildYear() {
        car->setYear(2022);
    }

    Car* getCar() {
        return car;
    }

private:
    Car* car;
};

// 具体建造者类：轿车建造者
class SedanBuilder : public CarBuilder {
public:
    SedanBuilder() {
        car = new Car();
    }

    void buildBrand() {
        car->setBrand("轿车");
    }

    void buildModel() {
        car->setModel("Civic");
    }

    void buildColor() {
        car->setColor("红色");
    }

    void buildYear() {
        car->setYear(2023);
    }

    Car* getCar() {
        return car;
    }

private:
    Car* car;
};

// 指挥者类：汽车制造指挥者
class CarDirector {
public:
    Car* buildCar(CarBuilder* builder) {
        builder->buildBrand();
        builder->buildModel();
        builder->buildColor();
        builder->buildYear();
        return builder->getCar();
    }
};

int main() {
    // 创建汽车制造指挥者
    CarDirector director;

    // 创建SUV汽车建造者
    CarBuilder* suvBuilder = new SUVBuilder();

    // 制造SUV汽车
    Car* suvCar = director.buildCar(suvBuilder);
    suvCar->printInfo();

    // 创建轿车建造者
    CarBuilder* sedanBuilder = new SedanBuilder();

    // 制造轿车
    Car* sedanCar = director.buildCar(sedanBuilder);
    sedanCar->printInfo();

    // 释放内存
    delete suvBuilder;
    delete suvCar;
    delete sedanBuilder;
    delete sedanCar;

    return 0;
}

2 要点总结

Builder 模式主要用于“分步骤构建一个复杂的对象”。在这其中“分步骤“是一个稳定的算法，而复杂对象的各个部分则经常变化。变化点在哪里，封装哪里——Builder 模式主要在干应对“复杂对象各个部分“的频繁需求变动。其缺点在于难以应对“分步骤构建算法”的需求变动。在 Builder 模式中，要注意不同语言中构造器内调用虚函数的差别 (C++ vS。 C#)。

目录