面向對象-設計模式-創建型

面向對象-設計模式-創建型

 

　　　　　　晴川歷歷漢陽樹，芳草萋萋鸚鵡洲。

 

簡介：面向對象-設計模式-創建型。

一、概述

何謂設計模式：

設計模式(Design Pattern)是一套被反復使用、多數人知曉的、經過分類的、代碼設計經驗的總結。

設計模式的好處&學習目的：

1、為了代碼可重用行、讓代碼更易被他人理解、保證代碼的可靠性、使代碼編寫真正實現工程化；

2、設計模式便於我們維護項目，增強系統的健壯性和可擴展性；

3、設計模式還可以鍛煉碼農的設計思維、升華代碼質量等。

二、創建型

單例模式、簡單工廠模式、工廠方法模式、抽象工廠模式、生成器模式、原型模式。

1、單例（Singleton）

單例模式參考鏈接：https://www.cnblogs.com/taojietaoge/p/10336439.html

Intent

確保一個類只有一個實例，並提供該實例的全局訪問點。

Class Diagram

使用一個私有構造函數、一個私有靜態變量以及一個公有靜態函數來實現。

私有構造函數保證了不能通過構造函數來創建對象實例，只能通過公有靜態函數返回唯一的私有靜態變量。

 

Implementation

Ⅰ 懶漢式-線程不安全

以下實現中，私有靜態變量 uniqueInstance 被延遲實例化，這樣做的好處是，如果沒有用到該類，那么就不會實例化 uniqueInstance，從而節約資源。

這個實現在多線程環境下是不安全的，如果多個線程能夠同時進入 if (uniqueInstance == null) ，並且此時 uniqueInstance 為 null，那么會有多個線程執行 uniqueInstance = new Singleton(); 語句，這將導致實例化多次 uniqueInstance。

// 懶漢模式-線程不安全
public class Singleton {  3 
    private static Singleton uniqueInstance;  5 
    private Singleton() {  7  }  8 
    public static Singleton getUniqueInstance() { 10         if (uniqueInstance == null) { 11             uniqueInstance = new Singleton(); 12  } 13         return uniqueInstance; 14  } 15 }

Ⅱ 餓漢式-線程安全

線程不安全問題主要是由於 uniqueInstance 被實例化多次，采取直接實例化 uniqueInstance 的方式就不會產生線程不安全問題。

但是直接實例化的方式也丟失了延遲實例化帶來的節約資源的好處。

// 餓漢模式
public class Singleton {  3 
    private static Singleton uniqueInstance = new Singleton();  5 
    private Singleton() {  7  }  8 
    public static Singleton getUniqueInstance() { 10         return uniqueInstance; 11  } 12 }

Ⅲ 懶漢式-線程安全

只需要對 getUniqueInstance() 方法加鎖，那么在一個時間點只能有一個線程能夠進入該方法，從而避免了實例化多次 uniqueInstance。

但是當一個線程進入該方法之后，其它試圖進入該方法的線程都必須等待，即使 uniqueInstance 已經被實例化了。這會讓線程阻塞時間過長，因此該方法有性能問題，不推薦使用。

// 懶漢模式-線程安全方法
public class Singleton {  3 
    private static Singleton uniqueInstance;  5 
    private Singleton() {  7  }  8 
    public static synchronized Singleton getUniqueInstance() {  // synchronized 加鎖
        if (uniqueInstance == null) { 11             uniqueInstance = new Singleton(); 12  } 13         return uniqueInstance; 14  } 15 }

Ⅳ 雙重校驗鎖-線程安全

uniqueInstance 只需要被實例化一次，之后就可以直接使用了。加鎖操作只需要對實例化那部分的代碼進行，只有當 uniqueInstance 沒有被實例化時，才需要進行加鎖。

雙重校驗鎖先判斷 uniqueInstance 是否已經被實例化，如果沒有被實例化，那么才對實例化語句進行加鎖。

// 雙重校驗鎖
public class Singleton {  3 
    private volatile static Singleton uniqueInstance;  // 使用 volatile 關鍵字修飾，禁止JVM 指令重排序

