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

工厂方法模式与简单工厂模式的区别在于：简单工厂模式用单一工厂来生产所有同种类的产品，而工厂模式是用对应的工厂来生产同一种类的不同产品。对于工厂方法模式而言，其简单模型的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;
}