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

这题怎么做？！？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. 抽象工厂模式：主要用于创建一组相关的产品，通过具体工厂类实现，可以同时创建多个相关的产品，确保产品之间的兼容性。

相关推荐
vir025 分钟前
木材加工（二分查找）
数据结构·c++·算法
余辉zmh1 小时前
【c++篇】：深入c++的set和map容器--掌握提升编程效率的利器
开发语言·c++
qq_428639616 小时前
植物明星大乱斗15
c++·算法·游戏
捕鲸叉7 小时前
C++创建型模式之生成器模式
开发语言·c++·建造者模式
sxtyjty7 小时前
人机打怪小游戏（非常人机）
c++
oioihoii7 小时前
单例模式详解
c++·单例模式·c#·大学必学
ikkkkkkkl7 小时前
深述C++模板类
开发语言·c++
Theodore_10228 小时前
7 设计模式原则之合成复用原则
java·开发语言·jvm·设计模式·java-ee·合成复用原则
Peter_chq8 小时前
【计算机网络】HTTP协议
linux·c语言·开发语言·网络·c++·后端·网络协议
武子康8 小时前
Java-05 深入浅出 MyBatis - 配置深入 动态 SQL 参数、循环、片段
java·sql·设计模式·架构·mybatis·代理模式
热门推荐
01PyTorch机器学习实现液态神经网络02Coze扣子平台完整体验和实践（附国内和国际版对比）03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明05玄机平台应急响应—webshell查杀06RAG 实践- Ollama+RagFlow 部署本地知识库07【目标跟踪】相机运动补偿08Unity中PICO实现 隔空取物 和 接触抓取物体09Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO1004 - matlab m_map地学绘图工具基础函数 - 设置网格