网站开发人员知乎,oa系统登录界面,如何用asp做视频网站,wordpress怎么修改代码1 建造者模式的概念
建造者模式#xff08;Builder Pattern#xff09;是一种创建型设计模式#xff0c;也被称为生成器模式。它的核心思想是将一个复杂对象的构建与它的表示分离#xff0c;使得同样的构建过程可以创建不同的表示。
在建造者模式中#xff0c;通常包括以…1 建造者模式的概念
建造者模式Builder Pattern是一种创建型设计模式也被称为生成器模式。它的核心思想是将一个复杂对象的构建与它的表示分离使得同样的构建过程可以创建不同的表示。
在建造者模式中通常包括以下几个角色
1Builder 这是一个抽象接口定义了产品对象的各个组成成分的建造。它规定了要实现复杂对象的哪些部分的创建但并不涉及具体的对象部件的创建。 2ConcreteBuilder 这是实现了Builder接口的具体类它针对不同的商业逻辑具体化了复杂对象的各部分的创建。在建造过程完成后它提供产品的实例。 3Director 这是一个指挥者角色它调用具体建造者来创建复杂对象的各个部分。在指导者中不涉及具体产品的信息只负责保证对象各部分完整创建或按某种顺序创建。 4Product 这是最终要创建的复杂对象。
建造者模式允许用户只通过指定复杂对象的类型和内容来构建对象而不需要知道内部的具体构建细节。这种模式特别适用于构建具有多个组成部分的复杂对象且这些组成部分的构建过程可能会因具体需求而有所不同的情况。通过建造者模式可以使得同样的构建过程能够创建出不同的产品表示提高了系统的灵活性和可扩展性。
1.1 建造者模式的应用场景
建造者模式通常适用于以下应用场景
1对象结构复杂 当需要创建的对象具有复杂的内部结构包含多个组件或属性时可以使用建造者模式来构建这些对象。通过将构建过程分解为多个步骤可以更加清晰地管理和控制对象的创建过程。 2创建流程固定 当对象的创建流程是固定的即无论创建多少个对象其构建步骤都是相同的时候可以使用建造者模式。通过将这些步骤封装在建造者类中可以确保每次创建对象时都遵循相同的流程。 3需要控制创建过程 当需要更加灵活地控制对象的创建过程例如根据用户输入或运行时条件来决定对象的某些属性时可以使用建造者模式。通过在指挥者类中引入逻辑来控制对象的创建可以实现更加灵活的构建过程。 4代码易于阅读和维护 当需要创建的对象具有大量的参数或配置选项时使用建造者模式可以将这些参数和选项分组并封装在不同的建造者类中从而减少构造函数的复杂度使代码更加易读和易于维护。
在实际应用中建造者模式常用于构建具有多个组件或属性的复杂对象如UI界面、配置文件、数据库查询结果等。通过使用建造者模式可以更加清晰地组织代码提高代码的可读性和可维护性同时降低对象创建的复杂性。
1.2 建造者模式的优点和缺点
建造者模式的优点主要包括
1封装性好 建造者模式将对象的构建与它的表示分离使得客户端不必知道产品内部组成的细节隐藏了产品的内部实现细节提供了更好的封装性。 2扩展性好 由于具体的建造者是相互独立的因此易于扩展。如果需要增加新的部件或修改现有部件的创建方式只需要增加或修改相应的建造者类而不会影响其他已构建的部件和客户端代码。 3控制细节风险 建造者模式允许对创建过程逐步细化而不对其他模块产生任何影响便于控制细节风险。客户端只需要指定需要构建的对象类型和内容而不需要了解具体的构建细节从而降低了客户端代码的复杂性。
然而建造者模式也存在一些缺点
1使用范围受限 建造者模式所创建的产品一般具有较多的共同点其组成部分相似。如果产品之间的差异性很大例如很多组成部分都不相同不适合使用建造者模式因此其使用范围受到一定的限制。 2可能导致系统庞大 如果产品的内部变化复杂可能需要定义很多具体建造者类来实现这种变化导致系统变得很庞大。这会增加系统的理解难度和运行成本因为需要维护大量的建造者类。
综上所述建造者模式在创建具有复杂内部结构和多个组件的对象时非常有用可以提供良好的封装性、扩展性和对细节的控制。然而它也有一些限制特别是在产品差异性大或内部变化复杂的情况下。因此在使用建造者模式时需要权衡其优点和缺点并根据具体的应用场景做出决策。
2 建造者模式的实现步骤
本章节使用一个建造房子的样例来讲解建造者模式的实现步骤。
2.1 定义产品Product类
首先定义 Product 类它表示最终要构建的对象。在本章节的例子中构建一个 House 类
#include iostream
#include memory
#include string class House
{
public:void setWalls(const std::string walls) {this-walls walls;}void setRoof(const std::string roof) {this-roof roof;}void setFloors(const std::string floors) {this-floors floors;}void showHouseDetails() const {std::cout Walls: walls std::endl;std::cout Roof: roof std::endl;std::cout Floors: floors std::endl;}private:std::string walls;std::string roof;std::string floors;
};2.2 定义抽象建造者Builder接口
接下来定义一个 Builder 抽象接口它声明了构建 House 对象所需的方法
class HouseBuilder
{
public:virtual ~HouseBuilder() default;virtual void buildWalls() 0;virtual void buildRoof() 0;virtual void buildFloors() 0;virtual std::shared_ptrHouse getHouse() 0;
};2.3 定义具体建造者ConcreteBuilder类
然后创建实现 HouseBuilder 接口的 ConcreteBuilder 类。这个类将包含构建 House 对象所需的具体实现
class ConcreteHouseBuilder : public HouseBuilder
{
public:ConcreteHouseBuilder() : house(std::make_sharedHouse()) {}void buildWalls() override {house-setWalls(Concrete walls);}void buildRoof() override {house-setRoof(Concrete roof);}void buildFloors() override {house-setFloors(Concrete floors);}std::shared_ptrHouse getHouse() override{return std::move(house);}private:std::shared_ptrHouse house;
};2.4 定义指挥者Director类
接下来创建一个 Director 类它负责指挥 Builder 对象来构建 Product 对象
class HouseDirector
{
public:HouseDirector(std::shared_ptrHouseBuilder builder) : builder(builder) {}void constructHouse() {builder-buildWalls();builder-buildRoof();builder-buildFloors();}std::shared_ptrHouse getHouse(){return builder-getHouse();}private:std::shared_ptrHouseBuilder builder;};2.5 客户端使用
最后在 main 函数中使用这些类来构建 House 对象
int main()
{// 创建具体建造者对象 auto builder std::make_sharedConcreteHouseBuilder();// 创建指挥者对象并将建造者传递给指挥者 HouseDirector director(builder);// 通过指挥者构建产品 director.constructHouse();// 获取并显示构建好的产品 auto house director.getHouse();house-showHouseDetails();return 0;
}上面代码的输出为
Walls: Concrete walls
Roof: Concrete roof
Floors: Concrete floors在上面代码中使用 std::make_shared 来创建 ConcreteHouseBuilder 对象并将其传递给 HouseDirector 。HouseDirector 通过调用 concreteHouseBuilder 的方法逐步构建了一个 House 对象并通过 getHouse 方法返回了 House 对象的所有权。最后获取这个构建好的 House 对象并显示其对象细节。
3 建造者模式的案例解析
3.1 对象结构复杂场景下使用建造者模式
如下的样例将展示如何使用建造者模式来构建一个 Computer 对象其中包含 Processor 和 Memory 两个子组件为了简化代码实际一个电脑的子组件会很多。
首先定义各个子组件以及 Computer 类
#include iostream
#include memory
#include string // 子组件类
class Processor
{
public:void setSpeed(int speed) { m_speed speed; }void setCores(int cores) { m_cores cores; }void showDetails() const {std::cout Processor: m_speed MHz, m_cores cores std::endl;}private:int m_speed;int m_cores;
};class Memory
{
public:void setSize(int size) { m_size size; }void setType(const std::string type) { m_type type; }void showDetails() const {std::cout Memory: m_size GB, m_type RAM std::endl;}private:int m_size;std::string m_type;
};// 产品类
class Computer {
public:void setProcessor(std::shared_ptrProcessor processor) { m_processor processor; }void setMemory(std::shared_ptrMemory memory) { m_memory memory; }void showDetails() const {m_processor-showDetails();m_memory-showDetails();}private:std::shared_ptrProcessor m_processor;std::shared_ptrMemory m_memory;
};接下来定义抽象建造者接口和具体的建造者类
// 产品类
class Computer {
public:void setProcessor(std::shared_ptrProcessor processor) { m_processor processor; }void setMemory(std::shared_ptrMemory memory) { m_memory memory; }void showDetails() const {m_processor-showDetails();m_memory-showDetails();}private:std::shared_ptrProcessor m_processor;std::shared_ptrMemory m_memory;
};// 抽象建造者接口
class ComputerBuilder
{
public:virtual ~ComputerBuilder() default;virtual void buildProcessor() 0;virtual void buildMemory() 0;virtual std::shared_ptrComputer getComputer() 0;
};// 具体建造者类
class GamingComputerBuilder : public ComputerBuilder
{
public:GamingComputerBuilder() : m_computer(std::make_sharedComputer()) {m_processor std::make_sharedProcessor();m_memory std::make_sharedMemory();}void buildProcessor() override {m_processor-setSpeed(3500);m_processor-setCores(6);}void buildMemory() override {m_memory-setSize(16);m_memory-setType(DDR4);}std::shared_ptrComputer getComputer() override {m_computer-setProcessor(m_processor);m_computer-setMemory(m_memory);return m_computer;}private:std::shared_ptrComputer m_computer;std::shared_ptrProcessor m_processor;std::shared_ptrMemory m_memory;
};然后定义 Director 类负责指导 Builder 对象如何构建最终的产品
class Director
{
public:Director(std::shared_ptrComputerBuilder builder) : m_builder(builder) {}void constructComputer() {m_builder-buildProcessor();m_builder-buildMemory();}std::shared_ptrComputer getComputer() {return m_builder-getComputer();}private:std::shared_ptrComputerBuilder m_builder;
};最后在 main 函数中使用 Director 和 GamingComputerBuilder 来构建一个 Computer 对象
int main()
{// 创建具体的建造者对象 std::shared_ptrComputerBuilder builder std::make_sharedGamingComputerBuilder();// 创建导演对象并将建造者对象传递给它 Director director(builder);// 指导构建过程 director.constructComputer();// 获取构建好的产品 std::shared_ptrComputer computer director.getComputer();// 展示产品详情 computer-showDetails();return 0;
}上面代码的输出为
Processor: 3500 MHz, 6 cores
Memory: 16 GB, DDR4 RAM3.2 对象结构复杂场景下使用建造者模式
在创建流程固定的场景下可以使用一个简单的 Builder 类来封装一个固定流程的构建过程。这种场景下Builder 类会提供一系列的方法来逐步构建对象并最终提供一个方法来获取构建好的对象。客户端代码则直接调用 Builder 的方法来构建对象。 如下为样例代码
#include iostream
#include memory
#include string // 产品类
class Product
{
public:void show() const {std::cout Product built with parts: partA , partB , partC std::endl;}public:std::string partA;std::string partB;std::string partC;
};// 建造者类
class Builder
{
public:Builder() { m_product std::make_sharedProduct(); }// 初始化产品 void setPartA(const std::string partA) { m_product-partA partA; }void setPartB(const std::string partB) { m_product-partB partB; }void setPartC(const std::string partC) { m_product-partC partC; }// 构建并返回产品 std::shared_ptrProduct build() {// 在这里可以添加一些额外的构建逻辑return m_product;}private:std::shared_ptrProduct m_product;
};int main()
{// 创建建造者对象 Builder builder;// 通过建造者设置产品的各个部分 builder.setPartA(Part A content);builder.setPartB(Part B content);builder.setPartC(Part C content);// 构建并获取产品 auto product builder.build();// 展示产品 product-show();return 0;
}上面代码的输出为
Product built with parts: Part A content, Part B content, Part C content在上面代码中Product 类是一个简单的产品类包含三个私有成员变量。Builder 类封装了 Product 对象的构建过程它提供了三个方法来设置产品的各个部分以及一个 Build 方法来构建并返回产品对象。
在 main 函数中客户端代码创建了 Builder 对象并通过调用 setPartA、setPartB 和 setPartC 方法来设置产品的各个部分。然后调用 Build 方法来构建产品对象并存储在 std::shared_ptr 中。最后调用Show方法来展示构建好的产品。
上面代码展示了如何在创建流程固定的情况下使用建造者模式。Builder 类确保了产品总是按照相同的步骤和顺序被构建而客户端代码则不需要了解具体的构建细节。这有助于保持代码的清晰和易于维护。
4 建造者模式与工厂模式的比较
建造者模式和工厂模式都是面向对象设计模式中常用的创建型模式它们的主要区别在于关注点、对象创建过程以及复杂度。
关注点 工厂模式主要关注对象的创建而建造者模式不仅关注对象的创建还关注对象的组成部分以及这些部分的构建顺序。 对象创建过程 工厂模式通常提供一个统一的接口来创建对象而不需要知道具体创建对象的类。而建造者模式则更加关注对象的构建过程它允许用户逐步添加对象的各个部分并控制这些部分的构建顺序。 复杂度 工厂模式通常用于创建简单对象而建造者模式更适合用于创建复杂对象。建造者模式允许用户将复杂对象的构建过程分解为多个步骤每个步骤只关注对象的一个或几个部分从而降低了构建过程的复杂度。
总的来说工厂模式和建造者模式都是用于创建对象的模式但它们在关注点、对象创建过程以及复杂度上有所不同。选择哪种模式取决于具体的应用场景和需求。
