设计模式：抽象工厂模式（Abstract Factory）
设计模式：抽象工厂模式（Abstract Factory）
抽象工厂模式（Abstract Factory）属于创建型模式（Creational Pattern）的一种。
创建型模式（Creational Pattern）对类的实例化过程进行了抽象，能够将软件模块中对象的创建和对象的使用分离。为了使软件的结构更加清晰，外界对于这些对象只需要知道它们共同的接口，而不清楚其具体的实现细节，使整个系统的设计更加符合单一职责原则。
创建型模式在创建什么（What），由谁创建（Who），何时创建（When）等方面都为软件设计者提供了尽可能大的灵活性。创建型模式隐藏了类的实例的创建细节，通过隐藏对象如何被创建和组合在一起达到使整个系统独立的目的。
模式动机
在工厂方法模式中具体工厂负责生产具体的产品，每一个具体工厂对应一种具体产品，工厂方法也具有唯一性，一般情况下，一个具体工厂中只有一个工厂方法或者一组重载的工厂方法。但是有时候我们需要一个工厂可以提供多个产品对象，而不是单一的产品对象。
为了更清晰地理解工厂方法模式，需要先引入两个概念：
- 产品等级结构 ：产品等级结构即产品的继承结构。比如，一个抽象类是电视机，其子类有海尔电视机、海信电视机、TCL电视机，则抽象电视机与具体品牌的电视机之间构成了一个产品等级结构，抽象电视机是父类，而具体品牌的电视机是其子类。
- 产品族 ：在抽象工厂模式中，产品族是指由同一个工厂生产的，位于不同产品等级结构中的一组产品，如海尔电器工厂生产的海尔电视机、海尔电冰箱，海尔电视机位于电视机产品等级结构中，海尔电冰箱位于电冰箱产品等级结构中。
当系统所提供的工厂所需生产的具体产品并不是一个简单的对象，而是多个位于不同产品等级结构中属于不同类型的具体产品时需要使用抽象工厂模式。
抽象工厂模式是所有形式的工厂模式中最为抽象和最具一般性的一种形态。
模式定义
抽象工厂模式（Abstract Factory Pattern）提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。
抽象工厂模式又称为Kit模式，属于对象创建型模式。
模式结构
抽象工厂模式包含以下几个核心角色：
- 抽象工厂（Abstract Factory）：声明了一组用于创建产品对象的方法，每个方法对应一种产品类型。抽象工厂可以是接口或抽象类。
- 具体工厂（Concrete Factory）：实现了抽象工厂接口，负责创建具体产品对象的实例。
- 抽象产品（Abstract Product）：定义了一组产品对象的共同接口或抽象类，描述了产品对象的公共方法。
- 具体产品（Concrete Product）：实现了抽象产品接口，定义了具体产品的特定行为和属性。
抽象工厂模式通常涉及一族相关的产品，每个具体工厂类负责创建该族中的具体产品。客户端通过使用抽象工厂接口来创建产品对象，而不需要直接使用具体产品的实现类。
时序图
模式实现
抽象工厂类 AbstractFactory.h：
#ifndef _ABSTRACT_FACTORY_H_
#define _ABSTRACT_FACTORY_H_
#include <string>
#include "ConcreteProductA1.h"
#include "ConcreteProductB1.h"
class AbstractFactory
{
public:
virtual AbstractProductA* createProductA() = 0;
virtual AbstractProductB* createProductB() = 0;
};
#endif // !_ABSTRACT_FACTORY_H_
具体工厂1类 ConcreteFactory1.h：
#ifndef _CONCRETE_FACTORY_1_H_
#define _CONCRETE_FACTORY_1_H_
#include "AbstractFactory.h"
#include "ConcreteProductA1.h"
#include "ConcreteProductB1.h"
class ConcreteFactory1 : public AbstractFactory
{
public:
AbstractProductA* createProductA() override
{
return new ConcreteProductA1();
}
AbstractProductB* createProductB() override
{
return new ConcreteProductB1();
}
};
#endif // !_CONCRETE_FACTORY_1_H_
具体工厂2类 ConcreteFactory2.h：
#ifndef _CONCRETE_FACTORY_2_H_
#define _CONCRETE_FACTORY_2_H_
#include "AbstractFactory.h"
#include "ConcreteProductA2.h"
#include "ConcreteProductB2.h"
class ConcreteFactory2 : public AbstractFactory
{
public:
AbstractProductA* createProductA() override
{
return new ConcreteProductA2();
}
AbstractProductB* createProductB() override
{
return new ConcreteProductB2();
}
};
#endif // !_CONCRETE_FACTORY_2_H_
抽象产品A类 AbstractProductA.h：
#ifndef _ABSTRACT_PRODUCT_A_H_
#define _ABSTRACT_PRODUCT_A_H_
#include <iostream>
class AbstractProductA
{
public:
virtual void use() = 0;
};
#endif // !_ABSTRACT_PRODUCT_A_H_
具体产品A1类 AbstractProductA1.h：
#ifndef _CONCRETE_PRODUCT_A_1_H_
#define _CONCRETE_PRODUCT_A_1_H_
#include "AbstractProductA.h"
class ConcreteProductA1 : public AbstractProductA
{
public:
void use() override
{
std::cout << "Using Concrete Product A1" << std::endl;
}
};
#endif // !_CONCRETE_PRODUCT_A_1_H_
具体产品A2类 AbstractProductA2.h：
#ifndef _CONCRETE_PRODUCT_A_2_H_
#define _CONCRETE_PRODUCT_A_2_H_
#include "AbstractProductA.h"
class ConcreteProductA2 : public AbstractProductA
{
public:
void use() override
{
std::cout << "Using Concrete Product A2" << std::endl;
}
};
#endif // !_CONCRETE_PRODUCT_A_2_H_
抽象产品B类 AbstractProductB.h：
#ifndef _ABSTRACT_PRODUCT_B_H_
#define _ABSTRACT_PRODUCT_B_H_
#include <iostream>
class AbstractProductB
{
public:
virtual void eat() = 0;
};
#endif // !_ABSTRACT_PRODUCT_B_H_
具体产品B1类 AbstractProductB1.h：
#ifndef _CONCRETE_PRODUCT_B_1_H_
#define _CONCRETE_PRODUCT_B_1_H_
#include "AbstractProductB.h"
class ConcreteProductB1 : public AbstractProductB
{
public:
void eat() override
{
std::cout << "Eating Concrete Product B1" << std::endl;
}
};
#endif // !_CONCRETE_PRODUCT_B_1_H_
具体产品B2类 AbstractProductB2.h：
#ifndef _CONCRETE_PRODUCT_B_2_H_
#define _CONCRETE_PRODUCT_B_2_H_
#include "AbstractProductB.h"
class ConcreteProductB2 : public AbstractProductB
{
public:
void eat() override
{
std::cout << "Eating Concrete Product B2" << std::endl;
}
};
#endif // !_CONCRETE_PRODUCT_B_2_H_
测试
测试代码 main.cpp：
#include <stdlib.h>
#include "ConcreteFactory1.h"
#include "ConcreteFactory2.h"
#include "AbstractProductA.h"
#include "AbstractProductB.h"
int main()
{
AbstractFactory* pcf1 = new ConcreteFactory1();
AbstractProductA* pA1 = pcf1->createProductA();
AbstractProductB* pB1 = pcf1->createProductB();
if (pA1)
pA1->use();
if (pB1)
pB1->eat();
AbstractFactory* pcf2 = new ConcreteFactory2();
AbstractProductA* pA2 = pcf2->createProductA();
AbstractProductB* pB2 = pcf2->createProductB();
if (pA2)
pA2->use();
if (pB2)
pB2->eat();
delete pA1;
delete pB1;
delete pA2;
delete pB2;
system("pause");
return 0;
}
运行结果：
优缺点
优点：
- 抽象工厂模式隔离了具体类的生成，使得客户并不需要知道什么被创建。由于这种隔离，更换一个具体工厂就变得相对容易。所有的具体工厂都实现了抽象工厂中定义的那些公共接口，因此只需改变具体工厂的实例，就可以在某种程度上改变整个软件系统的行为。另外，应用抽象工厂模式可以实现高内聚低耦合的设计目的，因此抽象工厂模式得到了广泛的应用。
- 当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一个产品族中的对象。这对一些需要根据当前环境来决定其行为的软件系统来说，是一种非常实用的设计模式。
- 增加新的具体工厂和产品族很方便，无须修改已有系统，符合“开闭原则”。
缺点：
- 在添加新的产品对象时，难以扩展抽象工厂来生产新种类的产品，这是因为在抽象工厂角色中规定了所有可能被创建的产品集合，要支持新种类的产品就意味着要对该接口进行扩展，而这将涉及到对抽象工厂角色及其所有子类的修改，显然会带来较大的不便。
- 开闭原则的倾斜性（增加新的工厂和产品族容易，增加新的产品等级结构麻烦）。
模式应用
在很多软件系统中需要更换界面主题，要求界面中的按钮、文本框、背景色等一起发生改变时，可以使用抽象工厂模式进行设计。
模式拓展
“开闭原则”的倾斜性
“开闭原则”要求系统对扩展开放，对修改封闭，通过扩展达到增强其功能的目的。对于涉及到多个产品族与多个产品等级结构的系统，其功能增强包括两方面：
- 增加产品族：对于增加新的产品族，工厂方法模式很好的支持了“开闭原则”，对于新增加的产品族，只需要对应增加一个新的具体工厂即可，对已有代码无须做任何修改。
- 增加新的产品等级结构：对于增加新的产品等级结构，需要修改所有的工厂角色，包括抽象工厂类，在所有的工厂类中都需要增加生产新产品的方法，不能很好地支持“开闭原则”。
抽象工厂模式的这种性质称为“开闭原则”的倾斜性，抽象工厂模式以一种倾斜的方式支持增加新的产品，它为新产品族的增加提供方便，但不能为新的产品等级结构的增加提供这样的方便。
工厂模式的退化
当抽象工厂模式中每一个具体工厂类只创建一个产品对象，也就是只存在一个产品等级结构时，抽象工厂模式退化成工厂方法模式。
当工厂方法模式中抽象工厂与具体工厂合并，提供一个统一的工厂来创建产品对象，并将创建对象的工厂方法设计为静态方法时，工厂方法模式退化成简单工厂模式。
抽象工厂模式与工厂方法模式的区别
抽象工厂模式与工厂方法模式最大的区别在于，工厂方法模式针对的是一个产品等级结构，而抽象工厂模式则需要面对多个产品等级结构，一个工厂等级结构可以负责多个不同产品等级结构中的产品对象的创建 。当一个工厂等级结构可以创建出分属于不同产品等级结构的一个产品族中的所有对象时，抽象工厂模式比工厂方法模式更为简单、有效率。
1695
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
