Java設計模式之工廠模式_ZenDei技術網路在線

本文主要講的就是java中的工廠設計模式中的三種模式，加強自己對其的理解。 ...

本文總結一下java的GOF（Gang Of Four）23種設計模式中的工廠模式。

工廠模式：

作用：實現了創建者和調用者的分離；

核心本質：實例化對象，用工廠方法代替new操作，將選擇實現類創建對象統一管理和控制，從而將調用者跟我們的實現類解耦。

工廠設計的基本原則：

1、OCP（Open_Closed Principle）：開閉原則，一個軟體的實體類應當對擴展開放，對修改關閉；

2、DIP（Dependence Inversion Principle）：依賴倒轉原則，要針對介面編程，不要針對實現編程；

3、LOD（Law Of Demeter）：迪米特法則，只與你直接的朋友通信，避免和陌生人通信。

分類：

1、簡單工廠模式（Simple Factory）

2、工廠方法模式（Factory Method）

3、抽象工廠模式（Abstract Factory）

一簡單工廠模式

　　用來生產同一等級結構中的任意產品。（對於增加新的產品，需要修改已有的代碼）

　　例：

手機介面

1 public interface Phone {
2     void create();
3 }

實現手機介面的類（假設分別為華為手機和小米手機）

1 public class HuaWei implements Phone{
2     @Override
3     public void create() {
4         System.out.println("這是華為手機");
5     }
6 }

1 public class Mi implements Phone{
2     @Override
3     public void create() {
4         System.out.println("這是小米手機");
5     }
6 }

創建簡單工廠類（實例化HuaWei類和Mi類）。這裡可以使用兩種方法，如下：

第一種

 1 public class SimpleFactory {
 2 
 3     public static Phone createHuaWei(){
 4         return new HuaWei();
 5     }
 6 
 7     public static Phone createMi(){
 8         return new Mi();
 9     }
10 }

第二種

 1 public class SimpleFactory1 {
 2 
 3     public static Phone createPhone(String type){
 4         if (type.equals("華為")){
 5             return new HuaWei();
 6         }else if (type.equals("小米")){
 7             return new Mi();
 8         }else{
 9             return null;    //防止空指針
10         }
11     }
12 }

測試類

 1 public class TestSimpleFactory {
 2     public static void main(String[] args) {
 3         //這是測試第一種的代碼
 4         Phone phone1 = SimpleFactory.createHuaWei();
 5         Phone phone2 = SimpleFactory.createMi();
 6 
 7         phone1.create();
 8         phone2.create();
 9         //這是測試第二種的代碼
10         Phone phone3 = SimpleFactory1.createPhone("華為");
11         Phone phone4 = SimpleFactory1.createPhone("小米");
12 
13         if (phone3 != null) {
14             phone3.create();
15         }
16         if (phone4 != null) {
17             phone4.create();
18         }
19     }
20 }

列印結構

這是華為手機
這是小米手機
這是華為手機
這是小米手機

　　簡單工廠模式也叫靜態工廠模式，就是因為工廠類一般使用靜態方法，通過接收的參數的不同來返回不同的對象實例。　　

