设计模式-工厂模式

前言

由于作者做的C++开发比较多所以本文实例都以C++语言方式给出。

简单工厂模式

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

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

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

// 工厂类
class Factory {
public:
    enum ProductType { A, B };
    
    static std::unique_ptr<Product> createProduct(ProductType type) {
        switch(type) {
            case A: return std::make_unique<ConcreteProductA>();
            case B: return std::make_unique<ConcreteProductB>();
            default: return nullptr;
        }
    }
};

简单工厂模式，通过枚举代表不同的产品，工厂类通过枚举来创建不同的产品返回的是抽象产品指针。简单工厂模式将产品的制造逻辑封装到了工厂类内部，外部使用者只需要使用工厂类创建产品即可。

抽象工厂模式

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

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

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

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

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

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

// 产品族2的实现...
class ProductA2 : public AbstractProductA { /*...*/ };
class ProductB2 : public AbstractProductB { /*...*/ };
class ConcreteFactory2 : public AbstractFactory { /*...*/ };

抽象工厂模式在简单工厂模式的基础上将工厂也进行了抽象，每个具体工厂实现自己需要创建的产品，不同的具体工厂可以根据需求创建不同的产品。