简单工厂、工厂方法和抽象工厂的区别

1、简单工厂模式

定义一个工厂类，它可以根据参数的不同返回不同类的实例，被创建的实例通常都具有共同父类。因为在简单工厂模式中用于创建实例的方法是静态方法，所以简单工厂模式也可以称为静态工厂方法模式，是一种类创建型模式。

在简单工厂模式中，工厂类只生产一类产品，所有具体的产品的创建都集中于工厂类中，根据所传入参数的不同可以创建不同的产品对象。

简单工厂模式中的角色：

工厂角色：实现创建所有产品实例的内部逻辑；

抽象产品角色：工厂类所创建的所有对象的父类，封装了各种产品对象的公有方法；

具体产品角色：每一个具体角色都继承了抽象产品的角色，需要实现抽象产品中声明的抽象方法。

2、工厂方法模式

定义一个用于创建对象的接口，让子类决定将哪一个类实例化，它让一个类的实例化延迟到子类。它提供一个抽象工厂接口来声明抽象工厂方法，而由其子类来具体实现工厂方法，创建具体的产品对象。它是基于工厂角色和产品角色的多态性而设计的。在系统中添加新产品时，无须修改抽象工厂类，只需添加一个新工厂类和新产品类就可以了。即工厂类可以生产多类产品。相应的产品由相对应的工厂来生产。

工厂方法模式中角色：

抽象产品：定义产品的接口，是产品对象的公共父类；

具体产品：实现了抽象产品接口，某种具体的产品由专门的具体工厂创建，即具体产品与具体工厂一一对应；

抽象工厂：声明了工厂方法，用于返回一个产品。所有创建对象的工厂类都必须实现该接口。

具体工厂：是抽象工厂的子类，实现了抽象工厂中定义的工厂方法，返回的是一个具体产品类的实例。

3、抽象工厂模式

提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。在它的抽象工厂类中，它声明了可以生产一族产品的方法，而每一个方法又对应一种产品。

抽象工厂模式中的角色：

抽象工厂：声明一组用于创建产品的方法，每一个方法对应一种产品；

具体工厂：实现在抽象工厂中声明的创建产品的方法，生成一组具体产品，这些产品构成了一个产品族；

抽象产品：为每种产品声明接口，在抽象产品中声明了产品所具有的业务方法；

具体产品：具体工厂生产的具体产品对象，实现抽象产品接口中声明的业务方法。

三种的比较，例如

要创建几种不同的图形，即圆形、方形、三角形，可以使用简单工厂模式；

如果要创建很多种不同的图形，即圆形、方形、三角形、五角形等等，使用工厂方法模式；

如果要创建各种不同颜色不同形状的图形，这时就该使用抽象工厂模式了，可以把这几种的图形的共性抽象出来。

具体例子：

简单工厂：

class SingleCore//处理器，抽象产品
{
	
public:

	SingleCore()
	{
		cout<<" Constructed SingleCore "<<endl;
	}

   virtual  ~SingleCore()//必须定义为虚析构函数
	{
		cout<<" Destructed SingleCore "<<endl;
	}

	virtual void show() = 0;//纯虚拟函数
};

class SingleCoreA : public SingleCore//A处理器，具体产品一
{

public:

	SingleCoreA()
	{
		cout<<" Constructed SingleCore A "<<endl;
	}
	
	//由于创建的实例类型为SingleCore类型，故不调用SingleCoreB类的析构函数
	~SingleCoreA()
	{
		cout<<" Destructed SingleCore A "<<endl;
	}

	void show()
	{
		cout<<" SingleCore A "<<endl;
	}
};

class SingleCoreB : public SingleCore//B处理器，具体产品二
{

public:

	SingleCoreB()
	{
		cout<<" Constructed SingleCore B "<<endl;
	}
	
	//由于创建的实例类型为SingleCore类型，故不调用SingleCoreB类的析构函数
	~SingleCoreB()
	{
		cout<<" Destructed SingleCore B "<<endl;
	}

	void show()
	{
		cout<<" SingleCore B "<<endl;
	}
};

class Factory//重点工厂方法类
{

public:

	Factory()
	{
		cout<<" Constructed Factory "<<endl;
	}
	
	~Factory()
	{
		cout<<" Destructed Factory "<<endl;
	}


