在抽象工厂模式中，我引用从网上看来的一篇例子来说明。
随着时间的推移，走过的地方越来越多，你天南海北的朋友也越来越多。你发现菜原来还分了许多菜系，鲁菜、粤菜、湘菜等等， 你招待
不同的朋友要用不同的菜系，这下难办了，你的厨师都是鲁菜风味，怎么办，广东的朋友来了吃不惯。现在我们再回到简单工厂模式，我们把
红烧肉再向下继承，生成鲁菜红烧肉、粤菜红烧肉、湘菜红烧肉；清蒸鱼向下继承为鲁菜清蒸鱼、粤菜清蒸鱼、湘菜清蒸鱼，其它也以此类
推。我们也修改一下这个类，不让其返回食物基类，而是返回红烧肉、清蒸鱼这一层次，并把这些方法抽象化，作为菜系工厂基类，然后再从
此基类继承出，鲁菜工厂、粤菜工厂、湘菜工厂等等，再由这些具体工厂实现创建具体菜的工作，哈哈你如果招待广东朋友就用粤菜工厂，返
回的就是一桌粤菜菜系的红烧肉、清蒸鱼了，你的广东朋友一定会吃的非常合乎胃口了。噢，非常好，你已经实现了抽象工厂模式了。结构模
型图也变成了的样子了。
现在可以看到，想新来做一个菜系，只需新聘请一个厨师就可以了，多么完美，但是如果你想新增加一个菜就变得非常困难了。
实现代码：
//产品基类
#include <iostream>
class FoodProduct
{
public:
FoodProduct(void);
~FoodProduct(void);
virtual void Delicious();
};
//红烧鱼类
class BraisingFish :public FoodProduct
{
public:
BraisingFish(void);
~BraisingFish(void);
virtual void Delicious();
};
//清蒸鱼类
class SteamedFish :public FoodProduct
{
public:
SteamedFish(void);
~SteamedFish(void);
virtual void Delicious();
};
//川式清蒸鱼
class ChuanBraisingFish :public BraisingFish
{
public:
ChuanBraisingFish(void);
~ChuanBraisingFish(void);
virtual void Delicious();
};
//鲁式清蒸鱼
class LuBraisingFish :public BraisingFish
{
public:
LuBraisingFish(void);
~LuBraisingFish(void);
virtual void Delicious();
};
//川（鲁）式红烧鱼类的写法与清蒸鱼类相同
//下面实现烹饪工厂
//烹饪总工厂
class CookFactory
{
public:
CookFactory(void);
~CookFactory(void);
virtual BraisingFish *CookBraisingFish();
virtual SteamedFish *CookSteamedFish();
};
//鲁菜工厂
class LuCookFactory :public CookFactory
{
public:
LuCookFactory(void);
~LuCookFactory(void);
virtual BraisingFish *CookBraisingFish();
virtual SteamedFish *CookSteamedFish();
};
//鲁菜工厂的实现
BraisingFish *LuCookFactory::CookBraisingFish()
{
std::cout<<"The Lu BraisingFish is Cooked!"<<std::endl;
return new LuBraisingFish();
}
SteamedFish *LuCookFactory::CookSteamedFish()
{
std::cout<<"The Lu StramedFish is Cooked!"<<std::endl;
return new LuSteamedFish();
}
//川菜工厂
class ChuanCookFactory :public CookFactory
{
public:
ChuanCookFactory(void);
~ChuanCookFactory(void);
virtual BraisingFish *CookBraisingFish();
virtual SteamedFish *CookSteamedFish();
};
//川菜工厂的实现
BraisingFish *ChuanCookFactory::CookBraisingFish()
{
std::cout<<"The Chuan BraisingFish is Cooked!"<<std::endl;
return new ChuanBraisingFish();
}
SteamedFish *ChuanCookFactory::CookSteamedFish()
{
std::cout<<"The Chuan SteamedFish is Cooked!"<<std::endl;
return new ChuanSteamedFish();
}
//下面是客户端的实现
int main(void)
{
CookFactory *cookFac = new LuCookFactory();
BraisingFish *braFish = cookFac->CookBraisingFish();
braFish->Delicious();
std::cout<<"******************************************/n";
delete braFish;
SteamedFish *steFish = cookFac->CookSteamedFish();
steFish->Delicious();
std::cout<<"******************************************/n";
delete steFish;
delete cookFac;
cookFac = new ChuanCookFactory();
braFish = cookFac->CookBraisingFish();
braFish->Delicious();
std::cout<<"******************************************/n";
delete braFish;
steFish = cookFac->CookSteamedFish();
steFish->Delicious();
delete steFish;
system("pause");
return 0;
}
至此，抽象工厂模式完成。
现在可以和工厂模式对比一下，抽象工厂返回的接口不再是产品A和产品B的共同基类Product了，而是产品A、产品B基类（在工厂模式
中它们为具体实现类，这里变成了基类）了。此时工厂的抽象和简单工厂中的工厂方法也很类似，就是这些特征区使其别于工厂模式而变成抽
象工厂模式了，因此抽象工厂解决的是创建一系列有共同风格的产品（鲁菜还是粤菜），而工厂方法模式解决的创建有共同特征的一系列产品
（红烧肉、清蒸鱼它们都是食物）。当然简单工厂的缺陷在抽象工厂中又再次出现了，我要新增加一个产品，工厂抽象接口就要改变了。因此
抽象工厂并不比工厂模式完美，只不过是各自的适用领域不同而已。其实，这里如果把抽象工厂模式的接口返回产品A和产品B的共同基类
（工厂模式返回的参数），你会发现，奇怪这个模式怎么这么眼熟，它不是恰恰退化成工厂模式了。
类模式与对象模式的区别讨论：先看定义类“模式使用继承关系，把对象的创建延迟的子类，对象模式把对象的创建延迟到另一个对象
中”。 分析：首先它们创建对象都不是在基类中完成，都是在子类中实现，因此都符合类模式的概念；但是工厂模式的创建产品对象是在编
译期决定的，要调用某个工厂固定的，而抽象工厂模式对产品的创建是在运行时动态决定的，只有到运行时才确定要调用那个工厂，调用工厂
随运行环境而改变。
适用性：
- 一个系统要独立于它的产品的创建、组合和表示时
- 一个系统要由多个 产品系列中的一个来配置时
- 当你要强调一个系列相关的产品对象的设计以便进行联合使用时
- 当你提供一个产品类库，而只想显示它们的接口而不是实现时。