需要說明的一點是單一職責原則不只是面向物件程式設計思想所特有的，只要是模組化的程式設計，都適用單一職責原則。

原則2：里氏替換原則

名字的由來

肯定有不少人跟我剛看到這項原則的時候一樣，對這個原則的名字充滿疑惑。
其實原因就是這項原則最早是在1988年，由麻省理工學院的一位姓裡的女士（Barbara Liskov）提出來的。
簡單來說的話，就是當我們使用繼承時，遵循里氏替換原則。

定義

注：類B繼承類A時，除新增新的方法完成新增功外，儘量不要重寫父類A的方法，也儘量不要過載父類A的方法。

繼承的風險

那就讓我們一起看看繼承的風險，如下：

class A
{
    public int func1(int a, int b)
    {
        return a - b;
    }
}

public class Client
{
    void Start()
    {
        A a = new A();
        Debug.Log("100-50=" + a.func1(100, 50));
        Debug.Log("100-80=" + a.func1(100, 80));
    }
}

執行結果

100-50=50
100-80=20

需求變動

後來，我們需要增加一個新的功能：完成兩數相加，然後再與100求和，由類B來負責。
即類B需要完成兩個功能：
兩數相減。
兩數相加，然後再加100。
由於類A已經實現了第一個功能，所以類B繼承類A後，只需要再完成第二個功能就可以了，程式碼如下

class B:A
{
    public int func1(int a, int b)
    {
        return a + b;
    }

    public int func2(int a, int b)
    {
        return func1(a, b) + 100;
    }
}

public class Client
{
    private void Start()
    {
        B b = new B();
        Debug.Log("100-50=" + b.func1(100, 50));
        Debug.Log("100-80=" + b.func1(100, 80));
        Debug.Log("100+20+100=" + b.func2(100, 20));
    }
}

類B執行結果

100-50=150
100-80=180
100+20+100=220

影響了正常的功能

我們發現原本執行正常的相減功能發生了錯誤。
原因就是類B在給方法起名時無意中重寫了父類的方法，造成所有執行相減功能的程式碼全部呼叫了類B重寫後的方法，造成原本執行正常的功能出現了錯誤。
在本例中，引用基類A完成的功能，換成子類B之後，發生了異常。
在實際程式設計中，我們常常會通過重寫父類的方法來完成新的功能，這樣寫起來雖然簡單，
但是整個繼承體系的可複用性會比較差，特別是運用多型比較頻繁時，程式執行出錯的機率非常大。
如果非要重寫父類的方法，比較通用的做法是：原來的父類和子類都繼承一個更通俗的基類，原有的繼承關係去掉，採用依賴、聚合，組合等關係代替。

里氏替換原則通俗的來講就是

子類可以擴充套件父類的功能，但不能改變父類原有的功能。它包含以下4層含義：
1.子類可以實現父類的抽象方法，但不能覆蓋父類的非抽象方法。
2.子類中可以增加自己特有的方法。
3.當子類的方法過載父類的方法時，方法的前置條件（即方法的形參）要比父類方法的輸入引數更寬鬆。
4.當子類的方法實現父類的抽象方法時，方法的後置條件（即方法的返回值）要比父類更嚴格。

看上去很不可思議，因為我們會發現在自己程式設計中常常會違反里氏替換原則，程式照樣跑的好好的。
所以大家都會產生這樣的疑問，假如我非要不遵循里氏替換原則會有什麼後果？
後果就是：你寫的程式碼出問題的機率將會大大增加。

原則3：依賴倒置原則

定義

高層模組不應該依賴低層模組，二者都應該依賴其抽象；抽象不應該依賴細節；細節應該依賴抽象。

以抽象為基礎搭建起來的架構比以細節為基礎搭建起來的架構要穩定的多。
抽象指的是介面或者抽象類，細節就是具體的實現類，使用介面或者抽象類的目的是制定好規範和契約，而不去涉及任何具體的操作，把展現細節的任務交給他們的實現類去完成。

依賴倒置原則核心思想

依賴倒置原則的核心思想是面向介面程式設計，我們依舊用一個例子來說明面向介面程式設計比相對於面向實現程式設計好在什麼地方。

情景舉例

場景是這樣的，母親給孩子講故事，只要給她一本書，她就可以照著書給孩子講故事了。程式碼如下：

class Book
{
    public String getContent()
    {
        return "很久很久以前有一個阿拉伯的故事……";
    }
}

