1、單例模式

單例模式（Singleton Pattern）是 Java 中最簡單的設(shè)計模式之一。這種類型的設(shè)計模式屬于創(chuàng)建型模式，它提供了一種創(chuàng)建對象的最佳方式。

這種模式涉及到一個單一的類，該類負責(zé)創(chuàng)建自己的對象，同時確保只有單個對象被創(chuàng)建。這個類提供了一種訪問其唯一的對象的方式，可以直接訪問，不需要實例化該類的對象。

單例模式是一種創(chuàng)建型設(shè)計模式，它確保一個類只有一個實例，并提供了一個全局訪問點來訪問該實例。

• 1、單例類只能有一個實例。
• 2、單例類必須自己創(chuàng)建自己的唯一實例。
• 3、單例類必須給所有其他對象提供這一實例。

1.1、應(yīng)用實例

• 一個班級只有一個班主任。
• Windows 在多進程多線程環(huán)境下操作文件時，避免多個進程或線程同時操作一個文件，需要通過唯一實例進行處理。
• 設(shè)備管理器設(shè)計為單例模式，例如電腦有兩臺打印機，避免同時打印同一個文件。

1.2、注意事項

• 線程安全：getInstance() 方法中需要使用同步鎖 synchronized (Singleton.class) 防止多線程同時進入造成實例被多次創(chuàng)建。
• 延遲初始化：實例在第一次調(diào)用 getInstance() 方法時創(chuàng)建。
• 序列化和反序列化：重寫 readResolve 方法以確保反序列化時不會創(chuàng)建新的實例。
• 反射攻擊：在構(gòu)造函數(shù)中添加防護代碼，防止通過反射創(chuàng)建新實例。
• 類加載器問題：注意復(fù)雜類加載環(huán)境可能導(dǎo)致的多個實例問題。

1.3、單例模式的幾種實現(xiàn)方式

單例模式的實現(xiàn)有多種方式，如下所示：

1、懶漢式，線程不安全

• 是否 Lazy 初始化：是
• 是否多線程安全：否
• 實現(xiàn)難度：易

描述：這種方式是最基本的實現(xiàn)方式，這種實現(xiàn)最大的問題就是不支持多線程。因為沒有加鎖 synchronized，所以嚴格意義上它并不算單例模式。
這種方式 lazy loading 很明顯，不要求線程安全，在多線程不能正常工作。

實例

public class Singleton {  private static Singleton instance;  private Singleton (){}  public static Singleton getInstance() {  if (instance == null) {  instance = new Singleton();  }  return instance;  }  
}

2、懶漢式，線程安全

• 是否 Lazy 初始化：是
• 是否多線程安全：是
• 實現(xiàn)難度：易

描述：這種方式具備很好的 lazy loading，能夠在多線程中很好的工作，但是，效率很低，99% 情況下不需要同步。
優(yōu)點：第一次調(diào)用才初始化，避免內(nèi)存浪費。
缺點：必須加鎖 synchronized 才能保證單例，但加鎖會影響效率。
getInstance() 的性能對應(yīng)用程序不是很關(guān)鍵（該方法使用不太頻繁）。

實例

public class Singleton {  private static Singleton instance;  private Singleton (){}  public static synchronized Singleton getInstance() {  if (instance == null) {  instance = new Singleton();  }  return instance;  }  
}

3、餓漢式

• 是否 Lazy 初始化：否
• 是否多線程安全：是
• 實現(xiàn)難度：易

描述：這種方式比較常用，但容易產(chǎn)生垃圾對象。
優(yōu)點：沒有加鎖，執(zhí)行效率會提高。
缺點：類加載時就初始化，浪費內(nèi)存。
它基于 classloader 機制避免了多線程的同步問題，不過，instance 在類裝載時就實例化，雖然導(dǎo)致類裝載的原因有很多種，在單例模式中大多數(shù)都是調(diào)用 getInstance 方法， 但是也不能確定有其他的方式（或者其他的靜態(tài)方法）導(dǎo)致類裝載，這時候初始化 instance 顯然沒有達到 lazy loading 的效果。

實例

public class Singleton {  private static Singleton instance = new Singleton();  private Singleton (){}  public static Singleton getInstance() {  return instance;  }  
}

4、雙檢鎖/雙重校驗鎖（DCL，即 double-checked locking）
JDK 版本：JDK1.5 起

