工厂模式：简单工厂模式、工厂方法模式、抽象工厂模式

这题怎么做？！？2024-10-31 18:45

目录

工厂模式的类型

工厂模式的优点

工厂模式的缺点

适用场景

[1. 简单工厂模式示例](#1. 简单工厂模式示例)

[2. 工厂方法模式示例](#2. 工厂方法模式示例)

[3. 抽象工厂模式示例](#3. 抽象工厂模式示例)

总结

工厂模式（Factory Pattern）是一种创建型设计模式，它提供了一种在不指定具体类的情况下创建对象的方式。工厂模式主要用于解决对象的创建问题，通过将对象的创建过程封装在一个工厂类中，使得客户端代码不需要关心对象的具体创建细节，只需要通过工厂类来获取所需的对象实例。

工厂模式的类型

工厂模式通常分为三种类型：

  1. 简单工厂模式（Simple Factory Pattern）：

    • 简单工厂模式并不是一种严格意义上的设计模式，它更像是一种编程习惯。
    • 简单工厂模式将对象的创建过程集中在一个工厂类中，客户端只需要调用工厂类的方法并传递相应的参数，工厂类就会根据参数返回相应的对象实例。
    • 优点是客户端代码简洁，但缺点是工厂类集中了所有的对象创建逻辑，随着业务逻辑的复杂化，工厂类可能会变得越来越臃肿。

  2. 工厂方法模式（Factory Method Pattern）：

    • 工厂方法模式是简单工厂模式的进一步抽象和推广。
    • 在工厂方法模式中，每个具体的类都有一个对应的工厂类，工厂类中定义了一个工厂方法，用于创建对应类的实例。
    • 这样做的好处是将对象的创建逻辑分散到各个工厂类中，避免了工厂类的臃肿，同时也符合开闭原则（对扩展开放，对修改关闭）。

  3. 抽象工厂模式（Abstract Factory Pattern）：

    • 抽象工厂模式提供了一种创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
    • 抽象工厂模式适用于需要创建一组相关或依赖的对象的情况。
    • 它通过定义一个抽象工厂接口，具体的工厂类实现这个接口，来创建一系列相关的产品对象。
    • 抽象工厂模式能够确保创建的对象之间的一致性，并且易于扩展。

工厂模式的优点

  • 解耦：客户端代码与具体类的创建代码分离，客户端代码只需要依赖工厂接口，而不需要依赖具体的类。
  • 可扩展性：通过增加新的工厂类和产品类，可以很容易地扩展系统，而不需要修改现有代码。
  • 封装性：对象的创建过程被封装在工厂类中，客户端不需要关心对象的创建细节。

工厂模式的缺点

  • 增加了类的数量：工厂模式会增加系统中类的数量，在一定程度上增加了复杂性。
  • 复杂性：对于简单的对象创建，使用工厂模式可能会显得过于复杂。

适用场景

  • 当一个类不知道它所需要的对象的具体类时。
  • 当一个类希望由其子类来指定它所创建的对象时。
  • 当类将创建对象的职责委托给多个帮助子类中的某一个，并且希望将哪一个帮助子类是代理者这一信息局部化时。

1. 简单工厂模式示例

#include <iostream>
#include <memory>

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

// 具体产品1
class ConcreteProductA : public Product {
public:
    void use() override {
        std::cout << "使用产品 A" << std::endl;
    }
};

// 具体产品2
class ConcreteProductB : public Product {
public:
    void use() override {
        std::cout << "使用产品 B" << std::endl;
    }
};

// 工厂类
class SimpleFactory {
public:
    static std::unique_ptr<Product> createProduct(const std::string &type) {
        if (type == "A") {
            return std::make_unique<ConcreteProductA>();
        } else if (type == "B") {
            return std::make_unique<ConcreteProductB>();
        }
        return nullptr;
    }
};

int main() {
    auto productA = SimpleFactory::createProduct("A");
    productA->use(); // 输出: 使用产品 A

    auto productB = SimpleFactory::createProduct("B");
    productB->use(); // 输出: 使用产品 B

    return 0;
}

2. 工厂方法模式示例

#include <iostream>
#include <memory>

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

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

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

// 工厂接口
class ProductFactory {
public:
    virtual std::unique_ptr<Product> createProduct() = 0;
    virtual ~ProductFactory() = default;
};

// 具体工厂 A
class ConcreteFactoryA : public ProductFactory {
public:
    std::unique_ptr<Product> createProduct() override {
        return std::make_unique<ConcreteProductA>();
    }
};

// 具体工厂 B
class ConcreteFactoryB : public ProductFactory {
public:
    std::unique_ptr<Product> createProduct() override {
        return std::make_unique<ConcreteProductB>();
    }
};

int main() {
    std::unique_ptr<ProductFactory> factoryA = std::make_unique<ConcreteFactoryA>();
    auto productA = factoryA->createProduct();
    productA->use(); // 输出: 使用产品 A

    std::unique_ptr<ProductFactory> factoryB = std::make_unique<ConcreteFactoryB>();
    auto productB = factoryB->createProduct();
    productB->use(); // 输出: 使用产品 B

    return 0;
}

3. 抽象工厂模式示例

#include <iostream>
#include <memory>

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

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

// 具体产品 A1
class ConcreteProductA1 : public AbstractProductA {
public:
    void use() override {
        std::cout << "使用产品 A1" << std::endl;
    }
};

// 具体产品 A2
class ConcreteProductA2 : public AbstractProductA {
public:
    void use() override {
        std::cout << "使用产品 A2" << std::endl;
    }
};

// 具体产品 B1
class ConcreteProductB1 : public AbstractProductB {
public:
    void use() override {
        std::cout << "使用产品 B1" << std::endl;
    }
};

// 具体产品 B2
class ConcreteProductB2 : public AbstractProductB {
public:
    void use() override {
        std::cout << "使用产品 B2" << std::endl;
    }
};

// 抽象工厂
class AbstractFactory {
public:
    virtual std::unique_ptr<AbstractProductA> createProductA() = 0;
    virtual std::unique_ptr<AbstractProductB> createProductB() = 0;
    virtual ~AbstractFactory() = default;
};

// 具体工厂 1
class ConcreteFactory1 : public AbstractFactory {
public:
    std::unique_ptr<AbstractProductA> createProductA() override {
        return std::make_unique<ConcreteProductA1>();
    }
    std::unique_ptr<AbstractProductB> createProductB() override {
        return std::make_unique<ConcreteProductB1>();
    }
};

// 具体工厂 2
class ConcreteFactory2 : public AbstractFactory {
public:
    std::unique_ptr<AbstractProductA> createProductA() override {
        return std::make_unique<ConcreteProductA2>();
    }
    std::unique_ptr<AbstractProductB> createProductB() override {
        return std::make_unique<ConcreteProductB2>();
    }
};

int main() {
    // 使用工厂 1
    std::unique_ptr<AbstractFactory> factory1 = std::make_unique<ConcreteFactory1>();
    auto productA1 = factory1->createProductA();
    productA1->use(); // 输出: 使用产品 A1
    auto productB1 = factory1->createProductB();
    productB1->use(); // 输出: 使用产品 B1
    
    // 使用工厂 2
    std::unique_ptr<AbstractFactory> factory2 = std::make_unique<ConcreteFactory2>();
    auto productA2 = factory2->createProductA();
    productA2->use(); // 输出: 使用产品 A2
    auto productB2 = factory2->createProductB();
    productB2->use(); // 输出: 使用产品 B2

    return 0;
}

总结

  1. 简单工厂模式：通过一个工厂类根据参数创建不同类型的产品，客户端只需知道工厂类。

  2. 工厂方法模式：定义了一个工厂接口，每个具体工厂负责创建特定的产品，便于扩展新产品类型。

  3. 抽象工厂模式：主要用于创建一组相关的产品，通过具体工厂类实现，可以同时创建多个相关的产品，确保产品之间的兼容性。

相关推荐
帅次34 分钟前
基于云平台的智能家居管理系统设计与通信协议分析
设计模式·重构·软件工程·软件构建·需求分析·代码规范·设计规范
大白的编程日记.1 小时前
【C++笔记】list结构剖析及其模拟实现
c++·笔记·list
AlexMercer10122 小时前
[C++ 核心编程]笔记 4.2.6 初始化列表
开发语言·数据结构·c++·笔记·算法
程序员阿鹏2 小时前
详解：模板设计模式
java·开发语言·jvm·后端·设计模式·eclipse·1024程序员节
zzzhpzhpzzz2 小时前
设计模式——享元模式
算法·设计模式·享元模式
何苏三月2 小时前
设计模式 - 简单工厂模式
java·设计模式·简单工厂模式
鳄鱼麻薯球3 小时前
【Qt】系统相关——多线程、Qt多线程介绍、常用函数、线程安全、网络、UDP Socket、TCP Socket
网络·c++·qt
玉树临风ives3 小时前
2024 CSP-J 题解
c++·算法·深度优先·动态规划
大山同学3 小时前
Swarm-LIO: Decentralized Swarm LiDAR-inertial Odometry论文翻译
c++·人工智能·算法·去中心化·区块链
Slow菜鸟4 小时前
Spring 设计模式之策略模式
spring·设计模式·策略模式
热门推荐
01Windows10安装PCL1.14.0及点云配准02制冷毛细管的计算方法介绍03【经验分享】Ubuntu22.04安装微信(linux官方版)04ECharts 地图实战分析：实现一个完整的地图下钻功能05前端vue3实现本地及在线文件预览（含pdf/txt/mp3/mp4/docx/xlsx/pptx）06组基轨迹建模 GBTM的介绍与实现（Stata 或 R）07(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明08【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总09RAG 实践- Ollama+RagFlow 部署本地知识库10苍穹外卖面试总结