工廠模式（Factory）

1、工廠模式介紹：

工廠模式實現了建立者和調用者的分離

工廠模式分類：

1.簡單工廠模式

2.工廠方法模式：定義一個用於建立對象的接口，讓子類決定實例化哪個類，工廠方法使一個類的實例化延遲到其子類

​3.抽象工廠模式：提供一個建立一系列相關或相互依賴對象的接口，而無需指定它們具體的類。

面向對象設計的基本原則：

OCP（開閉原則，Open-Closed Principle）：

        一個軟件的實體應當對擴展開放，對修改關閉。也就是說若是你要對一個已存在的系統作擴展的時候儘可能要新增長類，而不是在原有的基礎上修改。

DIP（依賴倒轉原則，Dependence Inversion Principle）

       針對接口編程，不要針對實現編程。

LoD（迪米特法則，Law Of Demeter）

       只與你直接的朋友通訊，而避免和陌生人通訊。一個類儘可能少的依賴其餘類

 

2、工廠模式代碼實現

未使用工廠模式的狀況

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

//汽車接口 public  interface  Car {      void  run(); } //奧迪 public  class  Audi  implements  Car {       @Override      public  void  run() {          System.out.println( "奧迪在跑" );      } } //比亞迪 public  class  Byd  implements  Car {      @Override      public  void  run() {          System.out.println( "比亞迪在跑。" );      } } //汽車測試類 public  class  TestCar { //調用者      public  static  void  main(String[] args) {          Car c1 =  new  Byd();          Car c2 =  new  Audi();              c1.run();          c2.run();          //未使用工廠模式的時候，調用者會依賴不少類。違反了開閉原則      } }

一、簡單工廠模式：雖然能經過工廠來建立對象，可是違反了開閉原則。一旦增長功能須要在原有基礎上修改代碼。

使用了簡單工廠模式後：能夠建立一個工廠類，該類中提供一個建立汽車的工廠（方法）

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

//汽車工廠 public class CarFactory {      /**       * 建立汽車       * @param type       * @return       */      public static Car createCar(String type){          //該方法還會有問題，假如之後有不少汽車都須要工廠來建立。則又得修改源代碼，違反了OCP開閉原則          if ( "audi" .equals(type)) {              return new Audi();          } else if ( "byd" .equals(type)) {              return new Byd();          } else {              return null ;          }      } } //測試簡單工廠方法 public class TestSimpleFactoryCar { //調用者      public static void main(String[] args) {          //建立汽車          Car audi = CarFactory.createCar( "audi" ); //建立者          Car byd = CarFactory.createCar( "byd" );          audi.run();          byd.run();      } }

二、工廠方法模式：將工廠類調整爲工廠接口，須要什麼類型的工廠就使用該類實現該工廠，建立相應的產品。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

//工廠接口 public interface CarFactory {      //建立汽車方法      Car createCar(); } //建立比亞迪汽車的工廠 public class BydFactory implements CarFactory{      @Override      public Car createCar() {          return new Byd();      } } //建立奧迪的工廠 public class AudiFactory implements CarFactory {      @Override      public Car createCar() {          return new Audi();      } }   //測試工廠方法 public class TestFactoryMethod {      public static void main(String[] args) {          /**           * 工廠方法模式好處在於，之後若是再增長一輛車。只需再實現CarFactory接口便可。避免了OCP開閉原則           * 不用在原來的代碼上修改，只需新增類便可。           * 例如:增長一輛奔馳，增長一個奔馳工廠BenzFactory便可。更好擴展           */          Car audi = new AudiFactory().createCar();          Car byd = new BydFactory().createCar();          audi.run();          byd.run();      } }

三、抽象工廠模式：抽象工廠模式用來生產不一樣產品族的所有產品，對於只增長產品某一部分則不適用。抽象工廠模式是工廠模式的一種升級版本。

在有多個業務品種，業務分類時，抽象工廠能產品不一樣類別的一個所有產品。例如：生產汽車，抽象工廠模式能夠生產高端汽車所有配件來組成一個高端汽車，

