当前位置：首页 > news >正文

Chapter5—抽象工厂模式

news 2025/9/13 9:41:58

抽象工厂模式

1 概念

工厂方法模式实现的是一个工厂类生产一种产品，而抽象工厂模式是一个工厂类对应多种相似的产品，开发者并不会直接创建具体产品，而是通过具体的工厂去实现产品对象的创建。抽象工厂模式是指一个工厂类可以生产多种相互关联的产品，一对多的关系使得开发者在生产多种产品时，只用修改一个工厂类即可。

2 意图(Intent)

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

3 动机(Motivate)

在软件系统中，经常面临着“一系列相互依赖的对象”的创建工作；同时，由于需求的变化，往往存在更多系列对象的创建工作。如何应对这种变化？如何绕过常规的对象创建方法(new)，提供一种“封装机制”来避免客户程序和这种“多系列具体对象创建工作”的紧耦合？

4 类图结构

在这里插入图片描述

5 角色定义

AbstractProduct（抽象产品）：抽象产品为每种产品声明接口，在抽象产品中定义了产品的抽象业务方法。
ConcreteProduct（具体产品）：具体产品定义了具体工厂生产的具体产品对象，实现抽象产品接口中定义的业务方法。
AbstractFactory（抽象工厂）：抽象工厂用于声明生成抽象产品的方法，在一个抽象工厂中可以定义一组方法，每一个方法对应一个产品等级结构。
ConcreteFactory（具体工厂）：具体工厂实现了抽象工厂声明的生成抽象产品的方法，生成一组具体产品，这些产品构成了一个产品族，每一个产品都位于某个产品等级结构中。

6 程序示例

基本抽象工厂

抽象产品A类

/*** @brief 抽象产品A类*/
class AbstractProductA
{
public:AbstractProductA() = default;virtual ~AbstractProductA() = default;public:virtual void Show() = 0;
};

具体产品A1类(属于1族)

/*** @brief 具体产品A1类(属于1族)*/
class ConcreteProductA1: public AbstractProductA
{
public:ConcreteProductA1() = default;~ConcreteProductA1() = default;public:void Show() override;
};void ConcreteProductA1::Show()
{qDebug() << "ConcreteProductA1 Show";
}

具体产品A2类(属于2族)

/*** @brief 具体产品A2类(属于2族)*/
class ConcreteProductA2: public AbstractProductA
{
public:ConcreteProductA2() = default;~ConcreteProductA2() = default;public:void Show() override;
};void ConcreteProductA2::Show()
{qDebug() << "ConcreteProductA2 Show";
}

抽象产品B类

/*** @brief 抽象产品B类*/
class AbstractProductB
{
public:AbstractProductB() = default;virtual ~AbstractProductB() = default;public:virtual void Show() = 0;
};

具体产品B1类(属于1族)

/*** @brief 具体产品B1类(属于1族)*/
class ConcreteProductB1: public AbstractProductB
{
public:ConcreteProductB1() = default;~ConcreteProductB1() = default;public:void Show() override;
};void ConcreteProductB1::Show()
{qDebug() << "ConcreteProductB1 Show";
}

具体产品B2类(属于2族)

/*** @brief 具体产品B2类(属于2族)*/
class ConcreteProductB2: public AbstractProductB
{
public:ConcreteProductB2() = default;~ConcreteProductB2() = default;public:void Show() override;
};void ConcreteProductB2::Show()
{qDebug() << "ConcreteProductB2 Show";
}

抽象工厂类

/*** @brief 抽象工厂类*/
class AbstractFactory
{
public:AbstractFactory() = default;virtual ~AbstractFactory() = default;public:virtual AbstractProductA* CreateProductA() = 0;virtual AbstractProductB* CreateProductB() = 0;
};

具体工厂，生产1族产品

/*** @brief 具体工厂，生产1族产品*/
class ConcreteFactory1 : public AbstractFactory
{
public:ConcreteFactory1() = default;~ConcreteFactory1() = default;public:AbstractProductA* CreateProductA() override;AbstractProductB* CreateProductB() override;
};AbstractProductA* ConcreteFactory1::CreateProductA()
{return new ConcreteProductA1();
}AbstractProductB* ConcreteFactory1::CreateProductB()
{return new ConcreteProductB1();
}

具体工厂，生产2族产品

/*** @brief 具体工厂，生产2族产品*/
class ConcreteFactory2 : public AbstractFactory
{
public:ConcreteFactory2() = default;~ConcreteFactory2() = default;public:AbstractProductA* CreateProductA() override;AbstractProductB* CreateProductB() override;
};AbstractProductA* ConcreteFactory2::CreateProductA()
{return new ConcreteProductA2();
}AbstractProductB* ConcreteFactory2::CreateProductB()
{return new ConcreteProductB2();
}

