抽象工厂模式

最新推荐文章于 2023-03-23 11:42:11 发布

贝勒里恩

最新推荐文章于 2023-03-23 11:42:11 发布

阅读量146

点赞数

CC 4.0 BY-SA版权

分类专栏： # 设计模式

本文链接：https://blog.youkuaiyun.com/Mr_robot_strange/article/details/110479500

设计模式专栏收录该内容

11 篇文章

订阅专栏

博客介绍了抽象工厂模式，它是在工厂方法模式基础上发展而来，通过工厂虚基类接口对应生产线，延迟具体子类实例化，集中生产线管理、节省资源。还指出工厂方法模式适用于产品种类单一的场合，而抽象工厂模式适用于产品种类结构多的场合。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、抽象工厂模式概念

简单工厂工厂模式可以通过传递不同的参数创建不同的对象，但是简单工厂模式不满足开闭原则，所以在此基础上推出了工厂方法模式；采用工厂–产品一对一原则，新增产品只需新增工厂即可，解决了开闭原则；但是后期产品会越来越多，建立的工厂也会越来越多，工厂变得凌乱而难以管理，而且每个工厂只能创建单一种类的产品，当需要生产一种全新的产品（不继承Product）时，发现工厂方法模式有点力不从心，所以在此基础上推出了抽象工厂模式；

抽象工厂模式中的工厂虚基类中的接口对应于生产线，而生产线实际需要生产什么样的产品，这是有具体工厂去决定的，这样便延迟了具体子类的实例化；同时集中化了生产线的管理，节省了资源的浪费。

抽象工厂模式常用代码结构：

//Abstract_Factory.h

#ifndef ABSTRACT_FACTORY_H
#define ABSTRACT_FACTORY_H

#include <QDebug>

class ProductA
{
public:
    ProductA();
    virtual ~ProductA();

    virtual void show() = 0;
};
class ProductA1 : public ProductA
{
public:
    ProductA1();
    ~ProductA1();

    void show();
};
class ProductA2 : public ProductA
{
public:
    ProductA2();
    ~ProductA2();

    void show();
};
//==================================================================
class ProductB
{
public:
    ProductB();
    virtual ~ProductB();

    virtual void show() = 0;
};
class ProductB1 : public ProductB
{
public:
    ProductB1();
    ~ProductB1();

    void show();
};
class ProductB2 : public ProductB
{
public:
    ProductB2();
    ~ProductB2();

    void show();
};
//==================================================================
class Factory
{
public:
    Factory();
    virtual ~Factory();

    virtual ProductA* CreateProductA() = 0;
    virtual ProductB* CreateProductB() = 0;

};
class Factory1 : public Factory
{
public:
    Factory1();
    ~Factory1();

    ProductA* CreateProductA();
    ProductB* CreateProductB();
};
class Factory2 : public Factory
{
public:
    Factory2();
    ~Factory2();

    ProductA* CreateProductA();
    ProductB* CreateProductB();
};


#endif // ABSTRACT_FACTORY_H

//Abstract_Factory.cpp
#include "abstract_factory.h"

ProductA::ProductA()
{

}
ProductA::~ProductA()
{

}
ProductA1::ProductA1()
{

}
ProductA1::~ProductA1()
{

}
void ProductA1::show()
{
    qDebug()<<"产品A1";
}

ProductA2::ProductA2()
{

}
ProductA2::~ProductA2()
{

}
void ProductA2::show()
{
    qDebug()<<"产品A2";
}
//==================================================================
ProductB::ProductB()
{

}
ProductB::~ProductB()
{

}
ProductB1::ProductB1()
{

}
ProductB1::~ProductB1()
{

}
void ProductB1::show()
{
    qDebug()<<"产品B1";
}
ProductB2::ProductB2()
{

}
ProductB2::~ProductB2()
{

}
void ProductB2::show()
{
    qDebug()<<"产品B2";
}
//==================================================================
Factory::Factory()
{

}
Factory::~Factory()
{

}

Factory1::Factory1()
{

}
Factory1::~Factory1()
{

}
ProductA* Factory1::CreateProductA()
{
    return new ProductA1();
}
ProductB* Factory1::CreateProductB()
{
    return new ProductB1();
}

Factory2::Factory2()
{

}
Factory2::~Factory2()
{

}
ProductA* Factory2::CreateProductA()
{
    return new ProductA2();
}
ProductB* Factory2::CreateProductB()
{
    return new ProductB2();
}

//main.cpp
Factory* factory1 = new Factory1;
ProductA* productA1 = factory1->CreateProductA();
ProductB* productB1 = factory1->CreateProductB();
productA1->show();
productB1->show();

Factory* factory2 = new Factory2;
ProductA* productA2 = factory2->CreateProductA();
ProductB* productB2 = factory2->CreateProductB();
productA2->show();
productB2->show();