[設計模式]抽象工廠模式

簡介

---

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

抽象工廠模式是一種 類建立型模式 （ 可參考 設計模式 建立型模式）。

結構

---

圖-抽象工廠模式結構圖

抽象工廠模式包含如下角色：

• AbstractFactory（抽象工廠）
  
• ConcreteFactory（具體工廠）
• AbstractProduct（抽象產品）
• ConcreteProduct（具體產品）
  

AbstractProduct : 聲明一個接口，這個接口中包含產品對象類型。

abstract  class AbstractProductA {
     public  abstract  void show();
}

abstract  class AbstractProductB {
     public  abstract  void show();
}

ConcreteProduct : 定義一個產品對象，這個產品對象是由相關的具體工廠建立的。

class ConcreteProductA1  extends AbstractProductA {
    @Override
     public  void show() {
        System.out.println("ConcreteProductA1");
    }
}

class ConcreteProductA2  extends AbstractProductA {
    @Override
     public  void show() {
        System.out.println("ConcreteProductA2");
    }
}

class ConcreteProductB1  extends AbstractProductB {
    @Override
     public  void show() {
        System.out.println("ConcreteProductB1");
    }
}

class ConcreteProductB2  extends AbstractProductB {
    @Override
     public  void show() {
        System.out.println("ConcreteProductB2");
    }
}

AbstractFactory : 聲明一個接口，這個接口中包含建立抽象產品對象的方法。

abstract  class AbstractFactory {
     public  abstract AbstractProductA createProductA();
     public  abstract AbstractProductB createProductB();
}

ConcreteFactory : 實現建立具體產品對象的方法。

class ConcreteFactory1  extends AbstractFactory {
    @Override
     public AbstractProductA createProductA() {
         return  new ConcreteProductA1();
    }

    @Override
     public AbstractProductB createProductB() {
         return  new ConcreteProductB1();
    }
}

class ConcreteFactory2  extends AbstractFactory {
    @Override
     public AbstractProductA createProductA() {
         return  new ConcreteProductA2();
    }

    @Override
     public AbstractProductB createProductB() {
         return  new ConcreteProductB2();
    }
}

Client : 只使用 AbstractFactory 和 AbstractProduct 聲明的接口。

public  class AbstarctFactoryPattern {
     public  static  void main(String[] args) {
        AbstractFactory  factory1  =  new ConcreteFactory1();
        AbstractProductA productA1 = factory1.createProductA();
        AbstractProductB productB1 = factory1.createProductB();
        productA1.show();
        productB1.show();
        
        AbstractFactory  factory2  =  new ConcreteFactory2();
        AbstractProductA productA2 = factory2.createProductA();
        AbstractProductB productB2 = factory2.createProductB();
        productA2.show();
        productB2.show();
    }
}

運行結果

ConcreteProductA1
ConcreteProductB1
ConcreteProductA2
ConcreteProductB2

 

動機

---

一個系統要獨立於它的產品的建立、組合和表示時。

一個系統要由多個產品系列中的一個來配置時。

當你要強調一系列相關的產品對象的設計以便進行聯合使用時。

當你提供一個產品類庫，而只想顯示它們的接口而不是實現時。

要點

---

優勢

（1）抽象工廠模式隔離了具體類的生成，用戶並不須要知道什麼被建立。因爲這種隔離，更換一個具體工廠變得相對容易。全部的具體工廠都實現了抽象工廠中定義的那些公共接口，所以只須要改變具體工廠的實例，就能夠在某種程度上改變整個軟件系統的行爲。另外，應用抽象工廠模式能夠實現高內聚低耦合的設計目的，所以抽象工廠模式獲得了普遍的應用。

（2）當一個產品族中的多個對象被設計成一塊兒工做時，它可以保證客戶端始終只使用同一個產品族中的對象。這對一些須要根據當前環境來決定其行爲的軟件系統來講，是一種很是實用的設計模式。

（3）增長新的具體工廠和產品族很方便，無須修改已有系統，符合「開放封閉原則」。

缺點

在添加新的產品對象時，難以擴展抽象工廠來生產新種類的產品，這是由於在抽象工廠角色中規定了全部可能被建立的產品集合，要支持新種類的產品就意味着要對該接口進行擴展，而這將涉及到對抽象工廠角色及其全部子類的修改，顯然會帶來較大的不便。

實例

---

衆所周知，蘋果和三星這兩家世界級的電子產品廠商都生產手機和電腦。

咱們以生產手機和電腦爲例，演示一下抽象工廠模式的應用

AbstractProduct 角色

首先，定義手機和電腦兩個抽象接口，他們都有各自的產品信息

interface Telephone {
     public String getProductInfo();
}

interface Computer {
     public String getProductInfo();
}

ConcreteProduct 角色

ConcreteProduct 根據 AbstractProduct 來定義具體的產品屬性、方法。

在咱們的例子中，蘋果、三星兩家公司的手機和電腦都有各自的具體產品信息。

class AppleTelephone  implements Telephone {

    @Override
     public String getProductInfo() {
         return "蘋果手機，採用ios系統";
    }
}

class SamsungTelephone  implements Telephone {

    @Override
     public String getProductInfo() {
         return "三星手機，採用android系統";
    }
}

class AppleComputer  implements Computer {

    @Override
     public String getProductInfo() {
         return "蘋果電腦，採用mac系統";
    }
}

class SamsungComputer  implements Computer {

    @Override
     public String getProductInfo() {
         return "三星電腦，採用windows系統";
    }
}

AbstractFactory 角色

蘋果，三星這兩個廠商都生產手機和電腦。因此它們能夠有一個抽象父類或父接口，提供生產手機和生產電腦的方法。

interface ElectronicFactory {
    
     public Telephone produceTelephone();

     public Computer produceComputer();
}

ConcreteFactory 角色

蘋果、三星工廠分別實現父接口，生產不一樣類型的產品。

class AppleFactory  implements ElectronicFactory {

    @Override
     public Telephone produceTelephone() {
         return  new AppleTelephone();
    }

    @Override
     public Computer produceComputer() {
         return  new AppleComputer();
    }
}

class SamsungFactory  implements ElectronicFactory {

    @Override
     public Telephone produceTelephone() {
         return  new SamsungTelephone();
    }

    @Override
     public Computer produceComputer() {
         return  new SamsungComputer();
    }
}

測試代碼

public  class PhoneFactoryDemo {
     public  static  void main(String[] args) {
        ElectronicFactory appleFactory =  new AppleFactory();
        Telephone phone = appleFactory.produceTelephone();
        System.out.println(phone.getProductInfo());
        Computer computer = appleFactory.produceComputer();
        System.out.println(computer.getProductInfo());
    }
}

運行結果

蘋果手機，採用ios系統
蘋果電腦，採用mac系統

 

推薦閱讀

---

本文屬於 設計模式系列 。

簡單工廠模式屬於工廠模式家族，歡迎參考閱讀 簡單工廠模式 、工廠方法模式 。

參考資料

《大話設計模式》 《HeadFirst設計模式》