设计模式之工厂模式

一、工厂模式概述

　　工厂模式（Factory Pattern）是一种创建型设计模式，旨在提供一种统一的方式来创建对象，将对象的实例化过程封装在一个单独的类中。工厂模式通过定义一个公共的接口来创建对象，但允许子类决定实例化哪个类。这样可以将对象的实例化与客户端代码的耦合度降到最低，同时也提供了一种可扩展的方式来创建对象。

工厂模式通常包含以下角色：

抽象产品（Abstract Product）：定义产品的通用接口，所有具体产品类都应该实现这个接口。
具体产品（Concrete Product）：实现抽象产品接口的具体类。
抽象工厂（Abstract Factory）：定义创建产品的接口，可以是抽象类或接口。通常会声明一个或多个用于创建产品的工厂方法。
具体工厂（Concrete Factory）：实现抽象工厂接口，负责实际创建具体产品的对象。

工厂模式的工作流程如下：

客户端通过调用抽象工厂的方法来创建产品，而无需直接实例化具体产品类。
抽象工厂根据客户端的请求，选择合适的具体工厂来创建对应的产品。
具体工厂根据抽象工厂的定义，创建具体产品的实例并返回给客户端。
客户端使用返回的产品实例进行操作，而无需关心具体产品的实现细节。

工厂模式的优点包括：

将对象的创建和使用分离，降低了客户端代码与具体产品的耦合度。
可以轻松扩展和添加新的产品，只需添加新的具体产品和对应的具体工厂类，而无需修改现有代码。
提供了一种可替换的方式来创建对象，使得系统更加灵活和可维护。

然而，工厂模式也有一些限制和考虑因素：

增加了系统的复杂性，引入了多个新的类和接口。
在添加新产品时，需要同时添加新的具体产品类和对应的具体工厂类，增加了代码量。
如果产品族的数量增加，可能会导致具体工厂类的爆炸性增长，需要谨慎设计和管理。

总的来说，工厂模式是一种常用且灵活的设计模式，适用于需要统一管理对象创建过程、降低客户端代码与具体产品的耦合度，并且允许动态替换和扩展对象创建的场景。

二、简单工厂模式

　　简单工厂模式（Simple Factory Pattern）是工厂模式的一种简化形式，也被称为静态工厂模式。它通过一个专门的工厂类来创建对象，而无需将对象的实例化过程放在客户端代码中。

在简单工厂模式中，有三个主要角色：

抽象产品（Abstract Product）：定义产品的通用接口，所有具体产品类都应该实现这个接口。
具体产品（Concrete Product）：实现抽象产品接口的具体类。
简单工厂（Simple Factory）：负责创建具体产品的工厂类。它通常包含一个静态方法，根据客户端的请求来创建并返回具体产品的实例。

简单工厂模式的优点包括：

将对象的创建过程集中在一个工厂类中，减少了客户端代码与具体产品的直接耦合。
可以通过简单工厂类的静态方法来创建产品，简化了客户端的调用代码。
可以轻松添加新的产品，只需修改简单工厂类的创建方法，而无需修改客户端代码。

然而，简单工厂模式也有一些限制和考虑因素：

工厂类负责创建所有产品，当产品种类较多时，工厂类的代码可能会变得复杂。
添加新产品时，需要修改工厂类的代码，违反了开闭原则。

简单工厂模式适用于需要根据客户端请求来创建不同类型对象的场景，但产品种类较少且不经常变化的情况。它提供了一种简单的方式来封装对象的创建过程，降低了客户端代码与具体产品的耦合度。

以下是一个示例，演示了如何在C++中实现简单工厂模式：

#include <iostream>
#include <memory>

// 抽象产品类
class Product {
public:
    virtual void use() = 0;
};

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

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

// 简单工厂类
class SimpleFactory {
public:
    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>();
        }
        else {
            // 处理未知产品类型的情况
            return nullptr;
        }
    }
};

int main() {
    // 使用简单工厂创建产品
    SimpleFactory factory;

    std::unique_ptr<Product> productA = factory.createProduct("A");
    if (productA) {
        productA->use();
    }

    std::unique_ptr<Product> productB = factory.createProduct("B");
    if (productB) {
        productB->use();
    }

    std::unique_ptr<Product> unknownProduct = factory.createProduct("C");
    if (!unknownProduct) {
        std::cout << "Unknown product type." << std::endl;
    }

    return 0;
}

打印结果：

三、工厂方法模式

