2. 程式人生 > >java設計模式中的工廠模式

java設計模式中的工廠模式

阿新 • • 發佈：2019-01-28
工廠模式：主要用來例項化有共同介面的類，工廠模式可以動態決定應該例項化那一個類。
工廠模式的形態
工廠模式主要用一下幾種形態：
1：簡單工廠（Simple Factory）。
2：工廠方法（Factory Method）。
3：抽象工廠（Abstract Factory）。

簡單工廠（Simple Factory）
又叫靜態工廠，是工廠模式三中狀態中結構最為簡單的。主要有一個靜態方法，用來接受引數，並根據引數來決定返回實現同一介面的不同類的例項。我們來看一個具體的例子：
假設一家工廠，幾生產洗衣機，有生產冰箱，還有空調等等..
我們先為所有產品定義一個共同的產品介面
Java程式碼 
  1. public interface Product{} 
public interface Product{}

接著我們讓這個工廠的所有產品都必須實現此介面
Java程式碼 
  1. public class Washerimplements Product{ 
  2.    public Washer(){ 
  3.        System.out.println("洗衣機被製造了"); 
  4.    } 
  5. } 
  6. public class Iceboximplements Product{ 
  7.    public Icebox(){ 
  8.        System.out.println("冰箱被製造了"); 
  9.    } 
  10. } 
  11. public class AirConditionimplements Product{ 
  12.    public
    Icebox(){ 
  13.        System.out.println("空調被製造了"); 
  14.    } 
  15. }  
public class Washer implements Product{
   public Washer(){
       System.out.println("洗衣機被製造了");
   }
}

public class Icebox implements Product{
   public Icebox(){
       System.out.println("冰箱被製造了");
   }
}

public class AirCondition implements Product{
   public Icebox(){
       System.out.println("空調被製造了");
   }
}

接下來我們來寫一個工廠類，有它來負責生產以上的產品
Java程式碼 
  1. public class SimpleFactory { 
  2.     public static Product factory(String productName)throws Exception{ 
  3.         if(productName.equals("Washer")){ 
  4.             return new Washer(); 
  5.         }else if(productName.equals("Icebox")){ 
  6.             return new Icebox(); 
  7.         }else if(productName.equals("AirCondition")){ 
  8.             return new AirCondition(); 
  9.         }else{ 
  10.             throw new Exception("沒有該產品"); 
  11.         } 
  12.     } 
  13. }  
public class SimpleFactory {
	
	public static Product factory(String productName) throws Exception{
		if(productName.equals("Washer")){
			return new Washer();
		}else if(productName.equals("Icebox")){
			return new Icebox();
		}else if(productName.equals("AirCondition")){
			return new AirCondition();
		}else{
			throw new Exception("沒有該產品");
		}
	}
}

好了，有了這個工廠類，我們就可以開始下定單了，SimpleFactory將根據不同的定單類決定生產什麼產品。
Java程式碼 
  1. public static void main(String[] args) { 
  2.     try { 
  3.               SimpleFactory.factory("Washer"); 
  4.               SimpleFactory.factory("Icebox"); 
  5.               SimpleFactory.factory("AirCondition"); 
  6.             } catch (Exception e) { 
  7.         e.printStackTrace(); 
  8.     } 
  9. }  
public static void main(String[] args) {
	try {
              SimpleFactory.factory("Washer");
              SimpleFactory.factory("Icebox");
              SimpleFactory.factory("AirCondition");
            } catch (Exception e) {
		e.printStackTrace();
	}
}

