Chapter5—抽象工厂模式

LoveXming2025-09-16 9:57

抽象工厂模式

1 概念

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

2 意图(Intent)

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

3 动机(Motivate)

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

4 类图结构

5 角色定义

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

6 程序示例

基本抽象工厂

抽象产品A类

cpp 复制代码 
/**
 * @brief 抽象产品A类
 */
class AbstractProductA
{
public:
    AbstractProductA() = default;
    virtual ~AbstractProductA() = default;

public:
    virtual void Show() = 0;
};

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

cpp 复制代码 
/**
 * @brief 具体产品A1类(属于1族)
 */
class ConcreteProductA1: public AbstractProductA
{
public:
    ConcreteProductA1() = default;
    ~ConcreteProductA1() = default;

public:
    void Show() override;
};

void ConcreteProductA1::Show()
{
    qDebug() << "ConcreteProductA1 Show";
}

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

cpp 复制代码 
/**
 * @brief 具体产品A2类(属于2族)
 */
class ConcreteProductA2: public AbstractProductA
{
public:
    ConcreteProductA2() = default;
    ~ConcreteProductA2() = default;

public:
    void Show() override;
};

void ConcreteProductA2::Show()
{
    qDebug() << "ConcreteProductA2 Show";
}

抽象产品B类

cpp 复制代码 
/**
 * @brief 抽象产品B类
 */
class AbstractProductB
{
public:
    AbstractProductB() = default;
    virtual ~AbstractProductB() = default;

public:
    virtual void Show() = 0;
};

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

cpp 复制代码 
/**
 * @brief 具体产品B1类(属于1族)
 */
class ConcreteProductB1: public AbstractProductB
{
public:
    ConcreteProductB1() = default;
    ~ConcreteProductB1() = default;

public:
    void Show() override;
};

void ConcreteProductB1::Show()
{
    qDebug() << "ConcreteProductB1 Show";
}

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

cpp 复制代码 
/**
 * @brief 具体产品B2类(属于2族)
 */
class ConcreteProductB2: public AbstractProductB
{
public:
    ConcreteProductB2() = default;
    ~ConcreteProductB2() = default;

public:
    void Show() override;
};

void ConcreteProductB2::Show()
{
    qDebug() << "ConcreteProductB2 Show";
}

抽象工厂类

cpp 复制代码 
/**
 * @brief 抽象工厂类
 */
class AbstractFactory
{
public:
    AbstractFactory() = default;
    virtual ~AbstractFactory() = default;

public:
    virtual AbstractProductA* CreateProductA() = 0;
    virtual AbstractProductB* CreateProductB() = 0;
};

具体工厂，生产1族产品

cpp 复制代码 
/**
 * @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族产品

cpp 复制代码 
/**
 * @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();
}

测试函数

cpp 复制代码 
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车型基类

cpp 复制代码 
/**
 * @brief SUV车型基类
 */
class BaseSuv
{
public:
    BaseSuv() = default;
    virtual ~BaseSuv() = default;

public:
    virtual void Show() = 0;
};

宝马SUV车型

cpp 复制代码 
/**
 * @brief 宝马SUV车型
 */
class BMWSuv : public BaseSuv
{
public:
    BMWSuv() = default;
    ~BMWSuv() = default;

public:
    void Show() override;
};

void BMWSuv::Show()
{
    qDebug() << "BMWSuv Show";
}

奔驰SUV车型

cpp 复制代码 
/**
 * @brief 奔驰SUV车型
 */
class BenzSuv : public BaseSuv
{
public:
    BenzSuv() = default;
    ~BenzSuv() = default;

public:
    void Show() override;
};

void BenzSuv::Show()
{
    qDebug() << "BenzSuv Show";
}

轿车型基类

cpp 复制代码 
/**
 * @brief 轿车型基类
 */
class BaseCar
{
public:
    BaseCar() = default;
    virtual ~BaseCar() = default;

public:
    virtual void Show() = 0;
};

