問題由來

問題由來：類A通過介面I依賴類B，類C通過介面I依賴類D，如果介面I對於類A和類B來說不是最小介面，則類B和類D必須去實現他們不需要的方法。
解決方案：將臃腫的介面I拆分為獨立的幾個介面，類A和類C分別與他們需要的介面建立依賴關係。也就是採用介面隔離原則。

定義

在講解介面隔離原則之前，先明確一下我們的主角——介面。介面分為兩種：

• 例項介面。在java中宣告一個類，然後用new關鍵字產生一個示例，它是對一個型別的事物的描述，這是一種介面，比如你定義Person這個類，然後使用Person zhangshan = new Person()產生一個例項，這個例項要遵從的標準就是Person這個類，Person類就是zhangsan的介面。疑惑？看不懂？不要緊，那是因為讓java語言浸染的時間太長了，只要知道從這個角度來看，java中的類也是一種介面。
• 類介面。java中常用interface關鍵字定義的介面。

主角已經定義清楚了，那什麼是隔離呢？它有兩種定義，如下：

• 客戶端不應該依賴於它不需要的介面
• 類間的依賴關係應該建立在最小的介面上
  我們可以把這兩個定義概括為一句話：建立單一的介面，不要建立臃腫龐大的介面。再通俗一點講：介面儘量細化，同時介面中的方法儘量少。

使用多個專門的介面，而不使用單一的總介面，即客戶端不應該依賴那些它不需要的介面。

• 應當為客戶端提供儘可能小的單獨的介面，而不要提供大的總介面。在面對物件程式語言中，實現一個介面就需要實現該介面中定義的所有方法，因此大的總介面使用起來不一定很方便。

• 很多人會覺的介面隔離原則跟之前的單一職責原則很相似，其實不然。其一，單一職責原則原注重的是職責；而介面隔離原則注重對介面依賴的隔離。其二，單一職責原則主要是約束類，其次才是介面和方法，它針對的是程式中的實現和細節；而介面隔離原則主要約束介面介面，主要針對抽象，針對程式整體框架的構建。

• 介面儘量小，但是要有限度。對介面進行細化可以提高程式設計靈活性是不掙的事實，但是如果過小，則會造成介面數量過多，使設計複雜化。所以一定要適度。

• 提高內聚，減少對外互動。使介面用最少的方法去完成最多的事情。運用介面隔離原則，一定要適度，介面設計的過大或過小都不好。設計介面的時候，只有多花些時間去思考和籌劃，才能準確地實踐這一原則。

介面隔離原則的最佳實踐

介面隔離原則是對介面的定義，同時也是對類的定義，介面和類儘管使用原子介面或原子類來組裝。但是，這個原子該怎麼劃分是設計模式中的一大難題，在實踐中可以根據以下幾個規劃來衡量：

• 一個介面只服務於一個子模組或業務邏輯
• 通過業務邏輯壓縮介面中的public方法，介面時常去回顧，儘量讓介面達到“滿身筋骨肉”，而不是“肥嘟嘟”的一大堆方法。
• 已經汙染了的介面，儘量去修改，若變更的風險較大，則採用介面卡模式進行轉化處理
• 瞭解環境，拒絕盲從。每個專案或產品都有特定的環境因素，別看到大師是這樣做的你就照抄。千萬別，環境不同，介面拆分的標準就不同。深入瞭解業務邏輯，最好的介面設計就出自你的手中

怎麼準確去實踐介面隔離原則？實踐、經驗和領悟

例子

舉例來說明介面隔離原則：

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

    interface I {  
        public void method1();  
        public void method2();  
        public void method3();  
        public void method4();  
        public 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 implements I{  
        public void method1() {  
            System.out.println("類B實現介面I的方法1");  
        }  
        public void method2() {  
            System.out.println("類B實現介面I的方法2");  
        }  
        public void method3() {  
            System.out.println("類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 implements I{  
        public void method1() {  
            System.out.println("類D實現介面I的方法1");  
        }  
        //對於類D來說，method2和method3不是必需的，但是由於介面A中有這兩個方法，  
        //所以在實現過程中即使這兩個方法的方法體為空，也要將這兩個沒有作用的方法進行實現。  
        public void method2() {}  
        public void method3() {}  

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

    public class Client{  
        public static void main(String[] args){  
            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 {  
      public void method1();  
    }  

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

    interface I3 {  
        public void method4();  
        public 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 implements I1, I2{  
        public void method1() {  
            System.out.println("類B實現介面I1的方法1");  
        }  
        public void method2() {  
            System.out.println("類B實現介面I2的方法2");  
        }  
        public void method3() {  
            System.out.println("類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 implements I1, I3{  
        public void method1() {  
            System.out.println("類D實現介面I1的方法1");  
        }  
        public void method4() {  
            System.out.println("類D實現介面I3的方法4");  
        }  
        public void method5() {  
            System.out.println("類D實現介面I3的方法5");  
        }  
    }  

  介面隔離原則的含義是：建立單一介面，不要建立龐大臃腫的介面，儘量細化介面，介面中的方法儘量少。也就是說，我們要為各個類建立專用的介面，而不要試圖去建立一個很龐大的介面供所有依賴它的類去呼叫。本文例子中，將一個龐大的介面變更為3個專用的介面所採用的就是介面隔離原則。在程式設計中，依賴幾個專用的介面要比依賴一個綜合的介面更靈活。介面是設計時對外部設定的“契約”，通過分散定義多個介面，可以預防外來變更的擴散，提高系統的靈活性和可維護性。