簡單工廠、抽象工廠、工廠——創建型設計模式

簡單工廠

瞭解
在創建一個對象時不向客戶暴露內部細節，並提供一個創建對象的通用接口

相當於一個工廠有多種產品，創建在類中，當客戶使用時只需要知道產品類對應參數即可

原理
簡單工廠把實例化的操作單獨放到一個類中，這個類就成爲簡單工廠類，讓簡單工廠類來決定用哪個具體子類來實例化

這樣做能把客戶類和具體子類的實現解耦合，客戶類不再需要知道有哪些子類以及應當實例化哪個子類。客戶類往往有多個，如果不使用簡單工廠，那麼所有的客戶類都要知道所有子類的細節。而且一旦子類發生改變，例如增加子類，那麼所有的客戶類都要進行修改

---

實現

class Product{};
class ConcreteProduct:public Product{};
class ConcreteProduct1:public Product{};
class ConcreteProduct2:public Product{};

//簡單工廠，被所有需要進行實例化的客戶類調用
class SimpleFactory 
{ 
public:
	Product createProduct(int type) 
	{
	if(type == 1) 
		{ return new ConcreteProduct1(); } 
	else if (type == 2) 
		{ return new ConcreteProduct2(); }
	return new ConcreteProduct(); 
	} 
};

class Client 
{
public:
static void main(String[] args) 
	{ 
		SimpleFactory simpleFactory = new SimpleFactory(); 
		Product product = simpleFactory.createProduct(1);
	 	//do something with the product 
	 } 
};

工廠方法

瞭解
在簡單工廠中，創建對象的是另一個類；而在工廠方法中，是由子類來創建對象

定義了一個創建對象的接口，但由子類決定要實例化哪個類。工廠方法把實例化操作推遲到子類
原理
Factory有一個doSomething() 方法，這個方法需要用到一個產品對象，這個產品對象由factoryMethod()方法創建【該方法是抽象的，需要由子類去實現】

實現

class Factory 
{ 
public:
	virtual Product factoryMethod(); 
	void doSomething() 
	{ 
		Product product = factoryMethod(); 
		// do something with the product 
	} 
};
class ConcreteFactory:public Factory 
{ 
public:
	Product factoryMethod() 
	{ 
		return new ConcreteProduct(); 
	} 
};
class ConcreteFactory1:public Factory 
{ 
public: 
	Product factoryMethod() 
	{ 
		return new ConcreteProduct1(); 
	} 
};
class ConcreteFactory2:public Factory 
{
public: 
	Product factoryMethod() 
	{ 
		return new ConcreteProduct2(); 
	} 
};

抽象工廠

瞭解
提供一個接口，用於創建相關的對象家族

抽象工廠模式創建的是對象家族，也就是很多對象而不是一個對象，並且這些對象是相關的，也就是說必須一起創建

工廠方法模式只是用於創建一個對象，這和抽象工廠模式有很大不同

原理
抽象工廠模式用到了工廠方法模式來創建單一對象，AbstractFactory中的createProductA()和createProductB()方法都是讓子類來實現，這兩個方法單獨來看就是在創建一個對象，這符合工廠方法模式的定義

創建對象家族這一概念在Client 體現，Client 要通過AbstractFactory同時調用兩個方法來創建出兩個對象，在這裏這兩個對象就有很大的相關性，Client需要同時創建出這兩個對象，從高層次來看，抽象工廠使用了組合，即Cilent組合了AbstractFactory，而工廠方法模式使用了繼承

繼承表現爲：is-a是一個
組合表現爲：has-a有一個【不會破壞程序封裝性，維護起來更加簡單】

class AbstractProductA { };
class AbstractProductB { };
class ProductA1:AbstractProductA { };
class ProductA2:AbstractProductA { };
class ProductB1:AbstractProductB { };
class ProductB2:AbstractProductB { };
class AbstractFactory 
{ 
	virtual AbstractProductA createProductA(); 
	virtual AbstractProductB createProductB(); 
};
class ConcreteFactory1:public AbstractFactory 
{ 
	AbstractProductA createProductA() 
	{ 
		return new ProductA1(); 
	}
	AbstractProductB createProductB() 
	{ 
		return new ProductB1(); 
	} 
};
class ConcreteFactory2:public AbstractFactory 
{ 
	AbstractProductA createProductA() 
		{ return new ProductA2();}
	AbstractProductB createProductB() 
		{ return new ProductB2();} 
};
class Client 
{ 
public: 
	static void main(String[] args) 
	{ 
		AbstractFactory abstractFactory = new ConcreteFactory1();
		AbstractProductA productA = abstractFactory.createProductA();
		AbstractProductB productB = abstractFactory.createProductB();
		 // do something with productA and productB 
	} 
};