    private Singleton() {  7  }  8 
    public static Singleton getUniqueInstance() { 10         if (uniqueInstance == null) { 11             synchronized (Singleton.class) {  // synchronized 對實例化語句加鎖
                if (uniqueInstance == null) { 13                     uniqueInstance = new Singleton(); 14  } 15  } 16  } 17         return uniqueInstance; 18  } 19 }

考慮下面的實現，也就是只使用了一個 if 語句。在 uniqueInstance == null 的情況下，如果兩個線程都執行了 if 語句，那么兩個線程都會進入 if 語句塊內。雖然在 if 語句塊內有加鎖操作，但是兩個線程都會執行 uniqueInstance = new Singleton(); 這條語句，只是先后的問題，那么就會進行兩次實例化。因此必須使用雙重校驗鎖，也就是需要使用兩個 if 語句：第一個 if 語句用來避免 uniqueInstance 已經被實例化之后的加鎖操作，而第二個 if 語句進行了加鎖，所以只能有一個線程進入，就不會出現 uniqueInstance == null 時兩個線程同時進行實例化操作。

if (uniqueInstance == null) { 2     synchronized (Singleton.class) {  // 如果兩個線程都執行了 if 語句
        uniqueInstance = new Singleton(); 4  } 5 }

uniqueInstance 采用 volatile 關鍵字修飾也是很有必要的， uniqueInstance = new Singleton(); 這段代碼其實是分為三步執行：

1. 為 uniqueInstance 分配內存空間
2. 初始化 uniqueInstance
3. 將 uniqueInstance 指向分配的內存地址

但是由於 JVM 具有指令重排的特性，執行順序有可能變成 1>3>2。指令重排在單線程環境下不會出現問題，但是在多線程環境下會導致一個線程獲得還沒有初始化的實例。例如，線程 T₁ 執行了 1 和 3，此時 T₂ 調用 getUniqueInstance() 后發現 uniqueInstance 不為空，因此返回 uniqueInstance，但此時 uniqueInstance 還未被初始化。

使用 volatile 可以禁止 JVM 的指令重排，保證在多線程環境下也能正常運行。

volatile 如何保證禁止指令重排序參考鏈接：https://www.cnblogs.com/taojietaoge/p/10260888.html

Ⅴ 靜態內部類實現

當 Singleton 類被加載時，靜態內部類 SingletonHolder 沒有被加載進內存。只有當調用 getUniqueInstance() 方法從而觸發 SingletonHolder.INSTANCE 時 SingletonHolder 才會被加載，此時初始化 INSTANCE 實例，並且 JVM 能確保 INSTANCE 只被實例化一次。

這種方式不僅具有延遲初始化的好處，而且由 JVM 提供了對線程安全的支持。

Ⅵ 枚舉實現

1 使用枚舉類實現單例的好處：寫法簡單、默認線程安全、反序列化（反射、克隆）時也不會創建新的對象。

// 枚舉類實現單例
public enum Singleton {  3 
 INSTANCE;  5 
    private String objName;  7 

    public String getObjName() { 10         return objName; 11  } 12 

    public void setObjName(String objName) { 15         this.objName = objName; 16  } 17 

    public static void main(String[] args) { 20 
        // 單例測試
        Singleton firstSingleton = Singleton.INSTANCE; 23         firstSingleton.setObjName("firstName"); 24  System.out.println(firstSingleton.getObjName()); 25         Singleton secondSingleton = Singleton.INSTANCE; 26         secondSingleton.setObjName("secondName"); 27  System.out.println(firstSingleton.getObjName()); 28  System.out.println(secondSingleton.getObjName()); 29 
        // 反射獲取實例測試
        try { 32             Singleton[] enumConstants = Singleton.class.getEnumConstants(); 33             for (Singleton enumConstant : enumConstants) { 34  System.out.println(enumConstant.getObjName()); 35  } 36         } catch (Exception e) { 37  e.printStackTrace(); 38  } 39  } 40 }

輸出： 2 firstName 3 secondName 4 secondName 5 secondName

該實現可以防止反射攻擊。在其它實現中，通過 setAccessible() 方法可以將私有構造函數的訪問級別設置為 public，然后調用構造函數從而實例化對象，如果要防止這種攻擊，需要在構造函數中添加防止多次實例化的代碼。該實現是由 JVM 保證只會實例化一次，因此不會出現上述的反射攻擊。

