總結經驗

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

（圖1 未遵循介面隔離原則的設計）
這個圖的意思是：類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 : 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();
                Debug.Log(a.depend1(new B()));
                Debug.Log(a.depend2(new B()));
                Debug.Log(a.depend3(new B()));
                 
                C c = new C();
                Debug.Log(c.depend1(new D()));
                Debug.Log(c.depend2(new D()));
                Debug.Log(c.depend3(new D()));
        }
}
 

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

（圖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 : 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");
        }
}