目录
主要觉得这几个模式比较相似，就放一起讲解，也方便学习和区分。
一、简单工作模式
1、含义：简单工厂模式是一种创建型设计模式，它提供了一种统一的接口来创建不同类型的对象，而不需要直接暴露对象的创建逻辑。这样可以降低系统的耦合度，增加了代码的灵活性和可维护性。
2、C++实现简单工厂模式的示例：
#include <iostream>
// 抽象产品类
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 <iostream>
#include <string>
// 抽象产品类
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++实现的工厂模式的示例：
#include <iostream>
// 抽象产品A
class AbstractProductA {
public:
virtual void operationA() = 0;
};
// 具体产品A1
class ConcreteProductA1 : public AbstractProductA {
public:
void operationA() override {
std::cout << "ConcreteProductA1::operationA()" << std::endl;
}
};
// 具体产品A2
class ConcreteProductA2 : public AbstractProductA {
public:
void operationA() override {
std::cout << "ConcreteProductA2::operationA()" << std::endl;
}
};
// 抽象产品B
class AbstractProductB {
public:
virtual void operationB() = 0;
};
// 具体产品B1
class ConcreteProductB1 : public AbstractProductB {
public:
void operationB() override {
std::cout << "ConcreteProductB1::operationB()" << std::endl;
}
};
// 具体产品B2
class ConcreteProductB2 : public AbstractProductB {
public:
void operationB() override {
std::cout << "ConcreteProductB2::operationB()" << 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() {
// 使用具体工厂1创建产品
AbstractFactory* factory1 = new ConcreteFactory1();
AbstractProductA* productA1 = factory1->createProductA();
AbstractProductB* productB1 = factory1->createProductB();
productA1->operationA();
productB1->operationB();
// 使用具体工厂2创建产品
AbstractFactory* factory2 = new ConcreteFactory2();
AbstractProductA* productA2 = factory2->createProductA();
AbstractProductB* productB2 = factory2->createProductB();
productA2->operationA();
productB2->operationB();
delete factory1;
delete factory2;
delete productA1;
delete productB1;
delete productA2;
delete productB2;
return 0;
}
这个示例中，抽象工厂
AbstractFactory定义了创建抽象产品AbstractProductA和AbstractProductB的接口。具体工厂ConcreteFactory1和ConcreteFactory2分别实现了这个接口，并创建了具体产品ConcreteProductA1、ConcreteProductA2、ConcreteProductB1和ConcreteProductB2。
四、简单工厂模式、工厂模式、抽象工厂模式之间的关系
1、简单工厂模式与工厂模式
（1）简单工厂模式的最大优点在于工厂类中包含了必要的逻辑判断；缺点就是违背了开放-封闭原则。
因为类中包含必要的逻辑判断，要是添加需求就要对原本的逻辑代码进行修改，有可能把之前好的功能也改出问题的风险。
（2）工厂模式，就是简单工厂模式的进一步抽象和推广。由于使用了多态性，工厂方法模式保持了简单工厂模式的优点，而且克服了它的缺点。
但是工厂模式本身有个缺点是，由于每家一个产品，就需要加一个产品工厂的类，增加了额外的开发量。
这个时候，可以利用”反射“可以解决避免分支判断问题。----抽象工厂模式。
2、抽象工厂模式与工厂模式
（1）目的不同：
- 抽象工厂模式旨在提供一个接口来创建一系列相关或相互依赖的对象。它将一组相关的产品抽象成一个工厂，客户端通过这个工厂来创建产品，从而实现解耦。
- 工厂方法模式旨在定义一个创建对象的接口，但将具体的实例化延迟到子类中。每个子类都可以根据需要创建适合自己的具体产品。
（2）结构不同：
- 抽象工厂模式旨在提供一个接口来创建一系列相关或相互依赖的对象。它将一组相关的产品抽象成一个工厂，客户端通过这个工厂来创建产品，从而实现解耦。
- 工厂方法模式旨在定义一个创建对象的接口，但将具体的实例化延迟到子类中。每个子类都可以根据需要创建适合自己的具体产品。
（3）关注点不同：
- 抽象工厂模式旨在提供一个接口来创建一系列相关或相互依赖的对象。它将一组相关的产品抽象成一个工厂，客户端通过这个工厂来创建产品，从而实现解耦。
- 工厂方法模式旨在定义一个创建对象的接口，但将具体的实例化延迟到子类中。每个子类都可以根据需要创建适合自己的具体产品。
总的来说，抽象工厂模式适用于需要一次性创建一组相关产品的场景，而工厂方法模式适用于需要根据不同情况创建不同产品的场景。