	//根据类型判断产生哪一个类的实例
   SingleCore *CreateSingleCore(int type)
   {

		switch(type)
		{
		case 1:
			return new SingleCoreA();//创建的实例类型为SingleCore
			break;

		case 2:
			return new SingleCoreB();//创建的实例类型为SingleCore
			break;

		default:
			cout<<"No type of the core"<<endl;
			
		}
	}

#include <iostream>

using namespace std;

#include "Simple Factory.h"

int main()
{
	int type;

	cout<<"Input a type of SingleCore: ";
	cin>>type;

	if(type == 1 || type == 2)
	{
		Factory *factory = new Factory();
		SingleCore *singlecore = factory->CreateSingleCore(type);
		singlecore->show();

		delete singlecore;
		delete factory;
	}
	else
		cout<<"no creating object"<<endl;

	cout<<endl;

	return 0;

}

工厂方法：

#ifndef COREFACTORY_H
#define COREFACTORY_H

#include <iostream>

using namespace std;

#include "SingleCore.h"

#include "MultiCore.h"

class CoreFactory //生产处理器的工厂，抽象工厂
{
	
public:
	
	CoreFactory()
	{
		cout<<" Construted CoreFactory "<<endl;
	}
	
	virtual ~CoreFactory()
	{
		cout<<" Destructed CoreFactory "<<endl;
	}

	//创建单核处理的工厂
	virtual SingleCore* CreateSingleCore() = 0;

	//创建多核处理的工厂
	virtual MultiCore* CreateMultiCore() = 0;
	
};


class CoreFactoryA : public CoreFactory //具体工厂一
{
	
public:
	
	CoreFactoryA()
	{
		cout<<" Construted CoreFactory A "<<endl;
	}
	
	~CoreFactoryA()
	{
		cout<<" Destructed CoreFactory A "<<endl;
	}
	
	SingleCore* CreateSingleCore()
	{
		return new SingleCoreA();//产生单核A
	}

};


class CoreFactoryB : public CoreFactory  //具体工厂二
{
	
public:
	
	CoreFactoryB()
	{
		cout<<" Construted CoreFactory B "<<endl;
	}
	
	~CoreFactoryB()
	{
		cout<<" Destructed CoreFactory B "<<endl;
	}
	
	SingleCore* CreateSingleCore()
	{
		return new SingleCoreB();//产生单核A
	}
	
};

#endif

#ifndef SINGLECORE_H
#define SINGLECORE_H

#include <iostream>

using namespace std;


class SingleCore//单核处理器，抽象产品
{

public:
	
	SingleCore()
	{
		cout<<" Construted SingleCore "<<endl;
	}

	virtual ~SingleCore()
	{
		cout<<" Destructed SingleCore "<<endl;
	}

	virtual void show() = 0;
};


class SingleCoreA : public SingleCore  //具体产品
{

public:

	SingleCoreA()
	{
		cout<<" Construted SingleCore A "<<endl;
	}

	 ~SingleCoreA()
	 {
		 cout<<" Destructed SingleCore A "<<endl;
	 }

	 void show()
	 {
		 cout<<" Single Core A "<<endl;
	 }
};


class SingleCoreB : public SingleCore  //具体产品
{
	
public:
	
	SingleCoreB()
	{
		cout<<" Construted SingleCore B "<<endl;
	}
	
	~SingleCoreB()
	{
		cout<<" Destructed SingleCore B "<<endl;
	}
	
	void show()
	{
		cout<<" Single Core B "<<endl;
	}
};

#endif

#include <iostream>

using namespace std;

#include "CoreFactory.h"

int main()
{
	int type;
	cout<<" Input type of the product: ";
	cin>>type;

	switch( type )
	{
	case 1:
		{
			CoreFactory * FactoryA1 = new CoreFactoryA();//创建A型工厂
			SingleCore * Singlecore1 = FactoryA1->CreateSingleCore();//生产A型单核处理器
			
			cout<<endl;		
			
			delete Singlecore1;
			delete FactoryA1;
			
			break;
		}
	

	case 2:
		{
			CoreFactory * FactoryB1 = new CoreFactoryB();//创建B型工厂
			SingleCore * Singlecore2 = FactoryB1->CreateSingleCore();//生产B型单核处理器		
			
			cout<<endl;		
			
			delete Singlecore2;
			delete FactoryB1;
			
			break;
		}

	default:

		cout<<" No this type of product "<<endl;

	}

	cout<<endl;

	return 0;
}

抽象工厂：

#ifndef ABSTRACT FACTORY_H
#define ABSTRACT FACTORY_H

#include <iostream>

using namespace std;

#include "IDepartment.h"
#include "IUser.h"

class Factory//抽象工厂
//包括Access工厂和Department工厂
{

public:

	Factory()
	{
		cout<<" Constructed Factory "<<endl;
	}

	virtual ~Factory()
	{
		cout<<" Destruvted Factory "<<endl;
	}

	virtual IUser* CreateUser() = 0;

	virtual IDepartment* CreateDepartment() = 0;
	
};

class AccessFactory : public Factory//Access工厂，具体工厂一
{

public:
	