由上面的程式碼可以看出，簡單工廠的核心就是一個SimpleFactory類，他擁有必要的邏輯判斷能力和所有產品的建立權利，我們只需要向把定單給他，就能得到我們想要的產品。這使用起來似乎非常方便。
但，實際上，這個SimpleFactory有很多的侷限。首先，我們每次想要增加一種新產品的時候，都必須修改SimpleFactory的原始碼。其次，當我們擁有很多很多產品的時候，而且產品之間又存在複雜的層次關係的時候，這個類必須擁有複雜的邏輯判斷能力，其程式碼量也將不斷地激增，這對以後的維護簡直就是恐怖兩個字...
還有就是，整個系統都嚴重依賴SimpleFactory類，只要SimpleFactory類一出問題，系統就進入不能工作的狀態，這也是最為致命的一點....
以上的不足將在工廠模式的另外兩種狀態中得到解決。

工廠方法（Factory Method）
上面的程式碼告訴我們，簡單工廠並不簡單，它是整個模式的核心，一旦他出了問題，整個模式都將受影響而不能工作，為了降低風險和為日後的維護、擴充套件做準備，我們需要對它進行重構，引入工廠方法。
工廠方法為工廠類定義了介面，用多型來削弱了工廠類的職能，以下是工廠介面的定義：
Java程式碼 
  1. public interface Factory{ 
  2.   public Product create(); 
  3. }  
public interface Factory{
  public Product create();
}

我們再來定義一個產品介面
Java程式碼 
  1. public interface Product{} 
public interface Product{}

一下是實現了產品介面的產品類
Java程式碼 
  1. public class Washerimplements Product{ 
  2.    public Washer(){ 
  3.        System.out.println("洗衣機被製造了"); 
  4.    } 
  5. } 
  6. public class Iceboximplements Product{ 
  7.    public Icebox(){ 
  8.        System.out.println("冰箱被製造了"); 
  9.    } 
  10. } 
  11. public class AirConditionimplements Product{ 
  12.    public Icebox(){ 
  13.        System.out.println("空調被製造了"); 
  14.    } 
  15. }  
public class Washer implements Product{
   public Washer(){
       System.out.println("洗衣機被製造了");
   }
}

public class Icebox implements Product{
   public Icebox(){
       System.out.println("冰箱被製造了");
   }
}

public class AirCondition implements Product{
   public Icebox(){
       System.out.println("空調被製造了");
   }
}

接下來，就是工廠方法的核心部分，也就是具體建立產品物件的具體工廠類，
Java程式碼 
  1. //建立洗衣機的工廠 
  2. public class CreateWasherimplements Factory{ 
  3.     public Product create(){ 
  4.           return new Washer(); 
  5.     } 
  6. } 
  7. //建立冰箱的工廠 
  8. public class CreateIceboximplements Factory{ 
  9.     public Product create(){ 
  10.           return new Icebox(); 
  11.     } 
  12. } 
  13. //建立空調的工廠 
  14. public class CreateAirConditionimplements Factory{ 
  15.     public Product create(){ 
  16.           return new AirCondition(); 
  17.     } 
  18. }  
//建立洗衣機的工廠
public class CreateWasher implements Factory{
    public Product create(){
          return new Washer();
    }
}

//建立冰箱的工廠
public class CreateIcebox implements Factory{
    public Product create(){
          return new Icebox();
    }
}

//建立空調的工廠
public class CreateAirCondition implements Factory{
    public Product create(){
          return new AirCondition();
    }
}

從上面建立產品物件的程式碼可以看出，工廠方法和簡單工廠的主要區別是，簡單工廠是把建立產品的職能都放在一個類裡面，而工廠方法則把不同的產品放在實現了工廠介面的不同工廠類裡面，這樣就算其中一個工廠類出了問題，其他工廠類也能正常工作，互相不受影響，以後增加新產品，也只需要新增一個實現工廠介面工廠類，就能達到，不用修改已有的程式碼。但工廠方法也有他侷限的地方，那就是當面對的產品有複雜的等級結構的時候，例如，工廠除了生產家電外產品，還生產手機產品，這樣一來家電是手機就是兩大產品家族了，這兩大家族下面包含了數量眾多的產品，每個產品又有多個型號，這樣就形成了一個複雜的產品樹了。如果用工廠方法來設計這個產品家族系統，就必須為每個型號的產品建立一個對應的工廠類，當有數百種甚至上千種產品的時候，也必須要有對應的上百成千個工廠類，這就出現了傳說的類爆炸，對於以後的維護來說，簡直就是一場災難.....

