抽象工廠模式（Java與Kotlin版）

 

前文推送

設計模式

簡單工廠模式（Java與Kotlin版）

工廠方法模式（Java與Kotlin版）

 

Kotlin基礎知識

Kotlin入門第一課：從對比Java開始

Kotlin入門第二課：集合操做

Kotlin入門第三課：數據類型

初次嘗試用Kotlin實現Android項目

 

1. 定義

抽象工廠模式（Abstract Factory Pattern）：提供一個建立一系列相關或相互依賴對象的接口，而無須指定它們具體的類。抽象工廠模式又稱爲Kit模式，屬於對象建立型模式。

 

2. 結構

AbstractFactory：抽象工廠，定義建立實例的抽象方法；

ConcreteFactory：具體工廠，實現具體邏輯；

AbstractProduct：抽象產品，定義產品的抽象方法；

Product：具體產品，實現具體邏輯；

 

3. 代碼

3.1 Java

AbstractProductA與AbstractProductB：

1 abstract class AbstractProductA {
2     abstract void printA();
3 }
4 
5 abstract class AbstractProductB {
6     abstract void printB();
7 }

定義了兩個抽象產品角色，分別有抽象方法printA和printB。

ConcreteProductA一、ConcreteProductA二、ConcreteProductB1及ConcreteProductB2：

 1 class ConcreteProductA1 extends AbstractProductA {
 2     void printA() {
 3         System.out.println("printA of ConcreteProductA1");
 4     }
 5 }
 6 
 7 class ConcreteProductA2 extends AbstractProductA {
 8     void printA() {
 9         System.out.println("printA of ConcreteProductA2");
10     }
11 }
12 
13 class ConcreteProductB1 extends AbstractProductB {
14     void printB() {
15         System.out.println("printB of ConcreteProductB1");
16     }
17 }
18 
19 class ConcreteProductB2 extends AbstractProductB {
20     void printB() {
21         System.out.println("printB of ConcreteProductB2");
22     }
23 }

定義了四個具體產品角色，分別實現了父類對應的printA和printB方法。

A1和B1屬於同一個產品族的不一樣產品等級的兩種產品，A2和B2相似。其中：

產品等級——同一類產品的產品等級相同，如海爾冰箱、西門子冰箱等；

產品族——同一家工廠生產的不一樣產品等級的產品，如海爾冰箱、海爾洗衣機等。

AbstractFactory：

1 abstract class AbstractFactory {
2     abstract AbstractProductA createProductA();
3     abstract AbstractProductB createProductB();
4 }

定義了抽象工廠角色，及抽象方法createProductA和createProductB。

ConcreteFactory1與ConcreteFactory2：

 1 class ConcreteFactory1 extends AbstractFactory {
 2     AbstractProductA createProductA() {
 3         System.out.println("create ProductA1");
 4 
 5         return new ConcreteProductA1();
 6     }
 7 
 8     AbstractProductB createProductB() {
 9         System.out.println("create ProductB1");
10 
11         return new ConcreteProductB1();
12     }
13 }
14 
15 class ConcreteFactory2 extends AbstractFactory {
16     AbstractProductA createProductA() {
17         System.out.println("create ProductA2");
18 
19         return new ConcreteProductA2();
20     }
21 
22     AbstractProductB createProductB() {
23         System.out.println("create ProductB2");
24 
25         return new ConcreteProductB2();
26     }
27 }

定義了兩個具體工廠角色，分別實現了createProductA和createProductB方法。

AbstractFactoryPattern：

 1 public class AbstractFactoryPattern {
 2     public static void main(String[] args) {
 3         System.out.println("Abstract Factory Pattern");
 4 
 5         AbstractFactory factory = new ConcreteFactory1();
 6         AbstractProductA productA = factory.createProductA();
 7         AbstractProductB productB = factory.createProductB();
 8         productA.printA();
 9         productB.printB();
10 
11         factory = new ConcreteFactory2();
12         productA = factory.createProductA();
13         productB = factory.createProductB();
14         productA.printA();
15         productB.printB();
16     }
17 }

不一樣產品族的具體產品實例，用不一樣的具體工廠來建立。

輸出：

 

3.2 Kotlin

AbstractProductA與AbstractProductB：

1 abstract class AbstractProductA {
2     abstract fun printA()
3 }
4 
5 abstract class AbstractProductB {
6     abstract fun printB()
7 }

ConcreteProductA一、ConcreteProductA二、ConcreteProductB1及ConcreteProductB2：

 1 class ConcreteProductA1 : AbstractProductA() {
 2     override fun printA() {
 3         println("printA of ConcreteProductA1")
 4     }
 5 }
 6 
 7 class ConcreteProductA2 : AbstractProductA() {
 8     override fun printA() {
 9         println("printA of ConcreteProductA2")
10     }
11 }
12 
13 class ConcreteProductB1 : AbstractProductB() {
14     override fun printB() {
15         println("printB of ConcreteProductB1")
16     }
17 }
18 
19 class ConcreteProductB2 : AbstractProductB() {
20     override fun printB() {
21         println("printB of ConcreteProductB2")
22     }
23 }

AbstractFactory：

1 abstract class AbstractFactory {
2     abstract fun createProductA(): AbstractProductA
3     abstract fun createProductB(): AbstractProductB
4 }

ConcreteFactory1與ConcreteFactory2：

 1 class ConcreteFactory1 : AbstractFactory() {
 2     override fun createProductA(): AbstractProductA {
 3         println("create ProductA1")
 4 
 5         return ConcreteProductA1()
 6     }
 7 
 8     override fun createProductB(): AbstractProductB {
 9         println("create ProductB1")
10 
11         return ConcreteProductB1()
12     }
13 }
14 
15 class ConcreteFactory2 : AbstractFactory() {
16     override fun createProductA(): AbstractProductA {
17         println("create ProductA2")
18 
19         return ConcreteProductA2()
20     }
21 
22     override fun createProductB(): AbstractProductB {
23         println("create ProductB2")
24 
25         return ConcreteProductB2()
26     }
27 }

AbstractFactoryPattern：

 1 fun main(args: Array<String>) {
 2     println("Abstract Factory Pattern")
 3 
 4     var factory: AbstractFactory = ConcreteFactory1()
 5     var productA = factory.createProductA()
 6     var productB = factory.createProductB()
 7     productA.printA()
 8     productB.printB()
 9 
10     factory = ConcreteFactory2()
11     productA = factory.createProductA()
12     productB = factory.createProductB()
13     productA.printA()
14     productB.printB()
15 }

輸出同上。

 

4. 優缺點

4.1 優勢

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

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

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

 

4.2 缺點

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

開閉原則的傾斜性（增長新的工廠和產品族容易，增長新的產品等級結構麻煩）。

 

5. 適用場景

一個系統不該當依賴於產品類實例如何被建立、組合和表達的細節，這對於全部類型的工廠模式都是重要的；

系統中有多於一個的產品族，而每次只使用其中某一產品族；

屬於同一個產品族的產品將在一塊兒使用，這一約束必須在系統的設計中體現出來；

系統提供一個產品類的庫，全部的產品以一樣的接口出現，從而使客戶端不依賴於具體實現。