	AccessFactory()
	{
		cout<<" Constructed AccessFactory "<<endl;
	}

	virtual ~AccessFactory()
	{
		cout<<" Destructed AccessFactory "<<endl;
	}

	virtual IUser* CreateUser()
	{
		return new AccessUser();//创建Access用户
	}

	virtual IDepartment* CreateDepartment()
	{
		return new AccessDepartment();//创建Access部门
	}
};


class SqlFactory : public Factory//Sql工厂，具体工厂二
{
	
public:
	
	SqlFactory()
	{
		cout<<" Constructed SqlFactory "<<endl;
	}
	
	virtual ~SqlFactory()
	{
		cout<<" Destructed SqlFactory "<<endl;
	}
	
	virtual IUser* CreateUser()
	{
		return new SqlUser();//创建Sql用户
	}
	
	virtual IDepartment* CreateDepartment()
	{
		return new SqlDepartment();//创建Sql部门
	}
};


#endif

#ifndef IDEPARTMENT_H
#define IDEPARTMENT_H

#include <iostream>

using namespace std;

class IDepartment//部门抽象接口，抽象产品一
//部门包括Access部门和Sql部门
{

public:

	IDepartment()
	{
		cout<<" Constructed IDepartment "<<endl;
	}

    virtual ~IDepartment()
	{
		cout<<" Destructed IDepartment "<<endl;
	}

	virtual void GetDepartment() = 0;

	virtual void InsertDepartment() = 0;

};


class AccessDepartment : public IDepartment//Access部门
{

public:

	AccessDepartment()
	{
		cout<<" Constructed AccessDepartment "<<endl;
	}

	virtual ~AccessDepartment()
	{
		cout<<" Destructed AccessDepartment "<<endl;
	}

	virtual void GetDepartment()
	{
		cout<<" Access GetDepartment "<<endl;
	}

	virtual void InsertDepartment()
	{
		cout<<" Access InsertDepartment "<<endl;
	}
	
};


class SqlDepartment : public IDepartment//Sql部门
{
	
public:
	
	SqlDepartment()
	{
		cout<<" Constructed SqlDepartment "<<endl;
	}
	
	virtual ~SqlDepartment()
	{
		cout<<" Destructed SqlDepartment "<<endl;
	}
	
	virtual void GetDepartment()
	{
		cout<<" Sql GetDepartment "<<endl;
	}
	
	virtual void InsertDepartment()
	{
		cout<<" Sql InsertDepartment "<<endl;
	}
	
};


#endif

#ifndef IUSER_H
#define IUSER_H

#include <iostream>

using namespace std;

class IUser//用户抽象接口,用于产生不同的用户，抽象产品二
//它包括Access用户和Sql用户
{

public:

	IUser()
	{
		cout<<" Constructed IUser "<<endl;
	}

	virtual ~IUser()
	{
		cout<<" Destructed IUser "<<endl;
	}

	virtual void GetUser() = 0;//纯虚拟函数

	virtual void InsertUser() = 0;

};

class AccessUser : public IUser//Access用户
{

public:

	AccessUser()
	{
		cout<<" Constructed AccessUser "<<endl;
	}

	virtual ~AccessUser()
	{
		cout<<" Destructed AccessUser "<<endl;
	}

	virtual void GetUser()
	{
		cout<<" Access GetUser "<<endl;
	}

	virtual void InsertUser()
	{
		cout<<" Access InsertUser "<<endl;
	}

};

class SqlUser : public IUser//SQL用户
{

public:

	SqlUser()
	{
		cout<<" Constructed SqlUser "<<endl;
	}

	virtual ~SqlUser()
	{
		cout<<" Destructed SqlUser "<<endl;
	}

	virtual void GetUser()
	{
        cout<<" Sql GetUser "<<endl;
	}

	virtual void InsertUser()
	{
		cout<<" Sql InsertUser "<<endl;
	}
};

#endif

#include "Abstract Factory.h"

int main()
{
	Factory* factory = new SqlFactory();//新建一个Sql工厂
	IUser* user = factory->CreateUser();//创建Sql用户
	IDepartment* depart = factory->CreateDepartment();//创建Sql部门

	cout<<endl;

	user->GetUser();
	depart->GetDepartment();

	cout<<endl;

	delete depart;
	cout<<endl;

	delete user;
	cout<<endl;

	delete factory;
	cout<<endl;

	return 0;
}