抽象工廠（Factory Method）
抽象工廠：意的意圖在於建立一系列互相關聯或互相依賴的物件。<<Java設計模式>>
我自己覺得抽象工廠是在工廠方法的基礎上引進了分類管理的概念....
工廠方法用來建立一個產品，它沒有分類的概念，而抽象工廠則用於建立一系列產品，所以產品分類成了抽象工廠的重點，
我們繼續用上面的例子來說明：
工廠生產的所有產品都用都用大寫字母來標明它們的型號，比如冰箱，就有“冰箱-A",“冰箱-B",同樣，其他的產品也都是遵守這個編號規則，於是就有了一下產品家族樹

冰箱：
  1. 冰箱-A  
  2. 冰箱-B


洗衣機：
  1. 洗衣機-A  
  2. 洗衣機-B

我們可以為冰箱和洗衣機分別定義兩個產品介面，以對他們進行分類，
Java程式碼 
  1. //洗衣機介面 
  2. public interface Washer{ 
  3. } 
  4. //冰箱介面 
  5. public interface Icebox{ 
  6. }  
//洗衣機介面
public interface Washer{
}

//冰箱介面
public interface Icebox{
}

接著，我們分別建立這兩個介面的具體產品
Java程式碼 
  1. //洗衣機-A 
  2. public class WasherAimplements Washer{ 
  3.    public WasherA(){ 
  4.        System.out.println("洗衣機-A被製造了"); 
  5.    } 
  6. } 
  7. //洗衣機-B 
  8. public class WasherBimplements Washer{ 
  9.    public WasherB(){ 
  10.        System.out.println("洗衣機-B被製造了"); 
  11.    } 
  12. } 
  13. //冰箱-A 
  14. public class IceboxAimplements Icebox{ 
  15.    public IceboxA(){ 
  16.        System.out.println("冰箱-A被製造了"); 
  17.    } 
  18. } 
  19. //冰箱-B 
  20. public class IceboxBimplements Icebox{ 
  21.    public IceboxB(){ 
  22.        System.out.println("冰箱-B被製造了"); 
  23.    } 
  24. }  
//洗衣機-A
public class WasherA implements Washer{
   public WasherA(){
       System.out.println("洗衣機-A被製造了");
   }
}

//洗衣機-B
public class WasherB implements Washer{
   public WasherB(){
       System.out.println("洗衣機-B被製造了");
   }
}

//冰箱-A
public class IceboxA implements Icebox{
   public IceboxA(){
       System.out.println("冰箱-A被製造了");
   }
}

//冰箱-B
public class IceboxB implements Icebox{
   public IceboxB(){
       System.out.println("冰箱-B被製造了");
   }
}

到此，產品部分我們準備好了，接下來我們來處理工廠部分，我們先來定義工廠行為介面
Java程式碼 
  1. public interface Factory{ 
  2.        public Washer createWasher(); 
  3.        public Icebox createIcebox(); 
  4. }  
public interface Factory{
       public Washer createWasher();
       public Icebox createIcebox();
}

接下來我創造具體的工廠類，我們根據上面產品的介面，把型號A的產品分為一類，由一個工廠來管理，把型號為B的產品有另一個工廠管理，根據這個分類，我們可以實現如下的兩個具體工廠類
Java程式碼 
  1. //建立型號為A的產品工廠 
  2. public class FactoryAimplements Factory{ 
  3.        //建立洗衣機-A 
  4.        public Washer createWasher(){ 
  5.             return new WasherA(); 
  6.        } 
  7.        //建立冰箱-A 
  8.        public Icebox createIcebox(){ 
  9.             return new IceboxA(); 
  10.        } 
  11. } 
  12. //建立型號為B的產品工廠 
  13. public class FactoryBimplements Factory{ 
  14.        //建立洗衣機-B 
  15.        public Washer createWasher(){ 
  16.             return new WasherB(); 
  17.        } 
  18.        //建立冰箱-B 
  19.        public Icebox createIcebox(){ 
  20.             return new IceboxB(); 
  21.        } 
  22. }  