宝马轿车类

cpp 复制代码 
/**
 * @brief 宝马轿车类
 */
class BMWCar : public BaseCar
{
public:
    BMWCar() = default;
    ~BMWCar() = default;

public:
    void Show() override;
};

void BMWCar::Show()
{
    qDebug() << "BMWCar Show";
}

奔驰轿车类

cpp 复制代码 
/**
 * @brief 奔驰轿车类
 */
class BenzCar : public BaseCar
{
public:
    BenzCar() = default;
    ~BenzCar() = default;

public:
    void Show() override;
};

void BenzCar::Show()
{
    qDebug() << "BenzCar Show";
}

工厂抽象类

cpp 复制代码 
/**
 * @brief 工厂抽象类
 */
class IFactory
{
public:
    IFactory() = default;
    virtual ~IFactory() = default;

public:
    virtual BaseSuv* CreateSuv() = 0;               // 生产SUV车型
    virtual BaseCar* CreateCar() = 0;               // 生产轿车车型
};

宝马工厂类

cpp 复制代码 
/**
 * @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();
}

奔驰工厂类

cpp 复制代码 
/**
 * @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();
}

测试函数

cpp 复制代码 
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 Show
    pBMWCar->Show();            // BMWCar Show

    pBenzSuv->Show();           // BenzSuv Show
    pBenzCar->Show();           // BenzCar Show

    delete pBMWFactory;
    delete pBenzFactory;

    delete pBMWSuv;
    delete pBMWCar;

    delete pBenzSuv;
    delete pBenzCar;
}

7 思考小结

  • 如果没有应对"多系列对象构建"的需求变化，则没有必要使用Abstract Factory模式，这时候使用简单的工厂完全可以。
  • "系列对象"指的是这些对象之间有相互依赖、或作用的关系，例如游戏开发场景中的"道路"与"房屋"的依赖，"道路"与"地道"的依赖。
  • Abstract Factory模式主要在于应对"新系列"的需求变动。其缺点在于难以应对"新对象"的需求变动。
相关推荐
青草地溪水旁2 小时前
设计模式(C++)详解—抽象工厂模式 (Abstract Factory)(2)
c++·设计模式·抽象工厂模式
青草地溪水旁2 小时前
设计模式(C++)详解—抽象工厂模式 (Abstract Factory)(1)
c++·设计模式·抽象工厂模式
Meteors.11 天前
23种设计模式——抽象工厂模式（Abstract Factory Pattern）详解
设计模式·抽象工厂模式
柯南二号12 天前
【Android】【设计模式】抽象工厂模式改造弹窗组件必知必会
android·设计模式·抽象工厂模式
hai_qin23 天前
三，设计模式-抽象工厂模式
c++·设计模式·抽象工厂模式
o0向阳而生0o1 个月前
93、23种设计模式之抽象工厂模式
设计模式·抽象工厂模式
哈基米喜欢哈哈哈1 个月前
设计模式(一)——抽象工厂模式
设计模式·抽象工厂模式
欲儿3 个月前
抽象工厂设计模式
java·设计模式·抽象工厂模式
OpenC++3 个月前
【C++】简单工厂模式/工厂方法模式/抽象工厂模式对比
c++·设计模式·简单工厂模式·工厂方法模式·抽象工厂模式
热门推荐
01GitHub 镜像站点02UV 工具安装与国内镜像源配置指南03UV安装并设置国内源0446个Nano-banana 精选提示词，持续更新中05A股预测还能更准？开源大模型Kronos带你跑通预测+回测全流程06解决 WSL Ubuntu 中 /etc/resolv.conf 自动重置问题07KGG转MP3工具|非KGM文件|解密音频08conda中设置镜像地址（附所有可换的地址）09智能库存管理的需求预测模型：从业务痛点到落地代码的完整实践10Claude Code 平替：OpenAI发布 Codex CLI ，GPT-5 国内直接使用