工厂模式 - 工厂方法模式、抽象工厂模式

🕗 发布于 2025-01-23 05:54 c++ 开发语言

引言

工厂模式（Factory Pattern）是设计模式中创建型模式的一种，它提供了一种创建对象的最佳方式。工厂模式的核心思想是将对象的创建与使用分离，使得代码更加灵活、可扩展。工厂模式主要分为两种：工厂方法模式和抽象工厂模式。

本文将详细介绍工厂方法模式和抽象工厂模式的概念、实现方式以及在C++中的应用。

工厂方法模式

概念

工厂方法模式（Factory Method Pattern）定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法模式让类的实例化推迟到子类。

优点

解耦：将对象的创建与使用分离，降低代码的耦合度。
扩展性好：新增产品类时，只需增加相应的工厂类，无需修改现有代码。
符合开闭原则：对扩展开放，对修改关闭。

缺点

类的数量增加：每增加一个产品类，就需要增加一个对应的工厂类，导致类的数量增加。
复杂性增加：对于简单的对象创建，使用工厂方法模式可能会增加代码的复杂性。

实现

下面是一个简单的工厂方法模式的实现示例：

#include <iostream>
#include <string>

// 产品接口
class Product {
public:
    virtual ~Product() {}
    virtual void use() = 0;
};

// 具体产品A
class ProductA : public Product {
public:
    void use() override {
        std::cout << "Using Product A" << std::endl;
    }
};

// 具体产品B
class ProductB : public Product {
public:
    void use() override {
        std::cout << "Using Product B" << std::endl;
    }
};

// 工厂接口
class Factory {
public:
    virtual ~Factory() {}
    virtual Product* createProduct() = 0;
};

// 具体工厂A
class FactoryA : public Factory {
public:
    Product* createProduct() override {
        return new ProductA();
    }
};

// 具体工厂B
class FactoryB : public Factory {
public:
    Product* createProduct() override {
        return new ProductB();
    }
};

int main() {
    Factory* factoryA = new FactoryA();
    Product* productA = factoryA->createProduct();
    productA->use();

    Factory* factoryB = new FactoryB();
    Product* productB = factoryB->createProduct();
    productB->use();

    delete productA;
    delete productB;
    delete factoryA;
    delete factoryB;

    return 0;
}

应用场景

工厂方法模式适用于以下场景：

不确定对象的类型：当创建对象时，不确定具体要创建哪种类型的对象。
需要扩展：当需要扩展系统，增加新的产品类时，使用工厂方法模式可以避免修改现有代码。

抽象工厂模式

概念

抽象工厂模式（Abstract Factory Pattern）提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。抽象工厂模式是工厂方法模式的扩展，它用于创建一组相关的对象。

优点

高内聚：将相关的产品族集中在一起创建，保证产品族的一致性。
解耦：将产品的创建与使用分离，降低代码的耦合度。
符合开闭原则：对扩展开放，对修改关闭。

缺点

类的数量增加：每增加一个产品族，就需要增加一个对应的工厂类，导致类的数量增加。
复杂性增加：对于简单的对象创建，使用抽象工厂模式可能会增加代码的复杂性。

实现

下面是一个简单的抽象工厂模式的实现示例：

#include <iostream>
#include <string>

// 抽象产品A
class AbstractProductA {
public:
    virtual ~AbstractProductA() {}
    virtual void use() = 0;
};

// 具体产品A1
class ProductA1 : public AbstractProductA {
public:
    void use() override {
        std::cout << "Using Product A1" << std::endl;
    }
};

// 具体产品A2
class ProductA2 : public AbstractProductA {
public:
    void use() override {
        std::cout << "Using Product A2" << std::endl;
    }
};

// 抽象产品B
class AbstractProductB {
public:
    virtual ~AbstractProductB() {}
    virtual void use() = 0;
};

// 具体产品B1
class ProductB1 : public AbstractProductB {
public:
    void use() override {
        std::cout << "Using Product B1" << std::endl;
    }
};

// 具体产品B2
class ProductB2 : public AbstractProductB {
public:
    void use() override {
        std::cout << "Using Product B2" << std::endl;
    }
};

// 抽象工厂
class AbstractFactory {
public:
    virtual ~AbstractFactory() {}
    virtual AbstractProductA* createProductA() = 0;
    virtual AbstractProductB* createProductB() = 0;
};

// 具体工厂1
class ConcreteFactory1 : public AbstractFactory {
public:
    AbstractProductA* createProductA() override {
        return new ProductA1();
    }

    AbstractProductB* createProductB() override {
        return new ProductB1();
    }
};

