设计模式（二）工厂方法模式+抽象工厂模式

工厂方法模式与简单工厂模式的区别在于：简单工厂模式用单一工厂来生产所有同种类的产品，而工厂模式是用对应的工厂来生产同一种类的不同产品。对于工厂方法模式而言，其简单模型的UML为：

工厂方法模式的定义：定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到工厂抽象类的子类。

工厂方法模式的简单模型的代码：

#include<iostream>
using namespace std;
class Product {
public:
  virtual void show() =0;
};

class ProductA : public Product {
public:
    virtual  void show()
	{
		cout<<" I am A"<<endl;	
	} 
};

class ProductB : public Product {
public:
    virtual  void show()
	{
		cout<<" I am B"<<endl;	
	} 
};

class Factory
{
public:
	virtual Product * CreateProduct() = 0;
};

class FactoryA : public Factory
{
public:
	virtual Product *CreateProduct()
	{
		Product * temp;
		temp=new ProductA();
		return temp;
	}
};

class FactoryB : public Factory
{
public:
	virtual Product *CreateProduct()
	{
		Product * temp;
		temp=new ProductB();
		return temp;
	}
};

int main(int argc, char *argv[])
{
	
	Factory *ProducAFactory = new FactoryA();
	Product *productObjA = ProducAFactory->CreateProduct();
	if (productObjA != NULL)
		productObjA->show();

	Factory *ProducBFactory = new FactoryB();
	Product *productObjB = ProducBFactory->CreateProduct();
	if (productObjB != NULL)
		productObjB->show();

	delete ProducAFactory;
	delete productObjA;
	delete ProducBFactory;
	delete productObjB;
	return 0;
}

对于工厂方法模式而言，对于同一种类的不同产品，都要单独一个工厂为其生产对应的产品，随着产品数量的增加，工厂的数量也随着线性增长。由此工厂方法模式对于有着不同种类，且不同种类还有不同产品的对象生成管理，就会有一定的臃肿，由此，可以在一定程度上，结合简单工厂模式的特点，在有着多类型产品的对象生成中，可以让一个工厂负责生产同一类型的产品。这里，对于“同一类型”这个字眼的理解，可以有多种多样的理解，重点是如何尽可能的降低代码的冗余，同时保持良好的“开-闭”的特性，有良好的可扩展性。

抽象工厂模式：提供创建一系列相关或者相互依赖的对象的接口，而无需制定它们具体的类。

在“大话设计模式”这本书，在抽象工厂模式和工厂方法模式的例子我觉得觉得比较好，是一个关于数据库接口的问题，问题背景是：
一个公司最开始是通过sqlSever建立数据库的，而随着业务的变更，需要另外增加另外一种类型的数据库接口建立数据库。在只有一张表的情况下，用工厂方法模式的观点来建立模型的话，应该是这样的：

这张UML图代表的意思是：有一张Usr表，一张表是用于SqlServer数据库来方式维护的，另外一张是通过Access的数据库类维护的，那么如果需要维护另外一张关于住址Department的表呢，应该如何处理，按照抽象工厂模式的思想，就是在工厂中提供生产Department的接口。UML表示如下：

实现代码为：

#include<iostream>
using namespace std;
class Usr {
public:
  virtual void show() =0;
};

class SqlServerUsr : public Usr {
public:
    virtual  void show()
	{
		cout<<" SqlServer manage usr table"<<endl;	
	} 
};

class AccessUsr : public Usr {
public:
    virtual  void show()
	{
		cout<<" Access manage usr table"<<endl;	
	} 
};

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

class SqlServerDepartment : public Department {
public:
    virtual  void show()
	{
		cout<<" SqlServer manage Department table"<<endl;	
	} 
};
class AccessDepartment : public Department {
public:
    virtual  void show()
	{
		cout<<" Access manage Department table"<<endl;	
	} 
};
class serverFactory
{
public:
	virtual Usr * CreateUsr() = 0;
	virtual Department * CreateDepartment() = 0;
};

class sqlServerFactory : public serverFactory
{
public:
	virtual Usr *CreateUsr()
	{
		Usr * temp;
		temp=new SqlServerUsr();
		return temp;
	}
	
	virtual Department *CreateDepartment()
	{
		Department * temp;
		temp=new SqlServerDepartment();
		return temp;
	}
};

class AccessFactory : public serverFactory
{
public:
	virtual Usr *CreateUsr()
	{
		Usr * temp;
		temp=new AccessUsr();
		return temp;
	}
	virtual Department *CreateDepartment()
	{
		Department * temp;
		temp=new AccessDepartment();
		return temp;
	}
};
int main(int argc, char *argv[])
{
	 serverFactory *factorySql= new sqlServerFactory();
	 Usr *sqlUsr=factorySql->CreateUsr();
	 Department *departmentSql=factorySql->CreateDepartment();
	 sqlUsr->show(); departmentSql->show();
		
	serverFactory *factoryAccess= new AccessFactory();
	 Usr *AccessUsr=factoryAccess->CreateUsr();
	 Department *departmentAccess=factoryAccess->CreateDepartment();
	 AccessUsr->show(); departmentAccess->show();

	delete factorySql;delete sqlUsr;delete departmentSql;
	delete factoryAccess;delete AccessUsr;delete departmentAccess;
	return 0;
}