　　假設你還要增加一個vivo手機的話，就需要增加一個實現手機介面的類以及在簡單工廠類中添加一個方法或者添加一個判定條件（else if(type.equals("vivo")）即可。如果不能修改代碼的話，這種工廠模式就不能擴展，所以為了更好的增加產品，就可以使用工廠方法模式。

二工廠方法模式

　　用來生產同一等級結構中的固定產品。（支持增加任意產品）

電腦介面

1 public interface Computer {
2     void create();
3 }

實現電腦介面的類（假設有聯想電腦和華碩電腦）

1 public class LianXiang implements Computer {
2     @Override
3     public void create() {
4         System.out.println("這是聯想電腦");
5     }
6 }

1 public class HuaShuo implements Computer {
2     @Override
3     public void create() {
4         System.out.println("這是華碩電腦");
5     }
6 }

先創建一個工廠介面，再為每類電腦都創建一個工廠類實現這個工廠介面

1 public interface FactoryMethod {　　
2     Computer factory();
3 }

1 //實現工廠介面的聯想工廠類
2 public class LianXiangFactory implements FactoryMethod {
3     @Override
4     public Computer factory() {
5         return new LianXiang();
6     }
7 }

1 //實現工廠介面的華碩工廠類
2 public class HuaShuoFactory implements FactoryMethod {
3     @Override
4     public Computer factory() {
5         return new HuaShuo();
6     }
7 }

測試類

1 public class TestFactoryMethod {
2     public static void main(String[] args) {
3         Computer computer1 = new LianXiangFactory().factory();
4         Computer computer2 = new HuaShuoFactory().factory();
5 
6         computer1.create();
7         computer2.create();
8     }
9 }

測試結果

這是聯想電腦
這是華碩電腦

　　工廠方法模式和簡單工廠模式最大的不同在於簡單工廠模式只有一個工廠類，而工廠方法模式則是有多個實現了相同介面的工廠類（每個工廠類對應一個產品）。

　　這種模式下想要增加產品時，可以直接添加一個產品類和對應的產品工廠類（並實現工廠介面）。不需要更改其它代碼。

三抽象工廠模式

　　用來生產不同產品族的全部產品。（對於增加新的產品，無能為力；支持增加產品族）

　　這裡多了一個概念——產品族，假設一個產品為屏幕，一個產品為鍵盤，一個產品為滑鼠；那麼這個產品族我們就可以理解為電腦。所以我們接下來的例子可以這樣假設，如果屏幕，鍵盤，滑鼠都是內置的——筆記本電腦；而屏幕，鍵盤，滑鼠都市外置的——台式電腦。那麼代碼如下：

創建三個產品（一個產品介面和實現產品介面的其他類）

 1 //屏幕介面
 2 public interface Display {
 3     void view();
 4 }
 5 //內置屏幕
 6 class InnerDisplay implements Display{
 7     @Override
 8     public void view() {
 9         System.out.println("這是內置屏幕");
10     }
11 }
12 //外接屏幕
13 class OuterDisplay implements Display{
14     @Override
15     public void view() {
16         System.out.println("這是外接屏幕");
17     }
18 }

 1 //鍵盤介面
 2 public interface KeyBoard {
 3     void play();
 4 }
 5 //內置鍵盤
 6 class InnerKeyBoard implements KeyBoard{
 7     @Override
 8     public void play() {
 9         System.out.println("這是內置鍵盤");
10     }
11 }
12 //外接鍵盤
13 class OuterKeyBoard implements KeyBoard{
14     @Override
15     public void play() {
16         System.out.println("這是外置鍵盤");
17     }
18 }

 1 //滑鼠介面
 2 public interface Mouse {
 3     void check();
 4 }
 5 //內置滑鼠
 6 class InnerMouse implements Mouse{
 7     @Override
 8     public void check() {
 9         System.out.println("這是內置滑鼠");
10     }
11 }
12 //外接滑鼠
13 class OuterMouse implements Mouse{
14     @Override
15     public void check() {
16         System.out.println("這是外置滑鼠");
17     }
18 }

創建一個工廠介面

1 public interface AbstractFactory {
2     Display createDisplay();    //用於實例化Display類
3     KeyBoard createKeyBoard();  //用於實例化KeyBoard類
4     Mouse createMouse();        //用於實例化Morse類
5 }

創建一個工廠類實例化內置屏幕類，內置鍵盤類，內置滑鼠類，並實現工廠介面

 1 public class AbstractFactoryImpl01 implements AbstractFactory {
 2     //實例化內置屏幕
 3     @Override
 4     public Display createDisplay() {
 5         return new InnerDisplay();
 6     }
 7     //實例化內置鍵盤
 8     @Override
 9     public KeyBoard createKeyBoard() {
10         return new InnerKeyBoard();
11     }
12     //實例化內置滑鼠
13     @Override
14     public Mouse createMouse() {
15         return new InnerMouse();
16     }
17 }

再創建一個工廠類實例化外接屏幕類，外接鍵盤類，外接滑鼠類，並實現工廠介面

 1 public class AbstractFactoryImpl02 implements AbstractFactory {
 2     //實話外接屏幕
 3     @Override
 4     public Display createDisplay() {
 5         return new OuterDisplay();
 6     }
 7     //實例化外接鍵盤
 8     @Override
 9     public KeyBoard createKeyBoard() {
10         return new OuterKeyBoard();
11     }
12     //實例化外接滑鼠
13     @Override
14     public Mouse createMouse() {
15         return new OuterMouse();
16     }
17 }