工厂方法模式（Factory Method Pattern）是一种创建型设计模式，它提供了一种将对象的创建委托给子类的方式。在工厂方法模式中，定义一个用于创建对象的接口，但让子类决定实例化哪个类。这样可以将对象的创建与使用解耦，使得系统在不修改具体产品类的情况下可以引入新的产品。

工厂方法模式包含以下几个角色：

抽象产品（Product）：定义了产品的接口，是所有具体产品类的共同父类。
具体产品（Concrete Product）：实现了抽象产品接口的具体产品类，是工厂方法模式所创建的对象。
抽象工厂（Factory）：定义了工厂方法的接口，负责创建抽象产品的对象。
具体工厂（Concrete Factory）：实现了抽象工厂接口，具体工厂类根据具体业务逻辑，创建具体产品的对象。

工厂方法模式的工作流程如下：

客户端通过调用具体工厂类的工厂方法来创建产品对象。
具体工厂类根据客户端的请求，调用具体产品类的构造方法创建具体产品对象。
具体工厂类将创建的具体产品对象返回给客户端。

通过工厂方法模式，客户端与具体产品类解耦，客户端只需关心抽象产品和抽象工厂，具体产品的创建由具体工厂类来完成。这样，当需要引入新的产品时，只需创建一个新的具体产品类和对应的具体工厂类，而不需要修改客户端代码。

工厂方法模式适用于以下情况：

当一个类无法预知它需要创建的对象的具体类时，可以使用工厂方法模式。
当一个类希望将对象的创建责任委托给多个子类中的某一个时，可以使用工厂方法模式。
当一个类需要通过其子类来指定创建对象时，可以使用工厂方法模式。

总结来说，工厂方法模式通过定义一个创建对象的接口，将对象的实例化延迟到子类中去完成，实现了对象的创建与使用的解耦，提高了系统的可扩展性和灵活性。

以下是一个示例，演示了如何在C++中实现工厂方法模式：

#include <iostream>
#include <memory>

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

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

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

// 抽象工厂类
class Factory {
public:
    virtual ~Factory() {}
    virtual std::unique_ptr<Product> createProduct() = 0;
    void print() {
        std::unique_ptr<Product> product = this->createProduct();
        product->use();
    }
};

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

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

int main() {
    // 使用工厂类创建产品
    std::unique_ptr<Factory> factoryA = std::make_unique<ConcreteFactoryA>();
    factoryA->print();

    std::unique_ptr<Factory> factoryB = std::make_unique<ConcreteFactoryB>();
    factoryB->print();
   
    return 0;
}

打印结果：

四、抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，旨在提供一种统一的方式来创建一系列相关或相互依赖的对象，而无需指定具体的类。它通过定义一个抽象工厂接口和一组具体工厂类，来创建一族产品对象。

在抽象工厂模式中，有以下主要角色：

抽象工厂（Abstract Factory）：定义了创建一族产品对象的接口。它通常包含一组用于创建不同产品的工厂方法。
具体工厂（Concrete Factory）：实现了抽象工厂接口，负责创建具体的产品对象。
抽象产品（Abstract Product）：定义了一族产品对象的通用接口。具体产品类应实现这个接口。
具体产品（Concrete Product）：实现了抽象产品接口，是由具体工厂创建的对象。

抽象工厂模式的工作流程如下：

客户端通过抽象工厂接口来创建一族相关的产品对象。
具体工厂类实现了抽象工厂接口，负责创建具体的产品对象。
抽象工厂的工厂方法根据具体工厂的实现，创建并返回具体产品的实例。
客户端使用返回的产品实例进行操作，而无需关心具体产品的实现细节。

抽象工厂模式的优点包括：

将对象的创建和使用分离，降低了客户端代码与具体产品的耦合度。
提供了一种可替换的方式来创建一族相关产品，使得系统更加灵活和可维护。
符合开闭原则，可以轻松添加新的具体工厂和产品类，扩展系统功能。

然而，抽象工厂模式也有一些限制和考虑因素：

当产品族的数量增加时，抽象工厂和具体工厂的接口可能变得复杂，需要谨慎设计和管理。
添加新的产品族可能需要修改抽象工厂和所有具体工厂的代码，违反了开闭原则。

抽象工厂模式适用于需要创建一族相关产品对象的场景，其中产品之间存在一定的关联或依赖关系。它提供了一种统一的方式来管理产品的创建过程，将对象的创建与客户端代码解耦，同时也支持动态替换和扩展对象的创建。

以下是一个示例，演示了如何在C++中实现抽象工厂方法模式：

#include <iostream>

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

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

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

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

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

