一、設計模式的分類

建立型模式，共五種(1-5)：工廠方法模式、抽象工廠模式、單例模式、建造者模式、原型模式。 
結構型模式，共七種(6-12)：介面卡模式、裝飾器模式、代理模式、外觀模式、橋接模式、組合模式、享元模式。 
行為型模式，共十一種(13-23)：策略模式、模板方法模式、觀察者模式、迭代子模式、責任鏈模式、命令模式、備忘錄模式、狀態模式、訪問者模式、中介者模式、直譯器模式。

其實還有兩類：併發型模式和執行緒池模式。用一個圖片來整體描述一下：

二、設計模式的六大原則

總原則：開閉原則（Open Close Principle）

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

1、單一職責原則

不要存在多於一個導致類變更的原因，也就是說每個類應該實現單一的職責，如若不然，就應該把類拆分。

2、里氏替換原則（Liskov Substitution Principle）

里氏代換原則(Liskov Substitution Principle LSP)面向物件設計的基本原則之一。 里氏代換原則中說，任何基類可以出現的地方，子類一定可以出現。 LSP是繼承複用的基石，只有當衍生類可以替換掉基類，軟體單位的功能不受到影響時，基類才能真正被複用，而衍生類也能夠在基類的基礎上增加新的行為。里氏代換原則是對“開-閉”原則的補充。實現“開-閉”原則的關鍵步驟就是抽象化。而基類與子類的繼承關係就是抽象化的具體實現，所以里氏代換原則是對實現抽象化的具體步驟的規範。—— From Baidu 百科 
歷史替換原則中，子類對父類的方法儘量不要重寫和過載。因為父類代表了定義好的結構，通過這個規範的介面與外界互動，子類不應該隨便破壞它。

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

這個是開閉原則的基礎，具體內容：面向介面程式設計，依賴於抽象而不依賴於具體。寫程式碼時用到具體類時，不與具體類互動，而與具體類的上層介面互動。

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

這個原則的意思是：每個介面中不存在子類用不到卻必須實現的方法，如果不然，就要將介面拆分。使用多個隔離的介面，比使用單個介面（多個介面方法集合到一個的介面）要好。

5、迪米特法則（最少知道原則）（Demeter Principle）

就是說：一個類對自己依賴的類知道的越少越好。也就是說無論被依賴的類多麼複雜，都應該將邏輯封裝在方法的內部，通過public方法提供給外部。這樣當被依賴的類變化時，才能最小的影響該類。 
最少知道原則的另一個表達方式是：只與直接的朋友通訊。類之間只要有耦合關係，就叫朋友關係。耦合分為依賴、關聯、聚合、組合等。我們稱出現為成員變數、方法引數、方法返回值中的類為直接朋友。區域性變數、臨時變數則不是直接的朋友。我們要求陌生的類不要作為區域性變量出現在類中。

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

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

三、Java的23中設計模式

從這一塊開始，我們詳細介紹Java中23種設計模式的概念，應用場景等情況，並結合他們的特點及設計模式的原則進行分析。

首先，簡單工廠模式不屬於23中設計模式，簡單工廠一般分為：普通簡單工廠、多方法簡單工廠、靜態方法簡單工廠。

1 簡單工廠模式

簡單工廠模式模式分為三種：

普通工廠模式

就是建立一個工廠類，對實現了同一介面的一些類進行例項的建立。首先看下關係圖：

舉例如下：（我們舉一個傳送郵件和簡訊的例子） 
首先，建立二者的共同介面：

    public interface Sender {
        public void Send();
    }

• 1
• 2
• 3
• 4
• 5

其次，建立實現類：

    public class MailSender implements Sender {
        @Override
        public void Send() {
            System.out.println("this is mailsender!");
        }
    }

    public class SmsSender implements Sender {

        @Override
        public void Send() {
            System.out.println("this is sms sender!");
        }
    }   

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16

最後，建工廠類：

    public class SendFactory {

        public Sender produce(String type) {
            if ("mail".equals(type)) {
                return new MailSender();
            } else if ("sms".equals(type)) {
                return new SmsSender();
            } else {
                System.out.println("請輸入正確的型別!");
                return null;
            }
        }
    }

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15

測試：

    public class FactoryTest {

        public static void main(String[] args) {
            SendFactory factory = new SendFactory();
            Sender sender = factory.produce("sms");
            sender.Send();
        }
    }

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10

輸出：this is sms sender!

多個工廠方法模式

是對普通工廠方法模式的改進，在普通工廠方法模式中，如果傳遞的字串出錯，則不能正確建立物件，而多個工廠方法模式是提供多個工廠方法，分別建立物件。關係圖：

