设计模式之抽象工厂

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

适用性：

一个系统要独立于它的产品创建、组合和表示。

一个系统要由多个产品系列的一个来配置时。

当你要强调一系列相关的产品对象的设计以便进行联合使用时。

当你提供一个产品类库，而只想显示他们的接口而不是实现时。

抽象工厂结构：

抽象工厂的划分维度：抽象工厂主要以产品等级和产品族来划分二维维度， 以产品族为纵坐标， 产品等级为横坐标，产品等级拓展比较容易而产品族的拓展比较麻烦，这也是抽象工厂的缺点。如下划分性别和肤色的产品族和产品等级划分。可将产品族以肤色划分，性别分为不同等级，创建两个工厂，分别生产不同的肤色的男人，不同肤色的女人。

工厂模式的示例代码如下：

/*抽象工厂模式是一个简单的模式，使用的场景非常多，大家在软件产品开发过程中，
涉及到不同操作系统的时候，都可以考虑使用抽象工厂模式，例如一个应用，需要在三个不同平台上运行：
Windows、Linux、Android（Google发布的智能终端操作系统）上运行，你会怎么设计？分别设计三套不同的应用？非也非也，
通过抽象工厂模式屏蔽掉操作系统对应用的影响。三个不同操作系统上的软件功能、应用逻辑、UI都应该是非常类似，唯一不同的是调用不同的工厂方法，
由不同的产品类去处理与操作系统交互的信息。*/

/*AbstractFactory.h*/

#include "Product.h"

class ProductA;
class ProductB;
class AbstreactFactory
{
public:
	virtual ProductA* CreateProductA() = 0;
	virtual ProductB* CreateProductB() = 0;
};

class ConcreteFactoryA : public AbstreactFactory
{
public:
	ConcreteFactoryA(){};
	virtual ~ConcreteFactoryA(){};
	virtual ProductA* CreateProductA();
	virtual ProductB* CreateProductB();
};

class ConcreteFactoryB : public AbstreactFactory
{
public:
	ConcreteFactoryB(){};
	virtual ~ConcreteFactoryB(){};
	virtual ProductA* CreateProductA();
	virtual ProductB* CreateProductB();
};

AbstractFactory.cpp

#include "AbstractFactory.h"
ProductA *ConcreteFactoryA::CreateProductA()
{
	return new ProductA1();
}

ProductB * ConcreteFactoryA::CreateProductB()
{
	return new ProductB1();
}


ProductA* ConcreteFactoryB::CreateProductA()
{
	return new ProductA2();
}

ProductB* ConcreteFactoryB::CreateProductB()
{
	return new ProductB2();
}

Pruduct.h

#ifndef PRODUCT_H_
#define PRODUCT_H_

//ProductA 和 ProductB 分别代表两种不同产品族手机和电脑.比如ProductA代表手机 而ProductB代表电脑

//ProductA1代表Linux操作系统的手机，ProductA2代表windowsx系统手机
class ProductA
{
public:
	virtual void show() = 0;
};


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

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


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

//ProductB1代表Linux操作系统的电脑，ProductB2代表Windows系统的电脑
class ProductB1 :public ProductB
{
public:
	ProductB1(){};
	virtual ~ProductB1(){};
	virtual void show();
};

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

Product.cpp

#include "Product.h"
#include <iostream>


void ProductA1::show()
{
	std::cout << "Product A1 is show!!\n";
}


void ProductA2::show()
{
	std::cout << "Product A2 is show!!\n";
}



void ProductB1::show()
{
	std::cout << "Product B1 is show!!\n";
}


void ProductB2::show()
{
	std::cout << "Product B2 is show!!\n";
}

main.cpp

#include "AbstractFactory.h"

int main()
{
	ConcreteFactoryA *pFacA = new ConcreteFactoryA();
	pFacA->CreateProductA()->show();
	pFacA->CreateProductB()->show();

	ConcreteFactoryB* pFcB = new ConcreteFactoryB();
	pFcB->CreateProductA()->show();
	pFcB->CreateProductB()->show();


	return 0;
}

 抽象工厂模式的优点

• 封装性，每个产品的实现类不是高层模块要关系的，要关心的是什么？是接口，是抽象，它不关心对象是如何创建出来，这由谁负责呢？工厂类，只要知道工厂类是谁，我就能创建出一个需要的对象，省时省力，优秀设计就应该如此。
• 产品族内的约束为非公开状态。例如生产男女比例的问题上，猜想女娲娘娘肯定有自己的打算，不能让女盛男衰，否则女性的优点不就体现不出来了吗？那在抽象工厂模式，就应该有这样的一个约束：每生产1个女性，就同时生产出1.2个男性，这样的生产过程对调用工厂类的高层模块来说是透明的，它不需要知道这个约束，我就是要一个黄色女性产品就可以了，具体的产品族内的约束是在工厂内实现的。

抽象工厂模式的缺点

     抽象工厂模式的最大缺点就是产品族扩展非常困难，为什么这么说呢？我们以通用代码为例，如果要增加一个产品C，也就是说有产品家族由原来的2个，增加到3个，看看我们的程序有多大改动吧！抽象类AbstractCreator要增加一个方法createProductC()，然后，两个实现类都要修改，想想看，这在项目中的话，还这么让人活！严重违反了开闭原则，而且我们一直说明抽象类和接口是一个契约，改变契约，所有与契约有关系的代码都要修改，这段代码叫什么？叫“有毒代码”，——只要这段代码有关系，就可能产生侵害的危险！

 抽象工厂模式的使用场景

     抽象工厂模式的使用场景定义非常简单：一个对象族（或是一组没有任何关系的对象）都有相同的约束，则可以使用抽象工厂模式，什么意思呢？例如一个文本编辑器和一个图片处理器，都是软件实体，但是*nix下的文本编辑器和WINDOWS下的文本编辑器虽然功能和界面都相同，但是代码实现是不同的，图片处理器也是类似情况，也就是具有了共同的约束条件：操作系统类型，于是我们可以使用抽象工厂模式，产生不同操作系统下的编辑器和图片处理器。

 抽象工厂模式的注意实现

     在抽象工厂模式的缺点中，我们提到抽象工厂模式的产品族扩展比较困难，但是一定要清楚是产品族扩展困难，而不是产品等级，在该模式下，产品等级是非常容易扩展的，增加一个产品等级，只要增加一个工厂类负责新增加出来的产品生产任务即可，也就是说横向扩展容易，纵向扩展困难。以人类为例子， 产品等级中只要男、女两个性别，现实世界还有一种性别：双性人，即使男人也是女人（俗语就是阴阳人），那我们要扩展这个产品等级也是非常容易的，增加三个产品类，分别对应不同的肤色，然后再创建一个工厂类，专门负责不同肤色人的双性人的创建任务，完全通过扩展来实现的需求的变更，从这一点上看，抽象工厂模式是符合开闭原则的。

最佳实践

     一个模式在什么情况下才能够使用，是很多读者比较困惑的地方，抽象工厂模式是一个简单的模式，使用的场景非常多，大家在软件产品开发过程中，涉及到不同操作系统的时候，都可以考虑使用抽象工厂模式，例如一个应用，需要在三个不同平台上运行：Windows、Linux、Android（Google发布的智能终端操作系统）上运行，你会怎么设计？分别设计三套不同的应用？非也非也，通过抽象工厂模式屏蔽掉操作系统对应用的影响。三个不同操作系统上的软件功能、应用逻辑、UI都应该是非常类似，唯一不同的是调用不同的工厂方法，由不同的产品类去处理与操作系统交互的信息