工厂模式详解与应用场景

最新推荐文章于 2024-04-25 20:36:13 发布

LewGarben

最新推荐文章于 2024-04-25 20:36:13 发布

阅读量1k

点赞数

文章标签： java 算法 jvm

本文链接：https://blog.csdn.net/qq_46017342/article/details/132093187

版权

摘要：

工厂模式是一种常见的设计模式，它可以帮助我们在面向对象的程序设计中更好地组织和管理对象的创建过程。本文将详细介绍工厂模式的概念、三种常见的工厂模式应用场景，并提供高质量的C++代码示例，旨在帮助初学者更好地理解和应用工厂模式。

1. 工厂模式概述

工厂模式属于创建型设计模式，它提供了一种将对象的创建过程封装起来的方法。通过工厂模式，我们可以将对象的实例化与客户端代码解耦，使客户端代码不依赖于具体的对象创建方式，而是通过工厂来获取所需的对象实例。这种解耦有助于提高代码的灵活性和可维护性。

在工厂模式中，通常有三个主要角色：

抽象产品（Abstract Product）：定义了产品的接口，具体产品必须实现这些接口。
具体产品（Concrete Product）：实现抽象产品定义的接口，代表具体的对象实例。
工厂（Factory）：负责创建具体产品的实例，客户端代码通过工厂来获取所需产品的对象。

2. 工厂模式应用场景

2.1 简单工厂模式（Simple Factory Pattern）

简单工厂模式并不属于GOF（Gang of Four）提出的23种设计模式之一，但它是工厂模式的一种基础形式。在简单工厂模式中，我们使用一个单独的工厂类来负责创建所有的产品对象。

适用场景：

当需要创建的对象较少，且创建过程相对简单时，可以考虑使用简单工厂模式。
适用于具有相同父类或接口的一组类，且客户端不需要关心具体对象的创建细节。

2.2 工厂方法模式（Factory Method Pattern）

工厂方法模式定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。这样，工厂方法模式将对象的实例化推迟到子类，符合开闭原则。

适用场景：

当需要添加新产品时，只需创建对应的具体工厂和产品类，无需修改现有代码，符合开闭原则。
适用于具有相同父类或接口的一组类，且每个子类需要不同的初始化逻辑。

2.3 抽象工厂模式（Abstract Factory Pattern）

抽象工厂模式提供了一个创建一系列相关或相互依赖对象的接口，而无需指定具体类。通过使用抽象工厂模式，客户端可以创建并使用多个产品组合，而无需关心具体产品的实现细节。
在这里插入图片描述

适用场景：

适用于产品有多个系列（例如不同品牌的汽车和轮胎），且客户端需要使用这些系列产品。
有利于避免产品之间的不匹配问题，确保一系列产品被一起创建。

3. 三种工厂模式的区别

简单工厂模式只有一个工厂类来创建所有产品，工厂方法模式每个产品对应一个具体工厂，抽象工厂模式每个产品组合对应一个具体工厂。

简单工厂模式的客户端代码与具体产品紧密耦合，不符合开闭原则。而工厂方法模式和抽象工厂模式通过派生新的工厂类来创建新的产品，更符合开闭原则。

工厂方法模式将产品的创建推迟到子类，使得系统更具有灵活性。抽象工厂模式则在工厂的基础上提供了一系列产品组合，更适合创建一系列相关的产品。

4. C++代码示例

4.1 简单工厂模式示例

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

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

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

// 简单工厂类
class SimpleFactory {
public:
    static Product* createProduct(int type) {
        if (type == 1) {
            return new ConcreteProductA();
        } else if (type == 2) {
            return new ConcreteProductB();
        }
        return nullptr;
    }
};

int main() {
    Product* productA = SimpleFactory::createProduct(1);
    Product* productB = SimpleFactory::createProduct(2);

    productA->operation();  // 输出：Concrete Product A
    productB->operation();  // 输出：Concrete Product B

    delete productA;
    delete productB;

    return 0;
}

4.2 工厂方法模式示例

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

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

// 具体产品 B
class ConcreteProductB : public Product {
public:

    void operation() override {
        std::cout << "Concrete Product B" << std::endl;
    }
};

// 抽象工厂类
class Factory {
public:
    virtual Product* createProduct() = 0;
};

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

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

int main() {
    Factory* factoryA = new ConcreteFactoryA();
    Factory* factoryB = new ConcreteFactoryB();

    Product* productA = factoryA->createProduct();
    Product* productB = factoryB->createProduct();

    productA->operation();  // 输出：Concrete Product A
    productB->operation();  // 输出：Concrete Product B

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

    return 0;
}

4.3 抽象工厂模式示例

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

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

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

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

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

// 具体产品 B2
class ConcreteProductB2 : public AbstractProductB {
public:
    void operationB() override {
        std::cout << "Concrete Product B2" << std::endl;
    }
};

// 抽象工厂类
class AbstractFactory {
public:
    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() {
    AbstractFactory* factory1 = new ConcreteFactory1();
    AbstractFactory* factory2 = new ConcreteFactory2();

    AbstractProductA* productA1 = factory1->createProductA();
    AbstractProductB* productB1 = factory1->createProductB();

    AbstractProductA* productA2 = factory2->createProductA();
    AbstractProductB* productB2 = factory2->createProductB();

    productA1->operationA();  // 输出：Concrete Product A1
    productB1->operationB();  // 输出：Concrete Product B1

    productA2->operationA();  // 输出：Concrete Product A2
    productB2->operationB();  // 输出：Concrete Product B2

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

    return 0;
}