抽象工厂模式（c++描述）

  在抽象工厂模式中，我引用从网上看来的一篇例子来说明。

 

   随着时间的推移，走过的地方越来越多，你天南海北的朋友也越来越多。你发现菜原来还分了许多菜系，鲁菜、粤菜、湘菜等等， 你招待

 

不同的朋友要用不同的菜系，这下难办了，你的厨师都是鲁菜风味，怎么办，广东的朋友来了吃不惯。现在我们再回到简单工厂模式，我们把

 

红烧肉再向下继承，生成鲁菜红烧肉、粤菜红烧肉、湘菜红烧肉；清蒸鱼向下继承为鲁菜清蒸鱼、粤菜清蒸鱼、湘菜清蒸鱼，其它也以此类

 

推。我们也修改一下这个类，不让其返回食物基类，而是返回红烧肉、清蒸鱼这一层次，并把这些方法抽象化，作为菜系工厂基类，然后再从

 

此基类继承出，鲁菜工厂、粤菜工厂、湘菜工厂等等，再由这些具体工厂实现创建具体菜的工作，哈哈你如果招待广东朋友就用粤菜工厂，返

 

回的就是一桌粤菜菜系的红烧肉、清蒸鱼了，你的广东朋友一定会吃的非常合乎胃口了。噢，非常好，你已经实现了抽象工厂模式了。结构模

 

型图也变成了的样子了。

 

 

 

 现在可以看到，想新来做一个菜系，只需新聘请一个厨师就可以了，多么完美，但是如果你想新增加一个菜就变得非常困难了。

 

实现代码：

 

//产品基类

#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的共同基类

 

（工厂模式返回的参数），你会发现，奇怪这个模式怎么这么眼熟，它不是恰恰退化成工厂模式了。

       类模式与对象模式的区别讨论：先看定义类“模式使用继承关系，把对象的创建延迟的子类，对象模式把对象的创建延迟到另一个对象

 

中”。 分析：首先它们创建对象都不是在基类中完成，都是在子类中实现，因此都符合类模式的概念；但是工厂模式的创建产品对象是在编

 

译期决定的，要调用某个工厂固定的，而抽象工厂模式对产品的创建是在运行时动态决定的，只有到运行时才确定要调用那个工厂，调用工厂

 

随运行环境而改变。

适用性：

• 一个系统要独立于它的产品的创建、组合和表示时
• 一个系统要由多个 产品系列中的一个来配置时
• 当你要强调一个系列相关的产品对象的设计以便进行联合使用时
• 当你提供一个产品类库，而只想显示它们的接口而不是实现时。