• 是否 Lazy 初始化：是
• 是否多線程安全：是
• 實現(xiàn)難度：較復(fù)雜

描述：這種方式采用雙鎖機制，安全且在多線程情況下能保持高性能。
getInstance() 的性能對應(yīng)用程序很關(guān)鍵。

實例

public class Singleton {  private volatile static Singleton singleton;  private Singleton (){}  public static Singleton getSingleton() {  if (singleton == null) {  synchronized (Singleton.class) {  if (singleton == null) {  singleton = new Singleton();  }  }  }  return singleton;  }  
}

5、登記式/靜態(tài)內(nèi)部類

• 是否 Lazy 初始化：是
• 是否多線程安全：是
• 實現(xiàn)難度：一般

描述：這種方式能達到雙檢鎖方式一樣的功效，但實現(xiàn)更簡單。對靜態(tài)域使用延遲初始化，應(yīng)使用這種方式而不是雙檢鎖方式。這種方式只適用于靜態(tài)域的情況，雙檢鎖方式可在實例域需要延遲初始化時使用。
這種方式同樣利用了 classloader 機制來保證初始化 instance 時只有一個線程，它跟第 3 種方式不同的是：第 3 種方式只要 Singleton 類被裝載了，那么 instance 就會被實例化（沒有達到 lazy loading 效果），而這種方式是 Singleton 類被裝載了，instance 不一定被初始化。因為 SingletonHolder 類沒有被主動使用，只有通過顯式調(diào)用 getInstance 方法時，才會顯式裝載 SingletonHolder 類，從而實例化 instance。想象一下，如果實例化 instance 很消耗資源，所以想讓它延遲加載，另外一方面，又不希望在 Singleton 類加載時就實例化，因為不能確保 Singleton 類還可能在其他的地方被主動使用從而被加載，那么這個時候?qū)嵗?instance 顯然是不合適的。這個時候，這種方式相比第 3 種方式就顯得很合理。

實例

public class Singleton {  private static class SingletonHolder {  private static final Singleton INSTANCE = new Singleton();  }  private Singleton (){}  public static final Singleton getInstance() {  return SingletonHolder.INSTANCE;  }  
}

6、枚舉
JDK 版本：JDK1.5 起

• 是否 Lazy 初始化：否
• 是否多線程安全：是
• 實現(xiàn)難度：易

描述：這種實現(xiàn)方式還沒有被廣泛采用，但這是實現(xiàn)單例模式的最佳方法。它更簡潔，自動支持序列化機制，絕對防止多次實例化。
這種方式是 Effective Java 作者 Josh Bloch 提倡的方式，它不僅能避免多線程同步問題，而且還自動支持序列化機制，防止反序列化重新創(chuàng)建新的對象，絕對防止多次實例化。不過，由于 JDK1.5 之后才加入 enum 特性，用這種方式寫不免讓人感覺生疏，在實際工作中，也很少用。
不能通過 reflection attack 來調(diào)用私有構(gòu)造方法。

實例

public enum Singleton {  INSTANCE;  public void whateverMethod() {  }  
}

經(jīng)驗之談：一般情況下，不建議使用第 1 種和第 2 種懶漢方式，建議使用第 3 種餓漢方式。只有在要明確實現(xiàn) lazy loading 效果時，才會使用第 5 種登記方式。如果涉及到反序列化創(chuàng)建對象時，可以嘗試使用第 6 種枚舉方式。如果有其他特殊的需求，可以考慮使用第 4 種雙檢鎖方式。

2、建造者模式

建造者模式是一種創(chuàng)建型設(shè)計模式，它允許你創(chuàng)建復(fù)雜對象的步驟與表示方式相分離。

建造者模式是一種創(chuàng)建型設(shè)計模式，它的主要目的是將一個復(fù)雜對象的構(gòu)建過程與其表示相分離，從而可以創(chuàng)建具有不同表示形式的對象。

將變與不變的部分分離開。

與工廠模式的區(qū)別是：建造者模式更加關(guān)注于零件裝配的順序。

2.1、結(jié)構(gòu)

建造者模式包含以下幾個主要角色：

