设计模式之抽象工厂模式

       工厂模式属于创建型模式，大致可以分为三类，简单工厂模式、工厂方法模式、抽象工厂模式。听上去差不多，都是工厂模式。这里我主要介绍抽象工厂模式，认识了抽象工厂模式，简单工厂模式，工厂方法模式自然而然就明白了，当每个抽象产品都有多于一个的具体子类的时候，工厂角色怎么知道实例化哪一个子类呢？比如每个抽象产品角色都有两个具体产品。抽象工厂模式提供两个具体工厂角色，分别对应于这两个具体产品角色，每一个具体工厂角色只负责某一个产品角色的实例化。每一个具体工厂类只负责创建抽象产品的某一个具体子类的实例。对于每一个产品族，都有一个具体工厂。而每一个具体工厂创建属于同一个产品族，但是分属于不同等级结构的产品。

举个例子：假设现在有宝马，奔驰两种产品的车子，每辆车子都必须由轮子，外壳，引擎组装起来！
宝马，奔驰     ——> 对应两种产品 ——>就会有两个工厂（宝马工厂，奔驰工厂）
宝马工厂创建 ——>就会涉及宝马牌的轮子，外壳，引擎中的一个创建，而轮子，外壳，引擎是同属于一个宝马产品族的，但是很明显是宝马车上的不同的零件（等级结构）

下面给出抽象工厂的解决方案

class Abstarctwheel
{
public:
	virtual void Concrete() = 0; 
};

class AbstarctShell
{
public:
	virtual void Concrete() = 0; 
};

class AbstarctEngine
{
public:
	virtual void Concrete() = 0; 
}; 
class BMWWheel:public Abstarctwheel
{
public:
	void Concrete()
	{
		cout<<"生产了一个宝马的轮子!"<<endl;
	}
};

class BenzWheel:public Abstarctwheel
{
public:
	void Concrete()
	{
		cout<<"生产了一个奔驰的轮子!"<<endl;
	}
};

class BMWShell:public AbstarctShell
{
public:
	void Concrete()
	{
		cout<<"生产了一个宝马的外壳!"<<endl;
	}
};

class BenzShell:public AbstarctShell
{
public:
	void Concrete()
	{
		cout<<"生产了一个奔驰的外壳!"<<endl;
	}
};

class BMWEngine:public AbstarctEngine
{
public:
	void Concrete()
	{
		cout<<"生产了一个宝马的发动机!"<<endl;
	}
};

class BenzEngine:public AbstarctEngine
{
public:
	void Concrete()
	{
		cout<<"生产了一个奔驰的发动机!"<<endl;
	}
};

以上不难看出是产品角色的实现，宝马，奔驰两个产品都有轮子，外壳，引擎这些配件

class FactoryInterFace
{
public:
	virtual Abstarctwheel * ConcreateWheel() = 0;
	virtual AbstarctShell * ConcreateShell() = 0;
	virtual AbstarctEngine * ConcreateEngine() = 0;
};

class FactoryBWM:public FactoryInterFace
{
public:
	 Abstarctwheel * ConcreateWheel()
	 {
		return new BMWWheel();
	 }
	 AbstarctShell * ConcreateShell()
	 {
		 return  new BMWShell();
	 }

	 AbstarctEngine * ConcreateEngine()
	 {
		 return new BMWEngine();
	 }
};


class FactoryBenz:public FactoryInterFace
{
public:
	Abstarctwheel * ConcreateWheel()
	{
		return new BenzWheel();
	}
	AbstarctShell * ConcreateShell()
	{
		return  new BenzShell();
	}

	AbstarctEngine * ConcreateEngine()
	{
		return new BenzEngine();
	}
};

宝马，奔驰两个产品就对应了FactoryBMW，FactoryBenz两个具体工厂，而一个工厂的具体创建，可以看出是相应产品的轮子，外壳，引擎中一项的具体创建生产

int _tmain(int argc, _TCHAR* argv[])
{
	FactoryInterFace * Inter = new FactoryBenz();
	AbstarctShell * shell = Inter->ConcreateShell();
	shell->Concrete();
	return 0;
}

最后输出的是生产了一个奔驰的外壳!

以上抽象工厂模式就算实现了，而下面谈下个人对简单模式，工厂方法模式，抽象工厂模式的个人看法

        简单工厂模式，工厂方法模式，抽象工厂模式，个人觉得这三个模式其实模型上是相通的，说白了就是在简单工厂模式下不断优化最终达到抽象工厂模式，三种模式基础知识就是对面向对象多态的使用，用父类的指针指向子类的对象，从而通过父类的指针调用子类从父类派生过去的重写的方法（就是多态），只不过这里的父类是个纯虚类（相当于一个接口）而这三种模式通过加入了一个工厂类内部实现了这种多态，是通过工厂角色将产品角色包装起来了，直接操作工厂类从而达到间接实现相应产品的实例化，要是有新产品加入，比如大众汽车，只要加入大众产品，继承重写大众自己的轮子，外壳，引擎零件，再加入个大众工厂类，对于宝马，奔驰先前封装的完全不需要改动，而达到设计模式的要求

以下是三种设计模式的区别：

（1）简单工厂模式：通过工厂类，实现一个方法，根据传入的类型来确定最终返回的指针是指向哪一个子类的对象（就是确定实现哪一个子类的多态，以上例子就是：生产那个零件），但是你会发现这里你需要传入的类型来确定实现哪一个子类的多态，要是新加了一个子类的类型，就要修改原有的工厂类，违背了设计模式的开闭原则

（2）工厂方法模式：其实是对简单工厂模式的优化，实现了开闭原则！每新加子类的类型，就新加一个工厂类在里面通过派生工厂类接口（或纯虚类）的函数来实现返回哪一个子类的多态（派生好处在于实现工厂类的多态，就能知道返回了哪一个子类的类型），缺点不难发现，每增加一种产品，就需要增加一个对象的工厂，相比简单工厂模式，工厂方法模式需要更多的类定义

（3）抽象工厂模式：从例子上不难看出，其实模型还是工厂方法模式，只不过接口从提供的一个变成了一系列，提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类，可以处理具有相同（或者相似）等级结构的多个产品族中的产品对象的创建问题

         每一个模式都是针对一定问题的解决方案，简单工厂模式和工厂方法模式针对的是一个产品等级结构；而抽象工厂模式针对的是多个产品等级结构。至此对工厂模式初步了解介绍告一段落