//建立型號為A的產品工廠
public class FactoryA implements Factory{
       //建立洗衣機-A
       public Washer createWasher(){
            return new WasherA();
       }

       //建立冰箱-A
       public Icebox createIcebox(){
            return new IceboxA();
       }
}

//建立型號為B的產品工廠
public class FactoryB implements Factory{
       //建立洗衣機-B
       public Washer createWasher(){
            return new WasherB();
       }

       //建立冰箱-B
       public Icebox createIcebox(){
            return new IceboxB();
       }
}


這樣，我們的抽象工廠就完成了。有上面可以看出，在運用上我覺得工廠方法和抽象工廠，都有自己的應用場景，並沒有什麼優劣之分，但在應用抽象工廠之前，要先對建立的物件進行系統的分類，這點很重要，好的產品分類規則能為具體工廠類的選擇呼叫和以後的擴充套件提供清晰的思路.

angrfeng個人總結：

靜態工廠：工廠很原始，工廠有什麼，就只能製造什麼，有新產品進來，要重新設計工廠（修改原始碼），往廠裡新增新產品的型別，某產品有變更，也要修改工廠，導致一個最嚴重問題，某一條生成線（製作不同的產品線）炸了，就是工廠炸了，然後整個生成線都炸了，boom！！boom7炸了，難道整個三星的手機廠都炸了？這樣設計明顯弊端很大！

工廠方法：工廠相對先進，有一個總工廠，總工廠下有很多子工廠，各個子工廠工作明確，製造的產品分離開，有新產品進來，不用像靜態工廠一樣改造總廠的東西，只要新增一個子工廠即可，修改某產品的設計，也只要修改改產品的子工廠設計即可。某一子工廠出現問題，不會影響其他子工廠，boom7炸了，s6這些手機還是能繼續生產的。但是該模式也有一個弊端，就是隻能生產關係結構簡單的產品。例如，三星做手機，但是又想做做手機膜，然後因為某些原因，各個手機的型號，大小，螢幕不同的原因，要製造跟手機型號匹配的手機膜。問題來了，現在是不是要重新又製造一個手機膜工廠，又根據不同的型號建立一大堆不同型號的手機膜工廠？如果還有其他對應的配件要生產，是不是又要建立一個配件廠，又建立一代對不同手機型號的配件廠？這就出現了類爆炸了。手機螢幕和手機膜之類的子工廠之間沒有聯絡（不同型號手機的配件子工廠沒聯絡就算了，同一手機下的配件子工廠都沒有聯絡），這樣的工廠管理起來，不會很麻煩嗎？

抽象工廠：工廠更加先進，在設計一個產品時，將產品和相關產品的生產方式抽象出來，放進一個總工廠裡。當生產某一具體產品時，繼承總工廠的模式，建立子產品生產線和相關產品生產線。例如：三星手機總廠，生產手機要生產什麼？螢幕，cpu，電池，外殼，還有手機膜等等，這些都是手機必備的，但是又是不同手機有不同型號啊大小啊的。現在總工廠將這些抽取出來，以後建廠就按照這個模板來。要生產s5，就建一個s5的手機廠，手機廠下有多條負責不同配件的生產線（這些不同配件生產線也可以抽取出來建廠製造，或者叫富士康代工...），生產boom7也一樣。現在bonm7炸了，可以返廠，檢查boom7下的各個生產線究竟哪裡出錯，馬上修改解決！這樣就實現了各類子工廠之間隔離，子工廠裡各類生產線隔離，但是子工廠屬於總工廠，各類子工廠生產線屬於子工廠。每一個生產線之間關係簡單，每一個子工廠之間結構明瞭！