該實現在多次序列化和序列化之后，不會得到多個實例。而其它實現需要使用 transient 修飾所有字段，並且實現序列化和反序列化的方法。

單例小結

最佳的單例實現模式就是枚舉模式。利用枚舉的特性，讓JVM 來幫我們保證線程安全和單一實例。

2、簡單工廠（Simple Factory）

Intent

在創建一個對象時不向客戶暴露內部細節，並提供一個創建對象的通用接口。

Class Diagram

簡單工廠把實例化的操作單獨放到一個類中，這個類就成為簡單工廠類，讓簡單工廠類來決定應該用哪個具體子類來實例化。

這樣做能把客戶類和具體子類的實現解耦，客戶類不再需要知道有哪些子類以及應當實例化哪個子類。客戶類往往有多個，如果不使用簡單工廠，那么所有的客戶類都要知道所有子類的細節。而且一旦子類發生改變，例如增加子類，那么所有的客戶類都要進行修改。

Implementation

public interface Product { 2 }

public class ConcreteProduct implements Product { 2 }

public class ConcreteProduct1 implements Product { 2 }

public class ConcreteProduct2 implements Product { }

以下的 Client 類包含了實例化的代碼，這是一種錯誤的實現。如果在客戶類中存在這種實例化代碼，就需要考慮將代碼放到簡單工廠中。

// 錯誤實現
public class Client {  3 
    public static void main(String[] args) {  5         int type = 1;  6  Product product;  7         if (type == 1) {  8             product = new ConcreteProduct1();  9         } else if (type == 2) { 10             product = new ConcreteProduct2(); 11         } else { 12             product = new ConcreteProduct(); 13  } 14         // do what u want to do
 } 16 }

以下的 SimpleFactory 是簡單工廠實現，它被所有需要進行實例化的客戶類調用。

public class SimpleFactory {  2 
    public Product createProduct(int type) {  4         if (type == 1) {  // 也可以用switch 當對象類型太多
            return new ConcreteProduct1();  6         } else if (type == 2) {  7             return new ConcreteProduct2();  8  }  9         return new ConcreteProduct(); 10  } 11 }

public class Client { 2     public static void main(String[] args) { 3         SimpleFactory simpleFactory = new SimpleFactory(); 4         // 只需要傳一個類型參數，實例化具體對象 
        Product product1 = simpleFactory.createProduct(1); 6         Product product2 = simpleFactory.createProduct(2); 7  } 8 }

3、工廠方法（Factory Method）

Intent

定義了一個創建對象的接口，但由子類決定要實例化哪個類。工廠方法把實例化操作推遲到子類。

Class Diagram

在簡單工廠中，創建對象的是另一個類，而在工廠方法中，是由子類來創建對象。

下圖中，Factory 有一個 doSomething() 方法，這個方法需要用到一個產品對象，這個產品對象由 factoryMethod() 方法創建。該方法是抽象的，需要由子類去實現。

 

Implementation

public abstract class Factory { 2     abstract public Product factoryMethod();  // 抽象方法，由子類去實現
    public void doSomething() { 4         Product product = factoryMethod(); 5         // do something with the product
 } 7 }

public class ConcreteFactory extends Factory { 2     public Product factoryMethod() { 3         return new ConcreteProduct(); 4  } 5 }

public class ConcreteFactory1 extends Factory { 2     public Product factoryMethod() { 3         return new ConcreteProduct1(); 4  } 5 }

public class ConcreteFactory2 extends Factory { 2     public Product factoryMethod() { 3         return new ConcreteProduct2();  // 由子類來創建對象
 } 5 }

4、抽象工廠（Abstract Factory）

Intent

提供一個接口，用於創建 相關的對象家族 。

Class Diagram

抽象工廠模式創建的是對象家族，也就是很多對象而不是一個對象，並且這些對象是相關的，也就是說必須一起創建出來。而工廠方法模式只是用於創建一個對象，這和抽象工廠模式有很大不同。

抽象工廠模式用到了工廠方法模式來創建單一對象，AbstractFactory 中的 createProductA() 和 createProductB() 方法都是讓子類來實現，這兩個方法單獨來看就是在創建一個對象，這符合工廠方法模式的定義。

