碼上歡樂
相關內容    簡體    繁體

設計模式之工廠模式

本文轉載自   查看原文   2017-10-26 14:00   273    java/ 設計模式

轉載：http://blog.csdn.net/lemon_tree12138/article/details/46225213

簡單工廠模式(Simple Factory Pattern)

  從簡單的工廠模式開始說起的話，我們要知道工廠模式的目的是什么？工廠模式的目的在於程序的可擴展性。而對於簡單工廠模式來說，它是為了讓程序有一個更好地封裝，降低程序模塊之間的耦合程度。

  對於簡單的工廠模式，其實也可以將其理解成為一個創建對象的工具類。工具類的形式，可以仿造如下代碼編寫：

 

[java] view plain copy
 
print?
  1. public class SimpleFactory {  
  2.   
  3.     public Object create(Class<?> clazz) {  
  4.         if (clazz.getName().equals(Plane.class.getName())) {  
  5.             return createPlane();  
  6.         } else if (clazz.getName().equals(Broom.class.getName())) {  
  7.             return createBroom();  
  8.         }  
  9.           
  10.         return null;  
  11.     }  
  12.       
  13.     private Broom createBroom() {  
  14.         return new Broom();  
  15.     }  
  16.       
  17.     private Plane createPlane() {  
  18.         return new Plane();  
  19.     }  
  20. }  
public class SimpleFactory {

    public Object create(Class<?> clazz) {
        if (clazz.getName().equals(Plane.class.getName())) {
            return createPlane();
        } else if (clazz.getName().equals(Broom.class.getName())) {
            return createBroom();
        }
        
        return null;
    }
    
    private Broom createBroom() {
        return new Broom();
    }
    
    private Plane createPlane() {
        return new Plane();
    }
}

測試代碼如下：

[java] view plain copy
 
print?
  1. public class FactoryTest {  
  2.   
  3.     public static void main(String[] args) {  
  4.         // 簡單工廠模式測試  
  5.         SimpleFactory simpleFactory = new SimpleFactory();  
  6.         Broom broom = (Broom) simpleFactory.create(Broom.class);  
  7.         broom.run();  
  8.     }  
  9. }  
public class FactoryTest {

    public static void main(String[] args) {
        // 簡單工廠模式測試
        SimpleFactory simpleFactory = new SimpleFactory();
        Broom broom = (Broom) simpleFactory.create(Broom.class);
        broom.run();
    }
}

正如之前所說的，簡單的工廠模式，就是去創建一個創建對象的工具類。在這個工具類里面，我們就可以進行一些其他操作，比如對象的初始化。這樣就避免了把對象初始化的大量代碼(如果有大量代碼的話)放在構造函數里了。

 

工廠方法模式(Factory Method Pattern)

之前說了簡單的工廠模式，在簡單的工廠模式里，我們創建了一個類似工具的類來創建相應的具體類對象。正因為其太過簡單，有一點不成規范。所以，這里要對其做一些適當地封裝。

我們來看一下工廠方法模式的定義吧。工廠方法模式定義了一個創建對象的接口，但由子類決定要實例化哪一個。工廠方法讓類把實例化推遲到了子類。（定義摘自《Head First設計模式》）

圖-1 工廠方法模式

抽象工廠：

我們的抽象工廠可以是類似這樣的：

 

[java] view plain copy
 
print?
  1. public abstract class VehicleFactory {  
  2.     public abstract Moveable create();  
  3. }  
public abstract class VehicleFactory {
    public abstract Moveable create();
}

具體工廠：

代碼就是這樣簡單而美好。而它有一個具體的實現工廠類：

 

[java] view plain copy
 
print?
  1. public class BroomFactory extends VehicleFactory {  
  2.   
  3.     @Override  
  4.     public Moveable create() {  
  5.         return new Broom();  
  6.     }  
  7.   
  8. }  
public class BroomFactory extends VehicleFactory {

    @Override
    public Moveable create() {
        return new Broom();
    }

}

這個具體的實現工廠告訴我們，這里可以通過 create() 方法來創建一個 Broom 對象。

我們可以這樣來理解他們的關系：有一個大的工廠它就是 VehicleFactory，VehicleFactory工廠里又有很多生產車間，其中有一個就是 BroomFactory。我們的具體產品都是通過這些生產車間來負責生產的。

抽象產品接口：

說到了產品，我們可以先試想一下這些具體的產品都會有什么樣的性質。我們可以這樣來定義它們：

[java] view plain copy
 
print?
  1. public interface Moveable {  
  2.     public void run();  
  3. }  
public interface Moveable {
    public void run();
}

具體產品：

嗯，這是一些可以run(移動)的產品。就 BroomFactory 生產車間而言，它負責生產 Broom。這個 Broom 是具有 Moveable 的屬性。那么它的實現可以這樣來寫：

[java] view plain copy
 
print?
  1. public class Broom implements Moveable {  
  2.   
  3.     @Override  
  4.     public void run() {  
  5.         System.out.println("我是Broom.我在飛...");  
  6.     }  
  7.   
  8. }  
public class Broom implements Moveable {

    @Override
    public void run() {
        System.out.println("我是Broom.我在飛...");
    }

}

功能測試：

我們有工廠，並且知道了工廠要生產的產品了。那么我們就來生產一個 Broom 來試試吧：

 

