> 作者：幻好
> 
>來源： [恆生LIGHT雲社群](https://developer.hs.net/thread/1335 "恆生LIGHT雲社群")

## 設計模式簡介

- 設計模式（Design pattern）代表了最佳的實踐，通常被有經驗的物件導向的軟體開發人員所採用。設計模式是軟體開發人員在軟體開發過程中面臨的一般問題的解決方案。這些解決方案是眾多軟體開發人員經過相當長的一段時間的試驗和錯誤總結出來的。
- 設計模式分為**23 種**經典的模式，根據用途我們又可以分為三大類。分別是建立型模式、結構型模式和行為型模式。
- 建立型模式：
  - 建立型模式提供了一種在建立物件的同時隱藏建立邏輯的方式，而不是使用 new 運算子直接例項化物件。這使得程式在判斷針對某個給定例項需要建立哪些物件時更加靈活。
- 結構型模式：
  - 結構型模式旨在透過改變程式碼結構來達到解耦的目的，使得我們的程式碼容易維護和擴充套件。
- 行為型模式：
  - 行為型模式關注的是各個類之間的相互作用，將職責劃分清楚，使得我們的程式碼更加地清晰。

![the-relationship-between-design-patterns.jpg](https://developer.hs.net/storage/attachments/2021/08/29/0OZqnp6i3elq04W1CEF6vLmOFOMOBkFbqVXu8bK4_thumb.jpg "3033")

## 設計模式的六大原則

### 1. 開閉原則（Open Close Principle）

開閉原則的意思是：**對擴充套件開放，對修改關閉**。在程式需要進行擴充的時候，不能去修改原有的程式碼，實現一個熱插拔的效果。簡言之，是為了使程式的擴充套件性好，易於維護和升級。想要達到這樣的效果，我們需要使用介面和抽象類，後面的具體設計中我們會提到這點。

### 2. 里氏代換原則（Liskov Substitution Principle）

里氏代換原則是物件導向設計的基本原則之一。 里氏代換原則中說，任何基類可以出現的地方，子類一定可以出現。LSP 是繼承複用的基石，只有當派生類可以替換掉基類，且軟體單位的功能不受到影響時，基類才能真正被複用，而派生類也能夠在基類的基礎上增加新的行為。里氏代換原則是對開閉原則的補充。實現開閉原則的關鍵步驟就是抽象化，而基類與子類的繼承關係就是抽象化的具體實現，所以里氏代換原則是對實現抽象化的具體步驟的規範。

### 3. 依賴倒轉原則（Dependence Inversion Principle）

這個原則是開閉原則的基礎，具體內容：針對介面程式設計，依賴於抽象而不依賴於具體。

### 4. 介面隔離原則（Interface Segregation Principle）

這個原則的意思是：使用多個隔離的介面，比使用單個介面要好。它還有另外一個意思是：降低類之間的耦合度。由此可見，其實設計模式就是從大型軟體架構出發、便於升級和維護的軟體設計思想，它強調降低依賴，降低耦合。

### 5. 迪米特法則，又稱最少知道原則（Demeter Principle）

最少知道原則是指：一個實體應當儘量少地與其他實體之間發生相互作用，使得系統功能模組相對獨立。

### 6. 合成複用原則（Composite Reuse Principle）

合成複用原則是指：儘量使用合成 / 聚合的方式，而不是使用繼承。

## 常用需掌握的設計模式

### 1. 工廠模式（Factory Pattern）

#### 基本概念

工廠模式（Factory Pattern）最常用的設計模式之一。這種型別的設計模式屬於建立型模式，它提供了一種建立物件的最佳方式。
在工廠模式中，我們在建立物件時不會對客戶端暴露建立邏輯，並且是透過使用一個共同的介面來指向新建立的物件。

**意圖：**定義一個建立物件的介面，讓其子類自己決定例項化哪一個工廠類，工廠模式使其建立過程延遲到子類進行。

**主要解決：**主要解決介面選擇的問題。

**何時使用：**我們明確地計劃不同條件下建立不同例項時。

**如何解決：**讓其子類實現工廠介面，返回的也是一個抽象的產品。

#### 程式碼示例

```java
public interface Shape {
    void draw();
}

public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("畫個圓形");
    }
}

public class CircleFactory implements Shape {
    @Override
    public void draw() {
        System.out.println("使用簡單工廠模式建立圓");
    }

}

public static void main(String[] args) {
    Shape shape = new CircleFactory();
    shape.draw();
}
```

### 2. 單例模式（Singleton Pattern）

#### 基本概念

單例模式（Singleton Pattern）是 Java 中最簡單的設計模式之一。這種型別的設計模式屬於建立型模式，它提供了一種建立物件的最佳方式。

這種模式涉及到一個單一的類，該類負責建立自己的物件，同時確保只有單個物件被建立。這個類提供了一種訪問其唯一的物件的方式，可以直接訪問，不需要例項化該類的物件。

單例模式的特點：

- 單例類只能有一個例項。
- 單例類必須自己建立自己的唯一例項。
- 單例類必須給所有其他物件提供這一例項。

**意圖：**保證一個類僅有一個例項，並提供一個訪問它的全域性訪問點。

**主要解決：**一個全域性使用的類頻繁地建立與銷燬。

**何時使用：**當您想控制例項數目，節省系統資源的時候。

**如何解決：**判斷系統是否已經有這個單例，如果有則返回，如果沒有則建立。

#### 程式碼示例

```java
// 必須掌握的單例模式的寫法
/**
  * 懶漢非執行緒安全
  */
public static class LazyNosafe{
    private static LazyNosafe lazyNosafe;
    public static LazyNosafe getLazyNosafe(){
        lazyNosafe = new LazyNosafe();
        return lazyNosafe;
    }
}

/**
  * 懶漢執行緒安全
  */
public static class LazySafe{
    private static LazySafe lazySafe;
    synchronized public static LazySafe getLazyNosafe(){
        lazySafe = new LazySafe();
        return lazySafe;
    }
}

/**
  * 餓漢模式
  */
public static class HungerSingle{
    private static HungerSingle hungerSingle = new HungerSingle();
    public static HungerSingle getHungerSingle(){
        return hungerSingle;
    }
}

/**
  * 餓漢模式變種
  */
public static class HungerSingleOther{
    private static HungerSingleOther hungerSingleOther;
    static {
        hungerSingleOther = new HungerSingleOther();
    }
    public static HungerSingleOther getHungerSingleOther(){
        return hungerSingleOther;
    }
}

/**
  * DCL 雙重檢查
  */
public static class DclSingleton{
    private static DclSingleton dclSingleton;
    public static DclSingleton getDclSingleton(){
        if(dclSingleton != null){
            synchronized (dclSingleton){
                if(dclSingleton != null){
                    dclSingleton = new DclSingleton();
                }
            }
        }
        return dclSingleton;
    }
}

/**
  * DCL 雙重檢查，最佳化版
  */
public static class DclSingletonOther{
    // 透過 volatile 禁止指令重排，保證按順序載入
    private static volatile DclSingleton dclSingleton;
    public static DclSingleton getDclSingleton(){
        if(dclSingleton != null){
            synchronized (dclSingleton){
                if(dclSingleton != null){
                    dclSingleton = new DclSingleton();
                }
            }
        }
        return dclSingleton;
    }
}

/**
  * 靜態內部類
  * 利用了 classloader 機制來保證初始化 instance 時只有一個執行緒
  */
public static class StaticClassSingleton{
    private static class StaticSingleton{
        public static final StaticSingleton staticSingleton = new StaticSingleton();
    }
    public static StaticSingleton getStaticSingleton(){
        return StaticSingleton.staticSingleton;
    }
}

/**
  * 列舉的方式
  */
public enum EnumSingleton{
    INSTANCE;
}
```

### 3. 代理模式（Proxy Pattern）

#### 基本概念

代理模式（Proxy Pattern）中，一個類代表另一個類的功能。這種型別的設計模式屬於結構型模式。
在代理模式中，我們建立具有現有物件的物件，以便向外界提供功能介面。

**意圖：**為其他物件提供一種代理以控制對這個物件的訪問。

**主要解決：**在直接訪問物件時帶來的問題，比如說：要訪問的物件在遠端的機器上。在物件導向系統中，有些物件由於某些原因（比如物件建立開銷很大，或者某些操作需要安全控制，或者需要程式外的訪問），直接訪問會給使用者或者系統結構帶來很多麻煩，我們可以在訪問此物件時加上一個對此物件的訪問層。

**何時使用：**想在訪問一個類時做一些控制。

**如何解決：**增加中間層。

#### 程式碼示例

```java
public interface Cat {
    void sayMiao();

void run();
}

public class BlackCat implements Cat {
    @Override
    public void sayMiao() {
        System.out.println("Black miao");
    }

@Override
    public void run() {
        System.out.println("Black run");
    }
}

public class PoxyCat implements Cat {
    private BlackCat blackCat = new BlackCat();
  
    @Override
    public void sayMiao() {
        // Before todo
        blackCat.sayMiao();
        // After todo
    }

@Override
    public void run() {
        // Before todo
        blackCat.run();
        // After todo
    }
}
```

### 4. 介面卡模式（Adapter Pattern）

#### 基本概念

- 介面卡模式（Adapter Pattern）是作為兩個不相容的介面之間的橋樑。這種型別的設計模式屬於結構型模式，它結合了兩個獨立介面的功能。
- 這種模式涉及到一個單一的類，該類負責加入獨立的或不相容的介面功能。舉個真實的例子，讀卡器是作為記憶體卡和筆記本之間的介面卡。您將記憶體卡插入讀卡器，再將讀卡器插入筆記本，這樣就可以透過筆記本來讀取記憶體卡。

**意圖：**將一個類的介面轉換成客戶希望的另外一個介面。介面卡模式使得原本由於介面不相容而不能一起工作的那些類可以一起工作。

**主要解決：**主要解決在軟體系統中，常常要將一些"現存的物件"放到新的環境中，而新環境要求的介面是現物件不能滿足的。

**何時使用：** 1、系統需要使用現有的類，而此類的介面不符合系統的需要。 2、想要建立一個可以重複使用的類，用於與一些彼此之間沒有太大關聯的一些類，包括一些可能在將來引進的類一起工作，這些源類不一定有一致的介面。 3、透過介面轉換，將一個類插入另一個類系中。（比如老虎和飛禽，現在多了一個飛虎，在不增加實體的需求下，增加一個介面卡，在裡面包容一個虎物件，實現飛的介面。）

**如何解決：**繼承或依賴（推薦）。

#### 程式碼示例

```java
public interface Cat{
    void sayMiao();
    void run();
}

public class animalsAdapter implements Cat{
    @Override
    public void sayMiao() { }
    @Override
    public void run() { }
}

public class Dog extends animalsAdapter{
    @Override
    public void run() {
        System.out.println("dog run");
    }
}
```

### 5. 外觀模式（Facade Pattern）

#### 基本概念

- 外觀模式（Facade Pattern）隱藏系統的複雜性，並向客戶端提供了一個客戶端可以訪問系統的介面。這種型別的設計模式屬於結構型模式，它向現有的系統新增一個介面，來隱藏系統的複雜性。
- 這種模式涉及到一個單一的類，該類提供了客戶端請求的簡化方法和對現有系統類方法的委託呼叫。

**意圖：**為子系統中的一組介面提供一個一致的介面，外觀模式定義了一個高層介面，這個介面使得這一子系統更加容易使用。

**主要解決：**降低訪問複雜系統的內部子系統時的複雜度，簡化客戶端之間的介面。

**何時使用：** 1、客戶端不需要知道系統內部的複雜聯絡，整個系統只需提供一個"接待員"即可。 2、定義系統的入口。

**如何解決：**客戶端不與系統耦合，外觀類與系統耦合。

#### 程式碼示例

```java
public interface Shape {
    void draw();
}

public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Circle::draw()");
    }
}

public class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Rectangle::draw()");
    }
}

public class ShapeMaker {
    private Shape circle;
    private Shape rectangle;

public ShapeMaker() {
        circle = new Circle();
        rectangle = new Rectangle();
    }

public void drawCircle() {
        circle.draw();
    }

public void drawRentangle() {
        rectangle.draw();
    }
}
```

### 6. 策略模式（Strategy Pattern）

#### 基本概念

- 在策略模式（Strategy Pattern）中，一個類的行為或其演算法可以在執行時更改。這種型別的設計模式屬於行為型模式。
- 在策略模式中，我們建立表示各種策略的物件和一個行為隨著策略物件改變而改變的 context 物件。策略物件改變 context 物件的執行演算法。

**意圖：**定義一系列的演算法,把它們一個個封裝起來, 並且使它們可相互替換。

**主要解決：**在有多種演算法相似的情況下，使用 if...else 所帶來的複雜和難以維護。

**何時使用：**一個系統有許多許多類，而區分它們的只是他們直接的行為。

**如何解決：**將這些演算法封裝成一個一個的類，任意地替換。

#### 程式碼示例

```java
public interface Strategy{
	void draw();
}

public class Circle implements Strategy{
	@Override
	public void draw() {
	}
}

public class Rentangle implements Strategy{
	@Override
	public void draw() {
	}
}

public class StrategyContext{
	private Strategy strategy;
	public StrategyContext(Strategy strategy){
		this.strategy = strategy;
	}
	public void draw(){
		strategy.draw();
	}
}
```

### 7. 模板方法模式（Template Pattern）

#### 基本概念

- 在模板模式（Template Pattern）中，一個抽象類公開定義了執行它的方法的方式 / 模板。它的子類可以按需要重寫方法實現，但呼叫將以抽象類中定義的方式進行。這種型別的設計模式屬於行為型模式。

**意圖：**定義一個操作中的演算法的骨架，而將一些步驟延遲到子類中。模板方法使得子類可以不改變一個演算法的結構即可重定義該演算法的某些特定步驟。

**主要解決：**一些方法通用，卻在每一個子類都重新寫了這一方法。

**何時使用：**有一些通用的方法。

**如何解決：**將這些通用演算法抽象出來。

#### 程式碼示例

```java
public abstract class AbstractTemplate{
    public void execute(){
        init();
        dosomething();
        end();
    }
    public void init(){
        System.out.println("初始化");
    }
    public void dosomething(){

}
    public void end(){
        System.out.println("結束執行");
    }
}

public class DemoTemplate extends AbstractTemplate{
    @Override
    public void dosomething() {
        System.out.println("自定義方法");
    }
}

public static void main(String[] args) {
    AbstractTemplate abstractTemplate = new DemoTemplate();
    abstractTemplate.execute();
}
```

### 8. 觀察者模式（Observer Pattern）

#### 基本概念

當物件間存在一對多關係時，則使用觀察者模式（Observer Pattern）。比如，當一個物件被修改時，則會自動通知它的依賴物件。觀察者模式屬於行為型模式。

**意圖：**定義物件間的一種一對多的依賴關係，當一個物件的狀態發生改變時，所有依賴於它的物件都得到通知並被自動更新。

**主要解決：**一個物件狀態改變給其他物件通知的問題，而且要考慮到易用和低耦合，保證高度的協作。

**何時使用：**一個物件（目標物件）的狀態發生改變，所有的依賴物件（觀察者物件）都將得到通知，進行廣播通知。

**如何解決：**使用物件導向技術，可以將這種依賴關係弱化。

#### 程式碼示例

```java
public class Subjects {
    private List<observer> observerList = new ArrayList<>();
    private String state;

public void attachOb(Observer observer) {
        observerList.add(observer);
    }

public void notifyAllObserver() {
        for (Observer observer : observerList) {
            observer.updata();
        }
    }

public String getState() {
        return state;
    }

public void setState(String state) {
        this.state = state;
        notifyAllObserver();
    }
}

public abstract class Observer {
    protected Subjects subject;

public abstract void updata();
}

public class DemoOb extends Observer {
    public DemoOb(Subjects subject){
        this.subject = subject;
        subject.attachOb(this);
    }

@Override
    public void updata() {
        System.out.println("DemoOb has updated");
    }
}

public static void main(String[] args) {
    Subjects subjects = new Subjects();
    Observer ob = new DemoOb(subjects);
    subjects.setState("123");
}
```</observer>

Java開發工程師進階篇-必掌握的常用設計模式

相關文章