JAVA中的設計模式二（工廠模式）

工廠模式：主要用來實例化有共同介面的類，工廠模式可以動態決定應該實例化那一個類。

工廠模式主要有：

簡單工廠模式，工廠方法，抽象工廠；

簡單工廠：

又叫靜態工廠，是工廠模式三中狀態中結構最為簡單的。主要有一個靜態方法，用來接受參數，並根據參數來決定返回實現同一介面的不同類的實例。我們來看一個具體的例子：

如下麵價單的圖形

代碼如下：
首先我們先創建一個抽象的產品：

1 package Factory;
2 
3 public abstract  class BMW {
4 
5     public BMW() {
6     }
7     
8 }

然後我們具體的產品類去繼承我們的抽象產品：

 1 public class BMW320 extends BMW{
 2     public BMW320() {
 3         // TODO Auto-generated constructor stub
 4         System.out.println("生產BMW320");
 5     }
 6 }
 7 
 8 
 9 
10 
11 
12 public class BMW523 extends BMW{
13     public BMW523() {
14         // TODO Auto-generated constructor stub
15         System.out.println("生產BMW523");
16     }
17 }

下麵我們創建我們的工廠：

 1 package Factory;
 2 
 3 public class Factory {
 4     public BMW crateBMW(int type){
 5         if(type==320){
 6             return new BMW320();
 7         }else if (type==523){
 8             return new BMW523();
 9         }else{
10             return null;
11         }
12     }
13     }

下麵就是客戶了，客戶需要產品，我們進行生產：

1 package Factory;
2 
3 public class Customer {
4     public static void main(String[] args) {
5         Factory f=new Factory();
6         BMW b320=f.crateBMW(320);
7         BMW b523=f.crateBMW(523);
8     }
9 }

運行的結果如下-----：

這個就是簡單的工廠模式；

上面的代碼告訴我們，簡單工廠並不簡單，它是整個模式的核心，一旦他出了問題，整個模式都將受影響而不能工作，為了降低風險和為日後的維護、擴展做準備，我們需要對它進行重構，引入工廠方法。

工廠方法：

工廠方法其實就是，不同額工廠對應不同的產品，就算其中某一個工廠不能正常工作了，也不會影響到其他的工廠工作；

首先我們先創建 產品介面和對應的具體產品

 1 public interface Product {
 2     
 3 }
 4 
 5 
 6 public class Washer implements Product{
 7 
 8     public Washer() {
 9         System.out.println("洗衣機被製造了");
10     }
11     
12 }
13 
14 
15 
16 public class AirCondition implements Product{
17 
18     public AirCondition() {
19         System.out.println("空調被製造了");
20     }
21 }

然後我們再創建 工廠介面和對應的具體生產不同商品的工廠

public interface Factory {
    
}



public class WasherFactory implements Factory{
    
    public Product make(){
        return new Washer();
    }
}




public class AirConditionFactory implements Factory{
    public Product make(){
        return new AirCondition();
    }
}

最後就是顧客了，

 1 package Factory2;
 2 
 3 public class Customer {
 4 
 5     public static void main(String[] args) {
 6         // TODO Auto-generated method stub
 7         
 8         WasherFactory f=new WasherFactory();
 9         Product w=f.make();
10         
11         AirConditionFactory f2=new AirConditionFactory();
12         Product w2=f2.make();
13     }
14 }

運行的結果為：

可以理解為：有了很多個工廠方法，自己需要哪一個產品，就調用當前產品的工廠方法，獲取相應的具體實例。

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

抽象方法：

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

首先：我們創造不同的 電視和滑鼠的介面：

1 public interface TV {
2 }
3 
4 
5 public interface Mouse {
6 
7 }

 然後我們創造冰箱和滑鼠的不同的品種：

 1 public class TV_A implements TV{
 2 
 3     public TV_A() {
 4         System.out.println("A型TV");
 5     }
 6 
 7 }
 8 
 9 
10 public class TV_B implements TV{
11     
12     public TV_B() {
13         System.out.println("B型TV");
14     }
15     
16 }
17 
18 
19 public class Mouse_A implements Mouse{
20 
21     public Mouse_A() {
22         System.out.println("A型滑鼠");
23     }
24 
25 }
26 
27 
28 public class Mouse_B implements Mouse{
29 
30     public Mouse_B() {
31         System.out.println("B型滑鼠");
32     }
33 
34 }

 最後就等到了不同類型的工廠，生產不同類型的產品。如A工廠只生產A類型的產品

public class Factory_A implements Factory{

    @Override
    public TV createTv() {
        // TODO Auto-generated method stub
        return new TV_A();
    }

    @Override
    public Mouse createMouse() {
        // TODO Auto-generated method stub
        return new Mouse_A();
    }

}



public class Factory_B implements Factory{

    @Override
    public TV createTv() {
        // TODO Auto-generated method stub
        return new TV_B();
    }

    @Override
    public Mouse createMouse() {
        // TODO Auto-generated method stub
        return new Mouse_B();
    }
    
}

 最後就是測試類：

 1 package Foctory3;
 2 
 3 public class Customer {
 4     public static void main(String[] args) {
 5         Factory f=new Factory_A();
 6         f.createTv();
 7         f.createMouse();
 8         
 9         f=new Factory_B();
10         f.createTv();
11         f.createMouse();
12     }
13 }

運行結果如圖所示：