感覺我的想法跟原帖的抽象工廠和工廠方法兩個有點分歧，以上紅字是我個人的理解，若有不正確的地方歡迎留言指正。。。

相關推薦

java設計模型 解析工廠模式、proxy-agent模式、templete模式

復制代碼 nbsp 解析 try java.awt master 函數 form pre 1、Factory Design pattern 工廠設計模式的優點 （1）工廠設計模式提供了接口而不是實現的代碼方法。 （2）工廠模式從客戶端代碼中刪除實際實現類的實例化。

java中的設計模式之單例模式、工廠模式

Java中的設計模式            轉載地址：https://www.toutiao.com/i6573486403282272775/ 為什麼要學習設計模式 1）設計模式都是一些相對優秀的解決方案，很多問題都是典型的

Java中常見的設計模式---簡單工廠模式、工廠方法模式和單例模式

在講設計模式之前，我們首先來說一下面向物件思想的設計原則，在實際的開發中，我們要想更深入的瞭解面向物件思想，就必須熟悉前人總結過的面向物件的思想的設計原則：1.單一職責原則：“高內聚，低耦合”，也就是說，每個類應該只有一個職責，對外只能提供一種功能，而引起類變化的原因應該只有

淺析JAVA設計模式之工廠模式(二)

1.2 源碼 pub color post del tar pop south 1 工廠方法模式簡單介紹 工廠方法 (Factroy Method)模式：又稱多態性工廠模式（Polymorphic Factory），在這樣的模式中，核心工廠不再是一個詳

Java設計模式之工廠模式

href 1.2 net main override create 靜態工廠方法 lan soft 工廠方法模式 工廠方法模式分為三種：普通工廠模式、多個工廠方法模式和靜態工廠方法模式。 1、普通工廠模式 普通工廠模式就是建立一個工廠類，對實現了同一接口的一些類進行實

Java設計模式之工廠模式（二）：抽象工廠模式

mar 模式 blank http left taxi ref www. app 2碳依5FVL冒傲3http://t.docin.com/etw488 am懦7鈉N山段9慌Q闌http://shequ.docin.com/ipu5657 iK1諾5N鍛認EUK剖嘲肆h

JAVA 設計模式 之 工廠模式

java 工廠模式 設計模式 1、為什麽要使用工廠模式？ 比方說，一位滴滴司機，如果要去開車掙錢的話，他得自己會制造汽車，然後，才能使用汽車掙錢；對於這位司機來說，要求很高了，畢竟汽車很難制造出來； 如果使用工廠模式的話，這位司機，只需要知道汽車工廠就可以了，直接去工廠提車就行。從

Java 設計模式學習-單例模式&工廠模式

最近看一個專案的原始碼，裡面的很多程式碼都不是很懂，原來是因為不理解程式碼中的設計模式，在一些大神的部落格中，學習一一些設計模式的知識，現把學習的內容記錄下來。 單例模式 單例模式是常用的設計模式，在java 應用中，能保證在一個JVM中，該物件只有一個例項存在，這樣的設計有幾個好處

Java設計模式（一）之建立型模式：工廠模式（簡單工廠模式+工廠方法模式）

在面向物件程式設計中, 最通常的方法是一個new操作符產生一個物件例項,new操作符就是用來構造物件例項的。但是在一些情況下, new操作符直接生成物件會帶來一些問題。舉例來說，許多型別物件的建立需要一系列的步驟：你可能需要計算或取得物件的初始位置；選擇生成哪個子物件例項；或在你生成你需要的物件

Java設計模式之 工廠模式