// 具体产品B2
class ConcreteProductB2 : public AbstractProductB {
public:
    void eat() override {
        std::cout << "Eating ConcreteProductB2" << 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 ConcreteProductA1();
    }

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

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

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

int main() {
    // 使用具体工厂1创建产品族1
    AbstractFactory* factory1 = new ConcreteFactory1();
    AbstractProductA* productA1 = factory1->createProductA();
    AbstractProductB* productB1 = factory1->createProductB();

    productA1->use();
    productB1->eat();

    // 使用具体工厂2创建产品族2
    AbstractFactory* factory2 = new ConcreteFactory2();
    AbstractProductA* productA2 = factory2->createProductA();
    AbstractProductB* productB2 = factory2->createProductB();

    productA2->use();
    productB2->eat();

    return 0;
}

打印结果：

五、优缺点总结

简单工厂模式（Simple Factory Pattern）的优缺点：

优点：

将对象的创建过程封装在一个工厂类中，客户端只需通过工厂类来创建对象，简化了客户端的调用代码。
将具体产品的实例化过程与客户端代码解耦，降低了客户端代码与具体产品的耦合度。
可以通过修改工厂类的代码来实现对产品对象的创建过程的控制和管理。
对于客户端而言，只需知道工厂类和产品接口，无需关心具体产品的实现细节。

缺点：

工厂类负责创建所有产品，当产品种类较多时，工厂类的代码可能会变得复杂，不易于维护和扩展。
添加新产品时，需要修改工厂类的代码，违反了开闭原则。
工厂类集中了所有产品的创建逻辑，一旦出现问题，可能会影响到所有产品的创建。

工厂模式（Factory Pattern）的优缺点：

优点：

将对象的创建过程封装在一个工厂类中，客户端只需通过工厂类来创建对象，降低了客户端代码与具体产品的耦合度。
可以通过定义工厂接口和具体工厂类的方式，支持动态切换和扩展产品的创建。
符合开闭原则，新增产品只需添加具体产品和对应的具体工厂类，无需修改现有代码。
提高了代码的可读性和可维护性，将对象的创建逻辑集中在一个类中，易于管理。

缺点：

当需要创建的产品种类较多时，工厂类的代码可能会变得复杂，不易于维护。
工厂模式引入了多个新的类和接口，增加了系统的复杂性。
对于简单的对象创建场景，引入工厂模式可能会显得繁琐和不必要。

抽象工厂模式（Abstract Factory Pattern）的优缺点：

优点：

提供了一种统一的方式来创建一族相关或相互依赖的对象，将对象的创建过程与客户端解耦。
支持动态切换和扩展产品族，只需修改具体工厂类即可。
符合开闭原则，新增产品族只需添加具体产品和对应的具体工厂类，无需修改现有代码。
提高了代码的可读性和可维护性，将对象的创建逻辑集中在具体工厂类中，易于管理。

缺点：

当产品族的数量增加时，抽象工厂和具体工厂的接口可能变得复杂，需要谨慎设计和管理。
添加新的产品族可能需要修改抽象工厂和所有具体工厂的代码，违反了开闭原则。
引入了多个新的类和接口，增加了系统的复杂性。

综合来说，简单工厂模式适用于产品种类较少且不经常变化的场景；工厂模式适用于需要根据客户端请求来创建不同类型对象的场景；抽象工厂模式适用于需要创建一族相关产品对象的场景，其中产品之间存在一定的关联或依赖关系。选择适合的设计模式要根据具体的业务需求和设计考虑。

posted @ 2023-06-14 23:55 TechNomad 阅读(877) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 设计模式之单例模式

· Qt之容器类

· 设计模式之工厂模式！深入解析简单工厂模式，工厂方法模式和抽象工厂模式

· 跟着GPT学设计模式之工厂模式

· 23种设计模式之工厂模式

阅读排行：
· DeepSeek 开源周回顾「GitHub 热点速览」
· 物流快递公司核心技术能力-地址解析分单基础技术分享
· .NET 10首个预览版发布：重大改进与新特性概览！
· AI与.NET技术实操系列（二）：开始使用ML.NET
· 单线程的Redis速度为什么快？

公告

昵称： TechNomad
园龄： 6年2个月
粉丝： 21
关注： 2

+加关注

2025年3月

日

一

二

三

四

五

六

TechNomad

编程是一场持久战，只有坚持不懈才能取得胜利。

设计模式之工厂模式

公告

搜索

常用链接

随笔分类

随笔档案

阅读排行榜

评论排行榜

推荐排行榜

最新评论