低端汽車所有配件來組成要給低端的汽車，可是不能產生一個高端的發動機和一個低端的座椅來組成一箇中等的汽車。這樣會混亂。

代碼實現：

首先使用一個接口來定義一個發動機，使用具體的類來定義發動機的好壞（具體實現）

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

/**   * 發動機接口   */ public interface Engine {      void run();      void start(); } //好的發動機 class LuxuryEngine implements Engine{      @Override      public void run() {          System.out.println( "好發動機轉的快" );      }      @Override      public void start() {          System.out.println( "啓動快，自動啓停" );      } } //差的發動機 class LowEngine implements Engine{      @Override      public void run() {          System.out.println( "轉的慢" );      }      @Override      public void start() {          System.out.println( "啓動慢" );      } }

定義一個汽車總工廠，用來生產各類類型的汽車。全部的汽車都須要依賴此工廠來生產汽車。

1 2 3 4 5 6 7 8

/**   *  汽車總工廠，能夠建立輪胎，座椅，發動機   */ public interface CarFactory {      Engine createEngine(); //建立發動機      Seat createSeat(); //建立座椅      Tyre createTyre(); //建立輪胎 }

而後根據生產的不一樣產品，類建立具體的實現來生產汽車。例如：專門生產高端的汽車，專門生產低端的汽車。均可以用針對CarFactory具體的實現來建立。

高端汽車製造工廠，全部汽車的生產必須依賴汽車總工廠

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

/**   *  高端汽車製造工廠   */ public class LuxuryCarFactory implements CarFactory{      @Override      public Engine createEngine() {          return new LuxuryEngine();      }      @Override      public Seat createSeat() {          return new LuxurySeat();      }      @Override      public Tyre createTyre() {          return new LuxuryTyre();      } }

低端汽車製造工廠，全部汽車的生產必須依賴汽車總工廠

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

/**   *  低端汽車製造工廠   */ public class LowCarFactory implements CarFactory{      @Override      public Engine createEngine() {          return new LowEngine();      }      @Override      public Seat createSeat() {          return new LowSeat();      }      @Override      public Tyre createTyre() {          return new LowTyre();      } }

具體生產汽車的時候就能夠根據須要來建立具體的汽車了。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

public static void main(String[] args) {      //想要好車      CarFactory factory = new LuxuryCarFactory();      Engine engine = factory.createEngine(); //建立高端發動機      engine.run();      engine.start();            //想要差一點的車      CarFactory factory2 = new LowCarFactory();      Engine e2= factory2.createEngine();      Seat s2 = factory2.createSeat();      Tyre t2 = factory2.createTyre();      e2.run();      e2.start();      //之後想要中等車的話能夠增長相應中等配件的接口 }

以上就是一個針對產品族的工廠，用來生產一個產品，而不是一個配件。假如之後想生產一箇中端汽車產品。就能夠增長相應的類，實現汽車總工廠CarFactory

來生產。

 

3、工廠模式要點

簡單工廠模式（靜態工廠模式）

   雖然某種程度不符合面向對象規則（不符合開閉原則，每次新增內容都須要在原有代碼上修改），可是實際使用最多。

工廠方法模式

   不修改已有類的前提下，經過增長新類來實現擴展。

抽象工廠模式

    不能夠增長產品中某一個配件，能夠增長一個具體的產品族。

 

4、應用場景

JDK中的Calendar的getInstance方法

JDBC中Connection對象的獲取getConnection

Hibernate中SessionFactory建立Session

spring中的IOC容器建立管理bean對象的時候也是工廠模式

XML解析時的DocumentBuilderFactory建立解析器對象

反射中Class對象的newInstance方法。

 

 

 Java23種設計模式學習筆記【目錄總貼】

參考資料：

　　大話設計模式(帶目錄完整版).pdf

　　HEAD_FIRST設計模式（中文版）.pdf

　　尚學堂_高淇_java300集最全視頻教程_【GOF23設計模式】