至於創建對象的家族這一概念是在 Client 體現，Client 要通過 AbstractFactory 同時調用兩個方法來創建出兩個對象，在這里這兩個對象就有很大的相關性，Client 需要同時創建出這兩個對象。

從高層次來看，抽象工廠使用了組合，即 Cilent 組合了 AbstractFactory，而工廠方法模式使用了繼承。

 

Implementation

public class AbstractProductA { 2 }

public class AbstractProductB { 2 }

public class ProductA1 extends AbstractProductA { 2 }

public class ProductA2 extends AbstractProductA { 2 }

public class ProductB1 extends AbstractProductB { 2 }

public class ProductB2 extends AbstractProductB { 2 }

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

public class ConcreteFactory1 extends AbstractFactory { 2  AbstractProductA createProductA() { 3         return new ProductA1(); 4  } 5 
 AbstractProductB createProductB() { 7         return new ProductB1(); 8  } 9 }

public class ConcreteFactory2 extends AbstractFactory { 2  AbstractProductA createProductA() { 3         return new ProductA2(); 4  } 5 
 AbstractProductB createProductB() { 7         return new ProductB2(); 8  } 9 }

public class Client { 2     public static void main(String[] args) { 3         AbstractFactory abstractFactory = new ConcreteFactory1(); 4         AbstractProductA productA = abstractFactory.createProductA(); 5         AbstractProductB productB = abstractFactory.createProductB(); 6         // do something with productA and productB
 } 8 }

6、生成器（Builder）

Intent

封裝一個對象的構造過程，並允許按步驟構造。

Class Diagram

 

Implementation

以下是一個簡易的 StringBuilder 實現，參考了 JDK 1.8 源碼。

public class AbstractStringBuilder {  2     protected char[] value;  3 
    protected int count;  5 
    public AbstractStringBuilder(int capacity) {  7         count = 0;  8         value = new char[capacity];  9  } 10 
    public AbstractStringBuilder append(char c) { 12         ensureCapacityInternal(count + 1); 13         value[count++] = c; 14         return this; 15  } 16 
    private void ensureCapacityInternal(int minimumCapacity) { 18         // overflow-conscious code
        if (minimumCapacity - value.length > 0) 20  expandCapacity(minimumCapacity); 21  } 22 
    void expandCapacity(int minimumCapacity) { 24         int newCapacity = value.length * 2 + 2; 25         if (newCapacity - minimumCapacity < 0) 26             newCapacity = minimumCapacity; 27         if (newCapacity < 0) { 28             if (minimumCapacity < 0) // overflow
                throw new OutOfMemoryError(); 30             newCapacity = Integer.MAX_VALUE; 31  } 32         value = Arrays.copyOf(value, newCapacity); 33  } 34 }

public class StringBuilder extends AbstractStringBuilder {  2     public StringBuilder() {  3         super(16);  4  }  5 
 @Override  7     public String toString() {  8         // Create a copy, don't share the array
        return new String(value, 0, count); 10  } 11 }

public class Client {  2     public static void main(String[] args) {  3         StringBuilder sb = new StringBuilder();  4         final int count = 26;  5         for (int i = 0; i < count; i++) {  6             sb.append((char) ('a' + i));  7  }  8  System.out.println(sb.toString());  9  } 10 }

abcdefghijklmnopqrstuvwxyz

6、原型模式（Prototype）

Intent

使用原型實例指定要創建對象的類型，通過復制這個原型來創建新對象。

Class Diagram

Implementation

public abstract class Prototype { 2     abstract Prototype myClone(); 3 }

public class ConcretePrototype extends Prototype {  2 
    private String filed;  4 
    public ConcretePrototype(String filed) {  6         this.filed = filed;  7  }  8 
 @Override 10  Prototype myClone() { 11         return new ConcretePrototype(filed); 12  } 13 
 @Override 15     public String toString() { 16         return filed; 17  } 18 }

public class Client { 2     public static void main(String[] args) { 3         Prototype prototype = new ConcretePrototype("abc"); 4         Prototype clone = prototype.myClone(); 5         System.out.println(clone.toString());  // abc
 } 7 }

 

 

 

 

晴川歷歷漢陽樹

　　　　　　芳草萋萋鸚鵡洲