最近正好有時間回顧了下工廠模式，一般包含有如下三種工廠模式：
- 簡單工廠模式
- 工廠方法模式
- 抽象工廠模式
1、簡單工廠模式：
1.1、模式定義：
簡單工廠模式又稱為靜态工程方法模式，它屬于類建立模式。在簡單工廠中，專門定義一個工廠類用來建立其他類的執行個體，并且可以根據不同的參數來擷取不同的類執行個體。
簡單工廠模式并不算是一種設計模式，不在23種模式之列，簡單工程更多的是一種程式設計習慣。
1.2、适用場景：
- 需要建立的對象較少。
- 用戶端不關心對象的建立過程。
1.3、模式結構：
簡單工廠模式包含如下角色：
- 工廠角色
- 抽象産品角色
- 具體産品角色
簡單工程類圖如下所示：
1.4、模式執行個體：
抽象産品類---Car：
public interface Car {
/**
* 駕駛
*/
void drive();
}
具體産品類1---BMWCarX5：
public class BMWCarX5 implements Car {
@Override
public void drive() {
System.out.println("寶馬X5--啟動啦！！！");
}
}
具體産品類2---BMWCarX7：
public class BMWCarX7 implements Car {
@Override
public void drive() {
System.out.println("寶馬X7--啟動啦！！！");
}
}
工廠類---CarFactory:
public class CarFactory {
public static Car createCar(int carType) {
Car car = null;
switch (carType) {
case CarTypeDef.CAR_TYPE_BMW_X5:
//寶馬X5系列
car = new BMWCarX5();
break;
case CarTypeDef.CAR_TYPE_BMW_X7:
//寶馬X7系列
car = new BMWCarX7();
break;
default:
break;
}
return car;
}
}
測試及輸出結果：
public static void main(String[] args) {
/**
* 測試簡單工廠
*/
Car carBMW = CarFactory.createCar(CarTypeDef.CAR_TYPE_BMW_X5);
carBMW.drive();
Car carBenz = CarFactory.createCar(CarTypeDef.CAR_TYPE_BMW_X7);
carBenz.drive();
}
如上即是簡單工廠模式的實際應用，可以看出簡單工廠模式通過一個具體的工廠類，根據不同的産品參數建立不同的具體産品執行個體。用戶端可以免除直接建立産品對象的責任，而僅僅“消費”産品。這種模式用于建立同一類型的産品來說，還是比較友善和靈活的。但是這種方式也有其缺點，比如每一次建立一個新的産品，就需要修改工廠類，違背了"開閉原則"(對擴充開放，對修改關閉)。并且在建立其他非Car産品時就顯得無能為力了。
2、工廠方法模式：
2.1、模式定義：
工廠方法模式又稱為工廠模式，或者多态工廠模式，它屬于類建立型模式。在工廠方法模式中，工廠父類負責定義建立産品對象的公共接口，而工廠子類則負責生成具體的産品對象。這樣做的目的是将産品類的執行個體化操作延遲到工廠子類中完成，即通過工廠子類來确定究竟應該執行個體化哪一個具體産品類。
2.2、适用場景：
- 用戶端不需要知道它所建立的對象的類。
- 用戶端可以通過子類來指定建立對應的對象。
2.3、模式結構：
工廠模式包含如下角色：
- 抽象産品角色
- 具體産品角色
- 抽象工廠角色
- 具體工廠角色
2.4、模式執行個體：
抽象産品類---Car：
public interface Car {
/**
* 駕駛
*/
void drive();
}
具體産品類1---BMWCar:
public class BMWCar implements Car {
public BMWCar(){
System.out.println("BMWCar--生産啦");
}
@Override
public void drive() {
System.out.println("BMWCar--啟動啦");
}
}
具體産品類2---BenzCar:
public class BenzCar implements Car {
public BenzCar() {
System.out.println("BenzCar--生産啦");
}
@Override
public void drive() {
System.out.println("BenzCar--啟動啦");
}
}
抽象工廠類---ICarFactory：
public interface ICarFactory {
Car createCar();
}
具體工廠類1---BMWCarFactory
public class BMWCarFactory implements ICarFactory {
@Override
public BMWCar createCar() {
System.out.println("begin--create--BMWCar");
return new BMWCar();
}
}
具體工廠類2---BenzCarFactory
public class BenzCarFactory implements ICarFactory {
@Override
public BenzCar createCar() {
System.out.println("begin--create--BenzCar");
return new BenzCar();
}
}
測試及輸出結果：
public static void main(String[] args) {
/**
* 測試工廠模式
*/
BMWCarFactory bmwCarFactory = new BMWCarFactory();
bmwCarFactory.createCar().drive();
BenzCarFactory benzCarFactory = new BenzCarFactory();
benzCarFactory.createCar().drive();
}
如上即是工廠方法模式的執行個體，可以看到工廠方法模式對于簡單工廠模式來說并沒有違背“開閉原則”（對修改關閉，對擴充開放）。另外，工廠方法模式中的具體工廠也可以通過反射來生産不同廠家的産品，這樣具體的工廠執行個體隻建立一個就可以了。
而當系統所提供的工廠所需生産的具體産品并不是一個簡單的對象，而是多個位于不同産品等級結構中屬于不同類型的具體産品時工廠方法的弊端就顯露出來了，此時便需要使用抽象工廠模式。
3、抽象工廠模式：
3.1、模式定義：
抽象工廠模式提供一個建立一系列相關或互相依賴對象的接口，而無須指定它們具體的類。抽象工廠模式屬于對象建立型模式。抽象工廠模式是工廠方法的僅一步深化，在這個模式中的工廠類不單單可以建立一個對象，而是可以建立一組對象，這是和工廠方法最大的不同點。
3.2、适用場景：
- 和工廠方法一樣用戶端不需要知道它所建立的對象的類。
- 需要一組對象共同完成某種功能時。并且可能存在多組對象完成不同功能的情況。
- 系統結構穩定，不會頻繁的增加對象。（因為一旦增加就需要修改原有代碼，不符合開閉原則）。
3.3、模式結構：
抽象工廠模式包含如下角色：
- 抽象産品角色
- 具體産品角色
- 抽象工廠角色
- 具體工廠角色
抽象工程類圖如下：
3.4、模式執行個體：
抽象産品類A---Engine：
public interface Engine {
/**
* 發動機轉動
*/
void rotate();
}
具體産品類A1---BMWEngine:
public class BMWEngine implements Engine {
public BMWEngine(){
System.out.println("BMWEngine--生産啦");
}
@Override
public void rotate() {
System.out.println("BMWEngine--rotate");
}
}
具體産品類A2---BenzEngine:
public class BenzEngine implements Engine {
public BenzEngine(){
System.out.println("BenzEngine--生成啦");
}
@Override
public void rotate() {
System.out.println("BenzEngine--rotate");
}
}
抽象産品類B---AirConditioner：
public interface AirConditioner {
/**
* 空調吹風
*/
void blow();
}
具體産品類B1---BMWAirConditioner:
public class BMWAirConditioner implements AirConditioner {
public BMWAirConditioner(){
System.out.println("BMWAirConditioner--生産啦");
}
@Override
public void blow() {
System.out.println("BMWAirConditioner--blow");
}
}
具體産品類B2---BenzAirConditioner:
public class BenzAirConditioner implements AirConditioner {
public BenzAirConditioner() {
System.out.println("BenzAirConditioner--生産啦");
}
@Override
public void blow() {
System.out.println("BenzAirConditioner--blow");
}
}
抽象工廠類---ICarFactory：
public interface ICarFactory {
/**
* 制造發動機
* @return
*/
Engine createEngine();
/**
* 制造空調
* @return
*/
AirConditioner createAirConditioner();
}
具體工廠類---BMWCarFactory：
public class BMWCarFactory implements ICarFactory {
@Override
public Engine createEngine() {
return new BMWEngine();
}
@Override
public AirConditioner createAirConditioner() {
return new BMWAirConditioner();
}
}
具體工廠類---BenzCarFactory：
public class BenzCarFactory implements ICarFactory {
@Override
public Engine createEngine() {
return new BenzEngine();
}
@Override
public AirConditioner createAirConditioner() {
return new BenzAirConditioner();
}
}
測試及輸出結果：
public static void main(String[] args) {
/**
* 測試抽象工廠模式
*/
ICarFactory bmwCarFactory = new BMWCarFactory();
bmwCarFactory.createEngine().rotate();
bmwCarFactory.createAirConditioner().blow();
ICarFactory benzCarFactory = new BenzCarFactory();
benzCarFactory.createEngine().rotate();
benzCarFactory.createAirConditioner().blow();
}
最後根據工廠模式的退化說明，來對這三種工廠模式做一個簡單精辟的總結：
當抽象工廠模式中每一個具體的工程類隻建立一個産品對象，也就是隻存在一個産品等級結構時，抽象工廠模式退化成工廠方法模式；當工廠方法模式中，抽象工程與具體工廠合并，提供一個統一的工廠對象來建立産品，并将建立對象的工廠方法設計為靜态方法時，工廠方法模式退化成簡單工廠模式。
檢視其它Java設計模式
參考：
工廠模式——看這一篇就夠了
建立型模式
JAVA設計模式之工廠模式(簡單工廠模式+工廠方法模式)