创建型设计模式：2、简单工厂模式、工厂模式、抽象工厂模式

目录

一、简单工作模式

二、工厂模式

三、抽象工厂模式

四、简单工厂模式、工厂模式、抽象工厂模式之间的关系

1、简单工厂模式与工厂模式

---

主要觉得这几个模式比较相似，就放一起讲解，也方便学习和区分。

一、简单工作模式

1、含义：简单工厂模式是一种创建型设计模式，它提供了一种统一的接口来创建不同类型的对象，而不需要直接暴露对象的创建逻辑。这样可以降低系统的耦合度，增加了代码的灵活性和可维护性。

2、C++实现简单工厂模式的示例：

#include 

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

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

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

// 简单工厂类
class SimpleFactory {
public:
    // 根据类型创建产品对象
    static Product* createProduct(const std::string& type) {
        if (type == "A") {
            return new ConcreteProductA();
        } else if (type == "B") {
            return new ConcreteProductB();
        } else {
            return nullptr;
        }
    }
};

int main() {
    // 创建产品A
    Product* productA = SimpleFactory::createProduct("A");
    productA->operation();

    // 创建产品B
    Product* productB = SimpleFactory::createProduct("B");
    productB->operation();

    delete productA;
    delete productB;

    return 0;
}

在上面的示例中，抽象产品类Product定义了所有具体产品类的共同接口。具体产品类ConcreteProductA和ConcreteProductB是具体产品的实现。

简单工厂类SimpleFactory负责根据不同的类型创建相应的产品对象。在createProduct方法中，根据传入的类型参数，返回相应的产品对象。

在main函数中，通过调用SimpleFactory::createProduct方法来创建不同类型的产品对象，并调用其operation方法进行操作。

运行程序，输出结果为：

Product A operation
Product B operation

这说明简单工厂模式成功地将对象的创建逻辑封装起来，并且能够根据不同的类型创建相应的对象。

二、工厂模式

1、含义：工厂模式（Factory Pattern）是一种创建型设计模式，它提供了一种创建对象的最佳方式，通过将创建对象的代码封装在一个工厂类中，而不是在客户端代码中直接实例化对象。

2、C++实现的工厂模式的示例：

#include 
#include 

// 抽象产品类
class Product {
public:
    virtual ~Product() {}
    virtual std::string operation() const = 0;
};

// 具体产品类A
class ConcreteProductA : public Product {
public:
    std::string operation() const override {
        return "ConcreteProductA";
    }
};

// 具体产品类B
class ConcreteProductB : public Product {
public:
    std::string operation() const override {
        return "ConcreteProductB";
    }
};

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

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

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

int main() {
    // 使用工厂A创建产品A
    Factory* factoryA = new ConcreteFactoryA();
    Product* productA = factoryA->createProduct();
    std::cout << productA->operation() << std::endl;

    // 使用工厂B创建产品B
    Factory* factoryB = new ConcreteFactoryB();
    Product* productB = factoryB->createProduct();
    std::cout << productB->operation() << std::endl;

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

    return 0;
}

在上述示例中，抽象产品类Product定义了产品的接口，具体产品类ConcreteProductA和ConcreteProductB实现了具体的产品。

抽象工厂类Factory定义了创建产品的接口，具体工厂类ConcreteFactoryA和ConcreteFactoryB实现了具体的工厂。

在客户端代码中，我们可以使用不同的工厂来创建不同的产品。通过工厂模式，客户端代码与具体产品的实现解耦，从而提高了代码的可维护性和扩展性。

三、抽象工厂模式

1、含义：抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

抽象工厂模式提供了一种创建一系列相关或相互依赖对象的接口，而无需指定具体实现类。通过使用抽象工厂模式，可以将客户端与具体产品的创建过程解耦，使得客户端可以通过工厂接口来创建一族产品。

2、C++实现的工厂模式的示例：（略）

四、简单工厂模式、工厂模式、抽象工厂模式之间的关系

1、简单工厂模式与工厂模式

（1）简单工厂模式的最大优点在于工厂类中包含了必要的逻辑判断；缺点就是违背了开放-封闭原则。

因为类中包含必要的逻辑判断，要是添加需求就要对原本的逻辑代码进行修改，有可能把之前好的功能也改出问题的风险。

（2）工厂模式，就是简单工厂模式的进一步抽象和推广。由于使用了多态性，工厂方法模式保持了简单工厂模式的优点，而且克服了它的缺点。

但是工厂模式本身有个缺点是，由于每家一个产品，就需要加一个产品工厂的类，增加了额外的开发量。

这个时候，可以利用”反射“可以解决避免分支判断问题。----抽象工厂模式。