將上面的程式碼做下修改，改動下SendFactory類就行，如下：

    public class SendFactory {

        public Sender produceMail(){
            return new MailSender();
        }

        public Sender produceSms(){
            return new SmsSender();
        }
    }

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12

測試類如下：

    public class FactoryTest {

        public static void main(String[] args) {
            SendFactory factory = new SendFactory();
            Sender sender = factory.produceMail();
            sender.Send();
        }
    }

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10

輸出：this is mailsender!

靜態工廠方法模式

將上面的多個工廠方法模式裡的方法置為靜態的，不需要建立例項，直接呼叫即可。

    public class SendFactory {

        public static Sender produceMail(){
            return new MailSender();
        }

        public static Sender produceSms(){
            return new SmsSender();
        }
    }  

    public class FactoryTest {

        public static void main(String[] args) {    
            Sender sender = SendFactory.produceMail();
            sender.Send();
        }
    }

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20

輸出：this is mailsender!

總體來說，工廠模式適合：凡是出現了大量的產品需要建立，並且具有共同的介面時，可以通過工廠方法模式進行建立。在以上的三種模式中，第一種如果傳入的字串有誤，不能正確建立物件，第三種相對於第二種，不需要例項化工廠類，所以，大多數情況下，我們會選用第三種——靜態工廠方法模式。

2、抽象工廠模式（Abstract Factory）

工廠方法模式有一個問題就是，類的建立依賴工廠類，也就是說，如果想要拓展程式，必須對工廠類進行修改，這違背了閉包原則，所以，從設計角度考慮，有一定的問題，如何解決？就用到抽象工廠模式，建立多個工廠類，這樣一旦需要增加新的功能，直接增加新的工廠類就可以了，不需要修改之前的程式碼。因為抽象工廠不太好理解，我們先看看圖，然後就和程式碼，就比較容易理解。

    public class MailSender implements Sender {
        @Override
        public void Send() {
            System.out.println("this is mailsender!");
        }
    }  

    public class SmsSender implements Sender {

        @Override
        public void Send() {
            System.out.println("this is sms sender!");
        }
    }

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16

兩個工廠類：

    public class SendMailFactory implements Provider {

        @Override
        public Sender produce(){
            return new MailSender();
        }
    }  

    public class SendSmsFactory implements Provider{

        @Override
        public Sender produce() {
            return new SmsSender();
        }
    }  

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18

在提供一個介面：

    public interface Provider {
        public Sender produce();
    }

• 1
• 2
• 3
• 4

測試類

    public class Test {
        public static void main(String[] args) {
            Provider provider = new SendMailFactory();
            Sender sender = provider.produce();
            sender.Send();
        }
    }

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9

其實這個模式的好處就是，如果你現在想增加一個功能：發及時資訊，則只需做一個實現類，實現Sender介面，同時做一個工廠類，實現Provider介面，就OK了，無需去改動現成的程式碼。這樣做，拓展性較好！

3、單例模式（Singleton）

單例物件（Singleton）是一種常用的設計模式。在Java應用中，單例物件能保證在一個JVM中，該物件只有一個例項存在。這樣的模式有幾個好處： 
1. 某些類建立比較頻繁，對於一些大型的物件，這是一筆很大的系統開銷。 
2. 省去了new操作符，降低了系統記憶體的使用頻率，減輕GC壓力。 
3. 有些類如交易所的核心交易引擎，控制著交易流程，如果該類可以建立多個的話，系統完全亂了。 （比如一個軍隊出現了多個司令員同時指揮，肯定會亂成一團），所以只有使用單例模式，才能保證核心交易伺服器獨立控制整個流程。 
首先我們寫一個簡單的單例類：

    public class Singleton {

        /* 持有私有靜態例項，防止被引用，此處賦值為null，目的是實現延遲載入 */
        private static Singleton instance = null;

        /* 私有構造方法，防止被例項化 */
        private Singleton() {
        }

        /* 靜態工程方法，建立例項 */
        public static Singleton getInstance() {
            if (instance == null) {
                instance = new Singleton();
            }
            return instance;
        }

        /* 如果該物件被用於序列化，可以保證物件在序列化前後保持一致 */
        public Object readResolve() {
            return instance;
        }
    }

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24

這個類可以滿足基本要求，但是，像這樣毫無執行緒安全保護的類，如果我們把它放入多執行緒的環境下，肯定就會出現問題了，如何解決？我們首先會想到對getInstance方法加synchronized關鍵字，如下：

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

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8

但是，synchronized關鍵字鎖住的是這個物件，這樣的用法，在效能上會有所下降，因為每次呼叫getInstance()，都要對物件上鎖，事實上，只有在第一次建立物件的時候需要加鎖，之後就不需要了，所以，這個地方需要改進。我們改成下面這個：

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

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12

相關推薦