工廠模式（簡單工廠，工廠方法，抽象工廠）

一：簡單工廠

1：簡單工廠模式的定義：

把實例化的操作單獨放到一個類中，這個類就成爲簡單工廠類，讓簡單工廠類來決定應該用哪個具體子類來實例化。這樣做能把客戶類和具體子類的實現解耦，客戶類不再需要知道有哪些子類以及應當實例化哪個子類

2：簡單工廠模式的特點：

違背開閉原則，不屬於設計模式的一種。

3：簡單工廠模式的實現：

Product：抽象產品類，將具體產品類公共的代碼進行抽象和提取後封裝在一個抽象產品類中。
ConcreteProduct：具體產品類，將需要創建的各種不同產品對象的相關代碼封裝到具體產品類中。
Factory：工廠類，提供一個工廠類用於創建各種產品，在工廠類中提供一個創建產品的工廠方法，該方法可以根據所傳入參數的不同創建不同的具體產品對象。
Client：客戶端類，只需調用工廠類的工廠方法並傳入相應的參數即可得到一個產品對象。
abstract class product {
	abstract void productState();
}
class product1 extends product {
	@Override
	void productState() {
		System.out.println("簡單工廠的product111");
	}
}
class product2 extends product {
	@Override
	void productState() {
		System.out.println("簡單工廠的product222");
	}
}
class productFactory {
	public static product createProduct(int num) {
		switch (num) {
		case 1:return new product1();
		case 2:return new product2();
		default:break;
		}
		return null;
	}
}
public class SimpleFactory {
	public static void main(String[] args) {
		product p1 = productFactory.createProduct(1);
		product p2 = productFactory.createProduct(2);
		p1.productState();
		p2.productState();
	}
}

二：工廠方法

1：工廠方法模式的定義：

定義一個用於創建對象的接口，讓子類決定實例化哪一個類。工廠方法使得一個類的實例化延遲到子類中。將類的實例化（具體產品的創建）延遲到工廠類的子類（具體工廠）中完成，即由子類來決定應該實例化（創建）哪一個類。主要解決了簡單工廠模式的缺點（工廠一旦需要生產新產品就需要修改工廠類的方法邏輯，違背了“開放 - 關閉原則）。

2：工廠方法模式的特點：

定義了一個創建對象的接口，但由子類決定要實例化哪個類。工廠方法把實例化操作推遲到子類。主要是通過反射的方式創建。在簡單工廠中，創建對象的是另一個類，而在工廠方法中，是由子類來創建對象。

3：工廠方法模式的實現：

product：抽象產品，具體產品的父類，描述具體產品的公共接口
concrete product：具體產品，抽象產品的子類，工廠類創建的目標類，描述生產的具體產品
Factory：抽象工廠，具體工廠的父類，描述具體工廠的公共接口
concrete Factory：具體工廠，抽象工廠的子類，被外界調用，描述具體工廠，創建產品的實例
public abstract class Product{
		public void method1{
Syso(“產品的公共業務邏輯處理”);		
	}
		public abstract void method2();
}
public class ConcreteProduct extends Product{
	public void method2(){
Syso(“自定義邏輯處理”);
}
}
public abstract class Factory{
	public abstract <T extends Product> T createProduct(Class<T> c);
}
public class ConcreteFactory extends Product{
	public <T extends Product> T createProduct(Class<T> c){
Product product=null;
try{
product=(Product)Class.forname(c.getName()).newInstance();
}catch(Exception e){
}
return (T)product;
}
}
public class Test{
		public static void main(String[] args) {
Factory factory=new ConcreteFactory();
Product product=factory.createProduct(ConcreteProduct.class)
}
}

三：抽象工廠

1、抽象工廠模式定義：

爲創建一組相關或者相互依賴的對象提供一個接口，並且無需指定他們的具體類

2、抽象工廠模式特點：

提供一個接口，用於創建 相關的對象家族 。抽象工廠模式創建的是對象家族，也就是很多對象而不是一個對象，並且這些對象是相關的，也就是說必須一起創建出來。而工廠方法模式只是用於創建一個對象，這和抽象工廠模式有很大不同。

3、抽象工廠模式的實現：

抽象工廠：interface ComputerFactory {
	keyboard createKeyBoard();
	mouse createMouse();
}
對象家族1：interface keyboard {
	void keyboardState();
}
對象家族2：interface mouse {
	void mouseState();
}:
class AKeyboard implements keyboard {
	@Override
	public void keyboardState() {
		System.out.println("抽象工廠Akeyboard");
	}
}
class Bkeyboard implements keyboard {
	@Override
	public void keyboardState() {
		System.out.println("抽象工廠Bkeyboard");
	}
}
class Amouse implements mouse {
	@Override
	public void mouseState() {
		System.out.println("抽象工廠Amouse");
	}
}
class Bmouse implements mouse {
	@Override
	public void mouseState() {
		System.out.println("抽象工廠Bmouse");
	}
}
對象家族1工廠：家族中每一個對象的創建和工廠方法一樣
class AComputerFactory implements ComputerFactory {
	@Override
	public keyboard createKeyBoard() {
		return new AKeyboard();
	}
	@Override
	public mouse createMouse() {
		return new Amouse();
	}
}
對象家族2工廠：家族中每一個對象的創建和工廠方法一樣
class BComputerFactory implements ComputerFactory {
	@Override
	public keyboard createKeyBoard() {
		return new Bkeyboard();
	}
	@Override
	public mouse createMouse() {
		return new Bmouse();}}
public class AbstractFactory {
	public static void main(String[] args) {
		ComputerFactory cfa = new AComputerFactory();
		ComputerFactory cfb = new BComputerFactory();
		cfa.createKeyBoard().keyboardState();
		cfa.createMouse().mouseState();
		cfb.createKeyBoard().keyboardState();
		cfb.createMouse().mouseState();
	}
}