• 產(chǎn)品（Product）：要構(gòu)建的復(fù)雜對象。產(chǎn)品類通常包含多個部分或?qū)傩浴?/li>
• 抽象建造者（Builder）：定義了構(gòu)建產(chǎn)品的抽象接口，包括構(gòu)建產(chǎn)品的各個部分的方法。
• 具體建造者（Concrete Builder）：實現(xiàn)抽象建造者接口，具體確定如何構(gòu)建產(chǎn)品的各個部分，并負責(zé)返回最終構(gòu)建的產(chǎn)品。
• 指導(dǎo)者（Director）：負責(zé)調(diào)用建造者的方法來構(gòu)建產(chǎn)品，指導(dǎo)者并不了解具體的構(gòu)建過程，只關(guān)心產(chǎn)品的構(gòu)建順序和方式。

2.2、應(yīng)用實例

去肯德基，漢堡、可樂、薯條、炸雞翅等是不變的，而其組合是經(jīng)常變化的，生成出不同的"套餐"。
Java 中的 StringBuilder。

3、原型模式

原型模式（Prototype Pattern）是用于創(chuàng)建重復(fù)的對象，同時又能保證性能。這種類型的設(shè)計模式屬于創(chuàng)建型模式，它提供了一種創(chuàng)建對象的最佳方式之一。

這種模式是實現(xiàn)了一個原型接口，該接口用于創(chuàng)建當(dāng)前對象的克隆。當(dāng)直接創(chuàng)建對象的代價比較大時，則采用這種模式。例如，一個對象需要在一個高代價的數(shù)據(jù)庫操作之后被創(chuàng)建。我們可以緩存該對象，在下一個請求時返回它的克隆，在需要的時候更新數(shù)據(jù)庫，以此來減少數(shù)據(jù)庫調(diào)用。
優(yōu)點

• 性能提高
• 避免構(gòu)造函數(shù)的約束

缺點

• 配備克隆方法需要全面考慮類的功能，對已有類可能較難實現(xiàn)，特別是處理不支持串行化的間接對象或含有循環(huán)結(jié)構(gòu)的引用時。
• 必須實現(xiàn) Cloneable 接口。

4、適配器模式

適配器模式（Adapter Pattern）充當(dāng)兩個不兼容接口之間的橋梁，屬于結(jié)構(gòu)型設(shè)計模式。它通過一個中間件（適配器）將一個類的接口轉(zhuǎn)換成客戶期望的另一個接口，使原本不能一起工作的類能夠協(xié)同工作。

這種模式涉及到一個單一的類，該類負責(zé)加入獨立的或不兼容的接口功能。舉個真實的例子，讀卡器是作為內(nèi)存卡和筆記本之間的適配器。您將內(nèi)存卡插入讀卡器，再將讀卡器插入筆記本，這樣就可以通過筆記本來讀取內(nèi)存卡。

假設(shè)有一個音頻播放器，它只能播放 MP3 文件?，F(xiàn)在，我們需要播放 VLC 和 MP4 文件，可以通過創(chuàng)建一個適配器來實現(xiàn)：

• 目標接口：定義一個可以播放多種格式文件的音頻播放器接口。
• 適配者類：現(xiàn)有的音頻播放器，只能播放 MP3 文件。
• 適配器類：創(chuàng)建一個新的類，實現(xiàn)目標接口，并在內(nèi)部使用適配者類來播放 MP3 文件，同時添加對 VLC 和 MP4 文件的支持。

4.1、實現(xiàn)方式

繼承或依賴：推薦使用依賴關(guān)系，而不是繼承，以保持靈活性。

4.2、優(yōu)點

• 促進了類之間的協(xié)同工作，即使它們沒有直接的關(guān)聯(lián)。
• 提高了類的復(fù)用性。
• 增加了類的透明度。
• 提供了良好的靈活性。

4.3、缺點

過度使用適配器可能導(dǎo)致系統(tǒng)結(jié)構(gòu)混亂，難以理解和維護。
在Java中，由于只能繼承一個類，因此只能適配一個類，且目標類必須是抽象的。

5、橋接模式

橋接（Bridge）是用于把抽象化與實現(xiàn)化解耦，使得二者可以獨立變化。這種類型的設(shè)計模式屬于結(jié)構(gòu)型模式，它通過提供抽象化和實現(xiàn)化之間的橋接結(jié)構(gòu)，來實現(xiàn)二者的解耦。

這種模式涉及到一個作為橋接的接口，使得實體類的功能獨立于接口實現(xiàn)類，這兩種類型的類可被結(jié)構(gòu)化改變而互不影響。