class Mother
{
    public void narrate(Book book)
    {
        Debug.Log("媽媽開始講故事");
        Debug.Log(book.getContent());
    }
}

public class Client
{
    void Start()
    {
        Mother mother = new Mother();
        mother.narrate(new Book());
    }
}

執行結果：

媽媽開始講故事
很久很久以前有一個阿拉伯的故事……

需求變動

執行良好，假如有一天，需求變成這樣：不是給書而是給一份報紙，讓這位母親講一下報紙上的故事，報紙的程式碼如下：

class Newspaper
{
    public String getContent()
    {
        return "林書豪38+7領導尼克斯擊敗湖人……";
    }
}

這位母親卻辦不到，因為她居然不會讀報紙上的故事，這太荒唐了，只是將書換成報紙，居然必須要修改Mother才能讀。
假如以後需求換成雜誌呢？換成網頁呢？
還要不斷地修改Mother，這顯然不是好的設計。
原因就是Mother與Book之間的耦合性太高了，必須降低他們之間的耦合度才行。

抽象的介面

我們引入一個抽象的介面IReader。
讀物，只要是帶字的都屬於讀物：

interface IReader
{
    String getContent();
}

Mother類與介面IReader發生依賴關係，而Book和Newspaper都屬於讀物的範疇，
他們各自都去實現IReader介面，這樣就符合依賴倒置原則了，程式碼修改為：

interface IReader
{
    String getContent();
}

class Newspaper : IReader
{
    public String getContent()
    {
        return "林書豪17+9助尼克斯擊敗老鷹……";
    }
}
class Book : IReader
{
    public String getContent()
    {
        return "很久很久以前有一個阿拉伯的故事……";
    }
}

class Mother
{
    public void narrate(IReader reader)
    {
        Debug.Log("媽媽開始講故事");
        Debug.Log(reader.getContent());
    }
}

public class Client
{
    public static void main(String[] args)
    {
        Mother mother = new Mother();
        mother.narrate(new Book());
        mother.narrate(new Newspaper());
    }
}

執行結果

媽媽開始講故事
很久很久以前有一個阿拉伯的故事……
媽媽開始講故事
林書豪17+9助尼克斯擊敗老鷹……

這樣修改後，無論以後怎樣擴充套件Client類，都不需要再修改Mother類了。
這只是一個簡單的例子，實際情況中，代表高層模組的Mother類將負責完成主要的業務邏輯，一旦需要對它進行修改，引入錯誤的風險極大。
所以遵循依賴倒置原則可以降低類之間的耦合性，提高系統的穩定性，降低修改程式造成的風險。
採用依賴倒置原則給多人並行開發帶來了極大的便利，

比如上例中，原本Mother類與Book類直接耦合時，Mother類必須等Book類編碼完成後才可以進行編碼，因為Mother類依賴於Book類。
修改後的程式則可以同時開工，互不影響，因為Mother與Book類一點關係也沒有。
參與協作開發的人越多、專案越龐大，採用依賴導致原則的意義就越重大。
現在很流行的TDD開發模式就是依賴倒置原則最成功的應用。

在實際程式設計中，我們一般需要做到如下3點

1.低層模組儘量都要有抽象類或介面，或者兩者都有。
2.變數的宣告型別儘量是抽象類或介面。使用繼承時遵循里氏替換原則。
3.依賴倒置原則的核心就是要我們面向介面程式設計，理解了面向介面程式設計，也就理解了依賴倒置。

原則4：介面隔離原則

定義

客戶端不應該依賴它不需要的介面；一個類對另一個類的依賴應該建立在最小的介面上。
將臃腫的介面I拆分為獨立的幾個介面，類A和類C分別與他們需要的介面建立依賴關係。也就是採用介面隔離原則。
舉例來說明介面隔離原則：

未遵循介面隔離原則的設計

 
這個圖的意思是：類A依賴介面I中的方法1、方法2、方法3，類B是對類A依賴的實現。
類C依賴介面I中的方法1、方法4、方法5，類D是對類C依賴的實現。
對於類B和類D來說，雖然他們都存在著用不到的方法（也就是圖中紅色字型標記的方法），但由於實現了介面I，所以也必須要實現這些用不到的方法。

示例程式碼

對類圖不熟悉的可以參照程式程式碼來理解，程式碼如下：

//介面
interface I
{
    void method1();
    void method2();
    void method3();
    void method4();
    void method5();
}

class A
{
    public void depend1(I i)
    {
        i.method1();
    }
    public void depend2(I i)
    {
        i.method2();
    }
    public void depend3(I i)
    {
        i.method3();
    }
}

