簡單工廠、工廠方法和抽象工廠的區別

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;
}