[java] view plain copy
 
print?
  1. VehicleFactory factory = new BroomFactory();  
  2. Moveable moveable = factory.create();  
  3. moveable.run();  
VehicleFactory factory = new BroomFactory();
Moveable moveable = factory.create();
moveable.run();

這樣我就生產了一個 Broom 了。是不是 so easy？

抽象工廠模式(Abstract Factory Pattern)

從上面的工廠方法中的結構圖中，我們可以看到其中的具體工廠A和B是兩個完全獨立的。兩者除了都是抽象工廠的子類，沒有任何其他的交集。

但是，如果我們有這樣一個需求：具體工廠A和B需要生產一些同類型的不同產品。那么我們就可以試試抽象工廠模式。

我們來看看抽象工廠模式是怎么定義的：為創建一組相關或相互依賴的對象提供一個接口，而且無需指定他們的具體類。同樣在下面的結構圖中，我們可以更好地解釋這一定義。我們的抽象工廠中包含一系列的去構造一個抽象產品的方法，而具體產品的實現則是放在了具體工廠（圖中的A和B）中進行。

圖-2 抽象工廠模式

現在我們看看代碼中是如何實現的。

抽象工廠：

 

[java] view plain copy
 
print?
  1. public abstract class AbstractFactory {  
  2.   
  3.     public abstract Flyable createFlyable();  
  4.       
  5.     public abstract Moveable createMoveable();  
  6.       
  7.     public abstract Writeable createWriteable();  
  8. }  
public abstract class AbstractFactory {

    public abstract Flyable createFlyable();
    
    public abstract Moveable createMoveable();
    
    public abstract Writeable createWriteable();
}

 

具體工廠：

從抽象工廠的代碼中也可以看出，抽象工廠只是去“生產”一些抽象的東西。有點類似於底層機制的感覺。現在我們來看看具體工廠的實現。

[java] view plain copy
 
print?
  1. public class Factory1 extends AbstractFactory {  
  2.   
  3.     @Override  
  4.     public Flyable createFlyable() {  
  5.         return new Aircraft();  
  6.     }  
  7.   
  8.     @Override  
  9.     public Moveable createMoveable() {  
  10.         return new Car();  
  11.     }  
  12.   
  13.     @Override  
  14.     public Writeable createWriteable() {  
  15.         return new Pen();  
  16.     }  
  17.   
  18. }  
public class Factory1 extends AbstractFactory {

    @Override
    public Flyable createFlyable() {
        return new Aircraft();
    }

    @Override
    public Moveable createMoveable() {
        return new Car();
    }

    @Override
    public Writeable createWriteable() {
        return new Pen();
    }

}

 

抽象產品接口：

在具體工廠里，我們就可以生產一些具體的產品了。就是這里的Aircraft、Car、Pen。抽象的產品接口如下。

 

[java] view plain copy
 
print?
  1. public interface Flyable {  
  2.   
  3.     public void fly(int height);  
  4. }  
public interface Flyable {

    public void fly(int height);
}

 

具體產品：

具體的產品則是要去實現這個接口，並實現其中的方法，如下：

 

[java] view plain copy
 
print?
  1. public class Aircraft implements Flyable {  
  2.   
  3.     @Override  
  4.     public void fly(int height) {  
  5.         System.out.println("我是一架客運機，我目前的飛行高度為：" + height + "千米。");  
  6.     }  
  7.   
  8. }  
public class Aircraft implements Flyable {

    @Override
    public void fly(int height) {
        System.out.println("我是一架客運機，我目前的飛行高度為：" + height + "千米。");
    }

}

 

功能測試：

有了這些東西，那么我們就來好好生產一些產品吧。

[java] view plain copy
 
print?
  1. public class FactoryTest {  
  2.   
  3.     public static void main(String[] args) {  
  4.         AbstractFactory factory = new Factory1();  
  5.         Flyable flyable = factory.createFlyable();  
  6.         flyable.fly(1589);  
  7.           
  8.         Moveable moveable = factory.createMoveable();  
  9.         moveable.run(87.6);  
  10.           
  11.         Writeable writeable = factory.createWriteable();  
  12.         writeable.write("Hello World.");  
  13.     }  
  14. }  
public class FactoryTest {

    public static void main(String[] args) {
        AbstractFactory factory = new Factory1();
        Flyable flyable = factory.createFlyable();
        flyable.fly(1589);
        
        Moveable moveable = factory.createMoveable();
        moveable.run(87.6);
        
        Writeable writeable = factory.createWriteable();
        writeable.write("Hello World.");
    }
}

  現在讓我們來看一下，結果是否跟我們想的一樣吧。

 

 

圖-3 抽象工廠模式運行結果圖

 

 

總結

以上就是工廠模式的基本實現和詳細說明。包括了簡單工廠模式、工廠方法模式、抽象工廠模式。我們可以基於需求來選擇合適的工廠模式。下面給出本文的所有代碼的GitHub鏈接。


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 設計模式之工廠模式與抽象工廠模式 設計模式之工廠模式（四） [設計模式]抽象工廠模式 設計模式——簡單工廠模式 Go 設計模式--工廠模式 python設計模式之工廠模式 設計模式之工廠模式 設計模式（0）簡單工廠模式 Spring設計模式_工廠模式 設計模式之工廠模式
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM