解释说明：提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们具体的类。
简言之，一个工厂可以提供创建多种相关产品的接口，而无需像工厂方法一样，为每一个产品都提供一个具体工厂
抽象工厂（AbstractFactory）：提供了创建抽象的接口，它包含了多个创建产品的方法，可以创建多个不同等级的产品
具体工厂（ConcreteFactory）：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建
抽象产品（Product）：定义产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品
具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是一对一的关系
优点：
封装了产品的创建，使得不需要知道具体是哪种产品，只需要知道是哪个工厂即可。
可以支持不同类型的产品，使得模式灵活性更强。
可以非常方便的使用一族中的不同类型的产品。
缺点：
结构过于臃肿，如果产品类型较多或产品族较多，会非常难于管理。
每次如果添加一组产品，那么所有的工厂类都必须添加一个方法，这样违背了开放-封闭原则。所以一般适用于产品组合产品族变化不大的情况。
适用场景
在不必指定产品的具体的情况下，创建多个产品族中的产品对象。
考虑这样一个场景，如下图
Jungle想要进行户外运动，它可以选择打篮球和踢足球。但这次Jungle不想弄脏原本穿的T恤，所以Jungle还需要穿球衣，打篮球就穿篮球衣，踢足球就穿足球衣。篮球保管室可以提供篮球和篮球衣，足球保管室可以提供足球和足球衣。Jungle只要根据心情去某个保管室，就可以换上球衣、拿上球，然后就可以愉快地玩耍了
对应的UML实例图如下图
#pragma once
#include <string>
using namespace std;
// 汽车接口
class ICar
{
public:
virtual string Name() = 0; // 汽车名称
};
/********** 汽车 **********/
// 奔驰
class BenzCar : public ICar
{
public:
string Name() {
return "Benz Car";
}
};
// 宝马
class BmwCar : public ICar
{
public:
string Name() {
return "Bmw Car";
}
};
// 奥迪
class AudiCar : public ICar
{
public:
std::string Name() {
return "Audi Car";
}
};
// 自行车接口
class IBike
{
public:
virtual string Name() = 0; // 自行车名称
};
/********** 自行车 **********/
// 奔驰
class BenzBike : public IBike
{
public:
string Name() {
return "Benz Bike";
}
};
// 宝马
class BmwBike : public IBike
{
public:
string Name() {
return "Bmw Bike";
}
};
// 奥迪
class AudiBike : public IBike
{
public:
string Name() {
return "Audi Bike";
}
};
#include "product.h"
// 抽象工厂
class AFactory
{
public:
enum FACTORY_TYPE {
BENZ_FACTORY, // 奔驰工厂
BMW_FACTORY, // 宝马工厂
AUDI_FACTORY // 奥迪工厂
};
virtual ICar* CreateCar() = 0; // 生产汽车
virtual IBike* CreateBike() = 0; // 生产自行车
static AFactory* CreateFactory(FACTORY_TYPE factory); // 创建工厂
};
#include "factory.h"
#include "product.h"
// 奔驰工厂
class BenzFactory : public AFactory
{
public:
ICar* CreateCar() {
return new BenzCar();
}
IBike* CreateBike() {
return new BenzBike();
}
};
// 宝马工厂
class BmwFactory : public AFactory
{
public:
ICar* CreateCar() {
return new BmwCar();
}
IBike* CreateBike() {
return new BmwBike();
}
};
// 奥迪工厂
class AudiFactory : public AFactory
{
public:
ICar* CreateCar() {
return new AudiCar();
}
IBike* CreateBike() {
return new AudiBike();
}
};
// 创建工厂
AFactory* AFactory::CreateFactory(FACTORY_TYPE factory)
{
AFactory* pFactory = NULL;
switch (factory) {
case FACTORY_TYPE::BENZ_FACTORY: // 奔驰工厂
pFactory = new BenzFactory();
break;
case FACTORY_TYPE::BMW_FACTORY: // 宝马工厂
pFactory = new BmwFactory();
break;
case FACTORY_TYPE::AUDI_FACTORY: // 奥迪工厂
pFactory = new AudiFactory();
break;
default:
break;
}
return pFactory;
}
#include "factory.h"
#include "product.h"
#include <iostream>
using namespace std;
#ifndef SAFE_DELETE
#define SAFE_DELETE(p) { if(p){delete(p); (p)=NULL;} }
#endif
int main()
{
// 奔驰
AFactory* pFactory = AFactory::CreateFactory(AFactory::FACTORY_TYPE::BENZ_FACTORY);
ICar* pCar = pFactory->CreateCar();
IBike* pBike = pFactory->CreateBike();
cout << "Benz factory - Car: " << pCar->Name() << endl;
cout << "Benz factory - Bike: " << pBike->Name() << endl;
SAFE_DELETE(pCar);
SAFE_DELETE(pBike);
SAFE_DELETE(pFactory);
// 宝马
pFactory = AFactory::CreateFactory(AFactory::FACTORY_TYPE::BMW_FACTORY);
pCar = pFactory->CreateCar();
pBike = pFactory->CreateBike();
cout << "Bmw factory - Car: " << pCar->Name() << endl;
cout << "Bmw factory - Bike: " << pBike->Name() << endl;
SAFE_DELETE(pCar);
SAFE_DELETE(pBike);
SAFE_DELETE(pFactory);
// 奥迪
pFactory = AFactory::CreateFactory(AFactory::FACTORY_TYPE::AUDI_FACTORY);
pCar = pFactory->CreateCar();
pBike = pFactory->CreateBike();
cout << "Audi factory - Car: " << pCar->Name() << endl;
cout << "Audi factory - Bike: " << pBike->Name() << endl;
SAFE_DELETE(pCar);
SAFE_DELETE(pBike);
SAFE_DELETE(pFactory);
getchar();
return 0;
}
![[C++ 网络协议] 重叠I/O模型](https://img-blog.csdnimg.cn/a723a4876df24814b91270cb2416af0f.png)
![MyBatis-Plus通用Service快速实现赠三改查[MyBatis-Plus系列] - 第489篇](https://img-blog.csdnimg.cn/img_convert/a7a8034d824f7b26377535152198926f.png)