class B : I
{
    public void method1()
    {
        Debug.Log("類B實現介面I的方法1");
    }
    public void method2()
    {
        Debug.Log("類B實現介面I的方法2");
    }
    public void method3()
    {
        Debug.Log("類B實現介面I的方法3");
    }
    //對於類B來說，method4和method5不是必需的，但是由於介面A中有這兩個方法，
    //所以在實現過程中即使這兩個方法的方法體為空，也要將這兩個沒有作用的方法進行實現。
    public void method4() { }
    public void method5() { }
}

class C
{
    public void depend1(I i)
    {
        i.method1();
    }
    public void depend2(I i)
    {
        i.method4();
    }
    public void depend3(I i)
    {
        i.method5();
    }
}

class D : I
{
    public void method1()
    {
        Debug.Log("類D實現介面I的方法1");
    }
    //對於類D來說，method2和method3不是必需的，但是由於介面A中有這兩個方法，
    //所以在實現過程中即使這兩個方法的方法體為空，也要將這兩個沒有作用的方法進行實現。
    public void method2() { }
    public void method3() { }

    public void method4()
    {
        Debug.Log("類D實現介面I的方法4");
    }
    public void method5()
    {
        Debug.Log("類D實現介面I的方法5");
    }
}

public class Client
{
    void Start()
    {
        A a = new A();
        a.depend1(new B());
       a.depend2(new B());
       a.depend3(new B());

        C c = new C();
      c.depend1(new D()));
        c.depend2(new D());
        c.depend3(new D());
    }
}

可以看到，如果介面過於臃腫，只要介面中出現的方法，不管對依賴於它的類有沒有用處，實現類中都必須去實現這些方法，這顯然不是好的設計。
如果將這個設計修改為符合介面隔離原則，就必須對介面I進行拆分。

遵循介面隔離原則的設計

在這裡我們將原有的介面I拆分為三個介面，拆分後的設計如圖2所示：

示例程式碼

照例貼出程式的程式碼，供不熟悉類圖的朋友參考：

interface I1
{
     void method1();
}

interface I2
{
     void method2();
     void method3();
}

interface I3
{
     void method4();
     void method5();
}

class A
{
    public void depend1(I1 i)
    {
        i.method1();
    }
    public void depend2(I2 i)
    {
        i.method2();
    }
    public void depend3(I2 i)
    {
        i.method3();
    }
}

class B : I1, I2
{
    public void method1()
    {
        Debug.Log("類B實現介面I1的方法1");
    }
    public void method2()
    {
        Debug.Log("類B實現介面I2的方法2");
    }
    public void method3()
    {
        Debug.Log("類B實現介面I2的方法3");
    }
}

class C
{
    public void depend1(I1 i)
    {
        i.method1();
    }
    public void depend2(I3 i)
    {
        i.method4();
    }
    public void depend3(I3 i)
    {
        i.method5();
    }
}

class D : I1, I3
{
    public void method1()
    {
        Debug.Log("類D實現介面I1的方法1");
    }
    public void method4()
    {
        Debug.Log("類D實現介面I3的方法4");
    }
    public void method5()
    {
        Debug.Log("類D實現介面I3的方法5");
    }
}

介面隔離原則的含義是：建立單一介面，不要建立龐大臃腫的介面，儘量細化介面，介面中的方法儘量少。
也就是說，我們要為各個類建立專用的介面，而不要試圖去建立一個很龐大的介面供所有依賴它的類去呼叫。
本文例子中，將一個龐大的介面變更為3個專用的介面所採用的就是介面隔離原則。

在程式設計中，依賴幾個專用的介面要比依賴一個綜合的介面更靈活。
介面是設計時對外部設定的“契約”，通過分散定義多個介面，可以預防外來變更的擴散，提高系統的靈活性和可維護性。
說到這裡，很多人會覺的介面隔離原則跟之前的單一職責原則很相似，其實不然。
其一，單一職責原則原注重的是職責；而介面隔離原則注重對介面依賴的隔離。
其二，單一職責原則主要是約束類，其次才是介面和方法，它針對的是程式中的實現和細節；

而介面隔離原則主要約束介面，主要針對抽象，針對程式整體框架的構建。

注意幾點