橋接模式的目的是將抽象與實現(xiàn)分離，使它們可以獨立地變化，該模式通過將一個對象的抽象部分與它的實現(xiàn)部分分離，使它們可以獨立地改變。它通過組合的方式，而不是繼承的方式，將抽象和實現(xiàn)的部分連接起來。

5.1、主要解決的問題

避免使用繼承導(dǎo)致的類爆炸問題，提供更靈活的擴展方式。

6、過濾器模式

過濾器模式（Filter Pattern）或標準模式（Criteria Pattern）是一種設(shè)計模式，這種模式允許開發(fā)人員使用不同的標準來過濾一組對象，通過邏輯運算以解耦的方式把它們連接起來。這種類型的設(shè)計模式屬于結(jié)構(gòu)型模式，它結(jié)合多個標準來獲得單一標準。

用于將對象的篩選過程封裝起來，允許使用不同的篩選標準動態(tài)地篩選對象。

6.1、使用場景

• 當(dāng)對象集合需要根據(jù)不同的標準進行篩選時。
• 當(dāng)篩選邏輯可能變化，或者需要動態(tài)地組合多個篩選條件時。

7、組合模式

組合模式（Composite Pattern），又叫部分整體模式，是用于把一組相似的對象當(dāng)作一個單一的對象。組合模式依據(jù)樹形結(jié)構(gòu)來組合對象，用來表示部分以及整體層次。這種類型的設(shè)計模式屬于結(jié)構(gòu)型模式，它創(chuàng)建了對象組的樹形結(jié)構(gòu)。

這種模式創(chuàng)建了一個包含自己對象組的類。該類提供了修改相同對象組的方式。

7.1、實現(xiàn)方式

• 統(tǒng)一接口：定義一個接口，所有對象（樹枝和葉子）都實現(xiàn)這個接口。
• 組合結(jié)構(gòu)：樹枝對象包含一個接口的引用列表，這些引用可以是葉子或樹枝。

案例：
我們有一個類 Employee，該類被當(dāng)作組合模型類。CompositePatternDemo 類使用 Employee 類來添加部門層次結(jié)構(gòu)，并打印所有員工。

步驟 1
創(chuàng)建 Employee 類，該類帶有 Employee 對象的列表。

Employee.java
import java.util.ArrayList;
import java.util.List;public class Employee {private String name;private String dept;private int salary;private List<Employee> subordinates;//構(gòu)造函數(shù)public Employee(String name,String dept, int sal) {this.name = name;this.dept = dept;this.salary = sal;subordinates = new ArrayList<Employee>();}public void add(Employee e) {subordinates.add(e);}public void remove(Employee e) {subordinates.remove(e);}public List<Employee> getSubordinates(){return subordinates;}public String toString(){return ("Employee :[ Name : "+ name +", dept : "+ dept + ", salary :"+ salary+" ]");}   
}

步驟 2
使用 Employee 類來創(chuàng)建和打印員工的層次結(jié)構(gòu)。

CompositePatternDemo.java
public class CompositePatternDemo {public static void main(String[] args) {Employee CEO = new Employee("John","CEO", 30000);Employee headSales = new Employee("Robert","Head Sales", 20000);Employee headMarketing = new Employee("Michel","Head Marketing", 20000);Employee clerk1 = new Employee("Laura","Marketing", 10000);Employee clerk2 = new Employee("Bob","Marketing", 10000);Employee salesExecutive1 = new Employee("Richard","Sales", 10000);Employee salesExecutive2 = new Employee("Rob","Sales", 10000);CEO.add(headSales);CEO.add(headMarketing);headSales.add(salesExecutive1);headSales.add(salesExecutive2);headMarketing.add(clerk1);headMarketing.add(clerk2);//打印該組織的所有員工System.out.println(CEO); for (Employee headEmployee : CEO.getSubordinates()) {System.out.println(headEmployee);for (Employee employee : headEmployee.getSubordinates()) {System.out.println(employee);}}        }
}

步驟 3
執(zhí)行程序，輸出結(jié)果為：

Employee :[ Name : John, dept : CEO, salary :30000 ]
Employee :[ Name : Robert, dept : Head Sales, salary :20000 ]
Employee :[ Name : Richard, dept : Sales, salary :10000 ]
Employee :[ Name : Rob, dept : Sales, salary :10000 ]
Employee :[ Name : Michel, dept : Head Marketing, salary :20000 ]
Employee :[ Name : Laura, dept : Marketing, salary :10000 ]
Employee :[ Name : Bob, dept : Marketing, salary :10000 ]