Java設計模式 - 工廠模式   工廠模式使用場景: 工廠模式分為簡單工廠 工廠 抽象工廠模式. 當用戶需要一個類的子類例項,且不希望與該類的子類行成耦合或者不知道該類有哪些子類可用時,可採用工廠模式; 當用戶需要系統提供多個物件,且希望和建立物件的類解耦時,可採用抽象工廠模

JAVA 23種設計模式---工廠模式(簡單工廠模式)

寫在前面的話： java常用的設計模式有23種，設計模式就是為了重用程式碼、解耦、讓程式碼更容易讓他人理解、保證程式碼可靠性 設計模式遵循的原則有6個： 1、開閉原則（Open Close Principle） 　　對擴充套件開放，對修改關閉。 2、里氏代換原則（Liskov S

JAVA設計模式-1-工廠模式

工廠模式是Java中最常用的設計模式之一。這種型別的設計模式屬於建立模式，因為此模式提供了建立物件的最佳方法之一。 在Factory模式中，我們建立物件而不將建立邏輯暴露給客戶端，並使用公共介面引用新建立的物件。 履行 我們將建立一個Shape介面和實現Shape介面的具體類。工廠類Sha

java常用設計模式--抽象工廠模式簡單例子

package com.ruanyun;/** * @Auther: maxw * @Date: 2018/11/12 11:23 * @Description:抽象工廠模式:與工廠方法模式不同的是，工廠方法模式中的工廠只生產單一的產品，而抽象工廠模式中的工廠生產多個產品。 * 還有個抽象工廠方法模式 只需要

java設計模式-- Factory 工廠模式

Factory 工廠模式          工廠模式實現了建立者和呼叫者的分離。 分類： 1.簡單工廠 2.工廠方法模式：定義一個用於建立物件的介面，讓子類決定例項化哪一個類，工廠方法使一個類的例項化延遲到其子類 3.抽象工廠：提

Spring中常用的設計模式：工廠模式

文章目錄 工廠模式 例項 1. 先實現簡單工廠 2. 工廠類(修改) 3. 增加配置檔案 4. 測試類 5. 總結 工廠模式 Beanfactory是一

Java設計模式-單例模式、觀察者模式、工廠模式

單例設計模式 概念： 全域性只有一個例項，自行例項化物件，自行向整個系統提供這個例項。 應用場景： 需要全域性只有一個例項的時候，如儲存使用者資訊。 只有一個訪問途徑 優點： 全域性只有一個例項，避免了頻繁的建立例項，耗費的資源。 提

Java設計模式-簡單工廠模式/工廠模式/抽象工廠模式

目錄 簡單工廠模式 工廠模式 抽象工廠模式 上述程式碼 GitHub 地址：https://github.com/baicun/designPatterns 共同點：建立一個類，對同樣操作的方法介面進行封裝，類似工廠管理生產線等情形。 優點：方便管理，易於拓展。 應用

java設計模式--抽象工廠模式

1 背景     上一章節我們說到了造車，當是客戶經理忘記了一件很重要的事情，忘記車還分手動擋和自動擋了，所有這次就用抽象工廠來實現了。     然後我們就開始分析了，首先當然是車啦，然後各種型號下又分別有手動擋和自動擋

java中工廠模式

工廠模式： 1.隱藏複雜的邏輯過程，只關心結果 分為：簡單工廠，工廠方法，抽象工廠 簡單工廠： 1.產品介面： package com.gupaoedu.vip.factory; //產品介面 //汽車需要滿足一定的標準 public interface Car

重走Java設計模式——抽象工廠模式（Abstract Factory Pattern）

抽象工廠模式 抽象工廠模式是所有形態的工廠模式中最為抽象和最具一般性的一種形態。 抽象工廠模式是指當有多個抽象角色時，使用的一種工廠模式。抽象工廠模式可以向客戶端提供一個介面，使客戶端在不必指定產品的具體的情況下，建立多個產品族中的產品物件。根據里氏替換原則，任