採用介面隔離原則對介面進行約束時，要注意以下幾點：
1.介面儘量小，但是要有限度。對介面進行細化可以提高程式設計靈活性是不掙的事實，但是如果過小，則會造成介面數量過多，使設計複雜化。所以一定要適度。
2.為依賴介面的類定製服務，只暴露給呼叫的類它需要的方法，它不需要的方法則隱藏起來。只有專注地為一個模組提供定製服務，才能建立最小的依賴關係。
3.提高內聚，減少對外互動。使介面用最少的方法去完成最多的事情。
運用介面隔離原則，一定要適度，介面設計的過大或過小都不好。設計介面的時候，只有多花些時間去思考和籌劃，才能準確地實踐這一原則。

原則5：迪米特法則

定義

一個物件應該對其他物件保持最少的瞭解
類與類之間的關係越密切，耦合度越大，當一個類發生改變時，對另一個類的影響也越大。
因此，儘量降低類與類之間的耦合。
自從我們接觸程式設計開始，就知道了軟體程式設計的總的原則：低耦合，高內聚。
無論是面向過程程式設計還是面向物件程式設計，只有使各個模組之間的耦合儘量的低，才能提高程式碼的複用率。
低耦合的優點不言而喻，但是怎麼樣程式設計才能做到低耦合呢？那正是迪米特法則要去完成的。

最少知道原則

迪米特法則又叫最少知道原則，最早是在1987年由美國Northeastern University的Ian Holland提出。
通俗的來講，就是一個類對自己依賴的類知道的越少越好。也就是說，對於被依賴的類來說，無論邏輯多麼複雜，都儘量地的將邏輯封裝在類的內部，對外除了提供的public方法，不對外洩漏任何資訊。
迪米特法則還有一個更簡單的定義：只與直接的朋友通訊。首先來解釋一下什麼是直接的朋友：
每個物件都會與其他物件有耦合關係，只要兩個物件之間有耦合關係，我們就說這兩個物件之間是朋友關係。
耦合的方式很多，依賴、關聯、組合、聚合等。其中，我們稱出現成員變數、方法引數、方法返回值中的類為直接的朋友，
而出現在區域性變數中的類則不是直接的朋友。也就是說，陌生的類最好不要作為區域性變數的形式出現在類的內部。

違反迪米特法則的設計

舉一個例子：有一個集團公司，下屬單位有分公司和直屬部門，現在要求打印出所有下屬單位的員工ID。
先來看一下違反迪米特法則的設計。

//總公司員工
class Employee
{
    private String id;
    public void setId(String id)
    {
        this.id = id;
    }
    public String getId()
    {
        return id;
    }
}

//分公司員工
class SubEmployee
{
    private String id;
    public void setId(String id)
    {
        this.id = id;
    }
    public String getId()
    {
        return id;
    }
}

class SubCompanyManager
{
    public List<SubEmployee> getAllEmployee()
    {
        List<SubEmployee> list = new List<SubEmployee>();
        for (int i = 0; i < 100; i++)
        {
            SubEmployee emp = new SubEmployee();
            //為分公司人員按順序分配一個ID
            emp.setId("分公司" + i);
            list.Add(emp);
        }
        return list;
    }
}

class CompanyManager
{

    public List<Employee> getAllEmployee()
    {
        List<Employee> list = new List<Employee>();
        for (int i = 0; i < 30; i++)
        {
            Employee emp = new Employee();
            //為總公司人員按順序分配一個ID
            emp.setId("總公司" + i);
            list.Add(emp);
        }
        return list;
    }

    public void printAllEmployee(SubCompanyManager sub)
    {
        List<SubEmployee> list1 = sub.getAllEmployee();
        foreach (SubEmployee e in list1)
        {
            Debug.Log(e.getId());
        }


        List<Employee> list2 = this.getAllEmployee();
        foreach (Employee e in list2)
        {
            Debug.Log(e.getId());
        }
    }
}

public class Client
{
    void Start()
    {
        CompanyManager e = new CompanyManager();
        e.printAllEmployee(new SubCompanyManager());
    }
}

現在這個設計的主要問題出在CompanyManager中，根據迪米特法則，只與直接的朋友發生通訊，
而SubEmployee類並不是CompanyManager類的直接朋友（以區域性變量出現的耦合不屬於直接朋友），從邏輯上講總公司只與他的分公司耦合就行了，
與分公司的員工並沒有任何聯絡，這樣設計顯然是增加了不必要的耦合。

修改後的程式碼

按照迪米特法則，應該避免類中出現這樣非直接朋友關係的耦合。修改後的程式碼如下:

class SubCompanyManager
{
    public List<SubEmployee> getAllEmployee()
    {
        List<SubEmployee> list = new List<SubEmployee>();
        for (int i = 0; i < 100; i++)
        {
            SubEmployee emp = new SubEmployee();
            //為分公司人員按順序分配一個ID
            emp.setId("分公司" + i);
            list.Add(emp);
        }
        return list;
    }
    public void printEmployee()
    {
        List<SubEmployee> list = this.getAllEmployee();
        foreach (SubEmployee e in list)
        {
            Debug.Log(e.getId());
        }
    }
}

class CompanyManager
{
    public List<Employee> getAllEmployee()
    {
        List<Employee> list = new List<Employee>();
        for (int i = 0; i < 30; i++)
        {
            Employee emp = new Employee();
            //為總公司人員按順序分配一個ID
            emp.setId("總公司" + i);
            list.Add(emp);
        }
        return list;
    }

    public void printAllEmployee(SubCompanyManager sub)
    {
        sub.printEmployee();
        List<Employee> list2 = this.getAllEmployee();
        foreach (Employee e in list2)
        {
            Debug.Log(e.getId());
        }
    }
}

主要的變化

修改後，為分公司增加了列印人員ID的方法，總公司直接呼叫來列印，從而避免了與分公司的員工發生耦合。

總結

迪米特法則的初衷是降低類之間的耦合，由於每個類都減少了不必要的依賴，因此的確可以降低耦合關係。
但是凡事都有度，雖然可以避免與非直接的類通訊，但是要通訊，必然會通過一個“中介”來發生聯絡，例如本例中，
總公司就是通過分公司這個“中介”來與分公司的員工發生聯絡的。
過分的使用迪米特原則，會產生大量這樣的中介和傳遞類，導致系統複雜度變大。
所以在採用迪米特法則時要反覆權衡，既做到結構清晰，又要高內聚低耦合。

原則6：開閉原則

定義

一個軟體實體如類、模組和函式應該對擴充套件開放，對修改關閉

在軟體的生命週期內，因為變化、升級和維護等原因需要對軟體原有程式碼進行修改時，
可能會給舊程式碼中引入錯誤，也可能會使我們不得不對整個功能進行重構，並且需要原有程式碼經過重新測試。
因此，當軟體需要變化時，儘量通過擴充套件軟體實體的行為來實現變化，而不是通過修改已有的程式碼來實現變化。
閉原則是面向物件設計中最基礎的設計原則，它指導我們如何建立穩定靈活的系統。開閉原則可能是設計模式六項原則中定義最模糊的一個了，

它只告訴我們對擴充套件開放，對修改關閉，可是到底如何才能做到對擴充套件開放，對修改關閉，並沒有明確的告訴我們。
以前，如果有人告訴我“你進行設計的時候一定要遵守開閉原則”，我會覺的他什麼都沒說，但貌似又什麼都說了。因為開閉原則真的太虛了。
在仔細思考以及仔細閱讀很多設計模式的文章後，終於對開閉原則有了一點認識。
其實，我們遵循設計模式前面5大原則，以及使用23種設計模式的目的就是遵循開閉原則。

如何遵守

也就是說，只要我們對前面5項原則遵守的好了，設計出的軟體自然是符合開閉原則的，這個開閉原則更像是前面五項原則遵守程度的“平均得分”，
前面5項原則遵守的好，平均分自然就高，說明軟體設計開閉原則遵守的好；
如果前面5項原則遵守的不好，則說明開閉原則遵守的不好。
其實，開閉原則無非就是想表達這樣一層意思：用抽象構建框架，用實現擴充套件細節。
因為抽象靈活性好，適應性廣，只要抽象的合理，可以基本保持軟體架構的穩定。
而軟體中易變的細節，我們用從抽象派生的實現類來進行擴充套件，當軟體需要發生變化時，我們只需要根據需求重新派生一個實現類來擴充套件就可以了。
當然前提是我們的抽象要合理，要對需求的變更有前瞻性和預見性才行。

如何去遵守這六個原則

對這六個原則的遵守並不是 是和否的問題，而是多和少的問題，也就是說，我們一般不會說有沒有遵守，而是說遵守程度的多少。
任何事都是過猶不及，設計模式的六個設計原則也是一樣，制定這六個原則的目的並不是要我們刻板的遵守他們，而需要根據實際情況靈活運用。
對他們的遵守程度只要在一個合理的範圍內，就算是良好的設計。
如果大家對這六項原則的理解跟我有所不同，歡迎指正