测试函数

void ClientTest()
{AbstractFactory* pFactory1 = new ConcreteFactory1();AbstractFactory* pFactory2 = new ConcreteFactory2();AbstractProductA* pProductA1 = pFactory1->CreateProductA();AbstractProductB* pProductB1 = pFactory1->CreateProductB();AbstractProductA* pProductA2 = pFactory2->CreateProductA();AbstractProductB* pProductB2 = pFactory2->CreateProductB();pProductA1->Show();      // "ConcreteProductA1 Show"pProductB1->Show();      // "ConcreteProductB1 Show"pProductA2->Show();      // "ConcreteProductA2 Show"pProductB2->Show();      // "ConcreteProductB2 Show"delete pFactory1;delete pFactory2;delete pProductA1;delete pProductB1;delete pProductA2;delete pProductB2;
}

汽车生产抽象工厂模式示例

类图关系如下
在这里插入图片描述
工厂的抽象方向为品牌族，而产品的抽象方向为车型，一个具体的工厂只生产同一品牌的不同车型，这样的划分就刚好符合抽象工厂模式。产品分类表格如下：

	SUV	轿车
宝马	宝马SUV	宝马轿车
奔驰	奔驰SUV	奔驰轿车

SUV车型基类

/*** @brief SUV车型基类*/
class BaseSuv
{
public:BaseSuv() = default;virtual ~BaseSuv() = default;public:virtual void Show() = 0;
};

宝马SUV车型

/*** @brief 宝马SUV车型*/
class BMWSuv : public BaseSuv
{
public:BMWSuv() = default;~BMWSuv() = default;public:void Show() override;
};void BMWSuv::Show()
{qDebug() << "BMWSuv Show";
}

奔驰SUV车型

/*** @brief 奔驰SUV车型*/
class BenzSuv : public BaseSuv
{
public:BenzSuv() = default;~BenzSuv() = default;public:void Show() override;
};void BenzSuv::Show()
{qDebug() << "BenzSuv Show";
}

轿车型基类

/*** @brief 轿车型基类*/
class BaseCar
{
public:BaseCar() = default;virtual ~BaseCar() = default;public:virtual void Show() = 0;
};

宝马轿车类

/*** @brief 宝马轿车类*/
class BMWCar : public BaseCar
{
public:BMWCar() = default;~BMWCar() = default;public:void Show() override;
};void BMWCar::Show()
{qDebug() << "BMWCar Show";
}

奔驰轿车类

/*** @brief 奔驰轿车类*/
class BenzCar : public BaseCar
{
public:BenzCar() = default;~BenzCar() = default;public:void Show() override;
};void BenzCar::Show()
{qDebug() << "BenzCar Show";
}

工厂抽象类

/*** @brief 工厂抽象类*/
class IFactory
{
public:IFactory() = default;virtual ~IFactory() = default;public:virtual BaseSuv* CreateSuv() = 0;               // 生产SUV车型virtual BaseCar* CreateCar() = 0;               // 生产轿车车型
};

宝马工厂类

/*** @brief 宝马工厂类*/
class BMWFactory : public IFactory
{
public:BMWFactory() = default;~BMWFactory() = default;public:BaseSuv* CreateSuv() override;BaseCar* CreateCar() override;
};BaseSuv* BMWFactory::CreateSuv()
{return new BMWSuv();
}BaseCar* BMWFactory::CreateCar()
{return new BMWCar();
}

奔驰工厂类

/*** @brief 奔驰工厂类*/
class BenzFactory : public IFactory
{
public:BenzFactory() = default;~BenzFactory() = default;public:BaseSuv* CreateSuv() override;BaseCar* CreateCar() override;
};BaseSuv* BenzFactory::CreateSuv()
{return new BenzSuv();
}BaseCar* BenzFactory::CreateCar()
{return new BenzCar();
}

测试函数

void ClientTest()
{IFactory* pBMWFactory = new BMWFactory();IFactory* pBenzFactory = new BenzFactory();BaseSuv* pBMWSuv = pBMWFactory->CreateSuv();BaseCar* pBMWCar = pBMWFactory->CreateCar();BaseSuv* pBenzSuv = pBenzFactory->CreateSuv();BaseCar* pBenzCar = pBenzFactory->CreateCar();pBMWSuv->Show();            // BMWSuv ShowpBMWCar->Show();            // BMWCar ShowpBenzSuv->Show();           // BenzSuv ShowpBenzCar->Show();           // BenzCar Showdelete pBMWFactory;delete pBenzFactory;delete pBMWSuv;delete pBMWCar;delete pBenzSuv;delete pBenzCar;
}