// 具体工厂2
class ConcreteFactory2 : public AbstractFactory {
public:
    AbstractProductA* createProductA() override {
        return new ProductA2();
    }

    AbstractProductB* createProductB() override {
        return new ProductB2();
    }
};

int main() {
    AbstractFactory* factory1 = new ConcreteFactory1();
    AbstractProductA* productA1 = factory1->createProductA();
    AbstractProductB* productB1 = factory1->createProductB();
    productA1->use();
    productB1->use();

    AbstractFactory* factory2 = new ConcreteFactory2();
    AbstractProductA* productA2 = factory2->createProductA();
    AbstractProductB* productB2 = factory2->createProductB();
    productA2->use();
    productB2->use();

    delete productA1;
    delete productB1;
    delete factory1;
    delete productA2;
    delete productB2;
    delete factory2;

    return 0;
}

应用场景

抽象工厂模式适用于以下场景：

产品族：当需要创建一组相关的产品时，使用抽象工厂模式可以保证产品族的一致性。
跨平台：当需要为不同的平台创建一组相关的产品时，使用抽象工厂模式可以方便地切换平台。

总结

工厂模式是一种非常实用的设计模式，它将对象的创建与使用分离，使得代码更加灵活、可扩展。工厂方法模式适用于创建单一产品，而抽象工厂模式适用于创建一组相关的产品。在实际开发中，根据具体需求选择合适的工厂模式，可以提高代码的可维护性和可扩展性。

希望本文能帮助你更好地理解工厂方法模式和抽象工厂模式的概念、实现方式以及应用场景。如果你有任何问题或建议，欢迎在评论区留言讨论。

原文地址：https://blog.csdn.net/2301_81482480/article/details/145312115

免责声明：本站文章内容转载自网络资源，如侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

安卓动态设置Unity图形API
安卓动态设置Unity图形API，Unity图像api设置为自动，安卓动态设置Vulkan、OpenGLES。
阅读更多2025-01-23
【深度学习基础】多层感知机 | 暂退法（Dropout）
本文讲解深度学习中的暂退法，并完成了暂退法的从零开始实现和简洁实现。暂退法在前向传播过程中，计算每一内部层的同时丢弃一些神经元。暂退法可以避免过拟合，它通常与控制权重向量的维数和大小结合使用的。
阅读更多2025-01-23
基于微信小程序的健身管理系统设计与实现（LW+源码+讲解）
专注于大学生项目实战开发,讲解,毕业答疑辅导，欢迎高校老师/同行前辈交流合作✌。技术范围：SpringBoot、Vue、SSM、HLMT、小程序、Jsp、PHP、Nodejs、Python、爬虫、数据
阅读更多2025-01-23
在K8S中，Keepalived是如何检测工作节点是否存活的？
Keepalived支持用户自定义健康检查脚本（vrrp_script），通过执行这些脚本来检测特定服务或资源的状态。例如，你可以编写一个脚本来ping某个IP地址、检查TCP端口是否打开，或者执行H
阅读更多2025-01-23
详细介绍：云原生技术细节（关键组成部分、优势和挑战、常用云原生工具）
本章详细介绍：云原生技术细节（关键组成部分、优势和挑战、常用云原生工具）
阅读更多2025-01-23
【开发日记】微信小程序getBackgroundAudioManager播放背景音乐提示播放失败
小程序在手机上打开，播放在线音频的时候会提示播放失败，但打印异常提示的是src为null，自己在打印的时候却没问题。并且在微信开发者工具中播放的时候也是正常的，只有手机上打开使用时提示异常。
阅读更多2025-01-23
数据分析变异系数
简单来讲就是平均值/标准差变异系数（Coefficient of Variation, CV）是一种相对量的变异指标，常用于衡量数据的离散程度。它通过标准差与均值的比值来表示，消除了单位差异的影响，使
阅读更多2025-01-23
原生toFixed的bug
如果5后无有效数字，则需看5前面的数字。若为奇数，则向前进一位；若为偶数（包括0），则直接舍去5不进位。如果5后还有不为“0”的任何数，无论5的前面是奇数还是偶数，均应进位。六入：当被修约的数字大
阅读更多2025-01-23
健身房项目 Uniapp+若依Vue3版搭建！！
本次系统实现主要负责前端前端功能的实现。其中系统前端主要分为三大部分，首页，教练列表页，我的页面。首页的实现效果如图。
阅读更多2025-01-23
[矩阵扩散]
真题目录:E 卷 100分题型。
阅读更多2025-01-23

工厂模式 - 工厂方法模式、抽象工厂模式

引言

工厂方法模式

概念

优点

缺点

实现

应用场景

抽象工厂模式

概念

优点

缺点

实现

应用场景

总结

相关文章