Java設計模式之接口隔離原則精解

更新時間：2022年02月08日 11:40:20 作者：張起靈-小哥

設計模式（Design pattern）代表了最佳的實踐，通常被有經驗的面向對象的軟件開發(fā)人員所采用。設計模式是軟件開發(fā)人員在軟件開發(fā)過程中面臨的一般問題的解決方案。本篇介紹設計模式七大原則之一的接口隔離原則

1.什么是接口隔離原則？

客戶端不應該依賴它不需要的接口，即一個類對另一個類的依賴應該建立在最小的接口范圍上。

2.對應代碼

上面這張圖呢，就違反了接口隔離原則。它對應的代碼如下：??????

package com.szh.principle.segregation;
 
/**
 *
 */
interface Interface1 {
    void operation1();
    void operation2();
    void operation3();
    void operation4();
    void operation5();
}
 
class B implements Interface1 {
    public void operation1() {
        System.out.println("B 實現了 operation1");
    }
    public void operation2() {
        System.out.println("B 實現了 operation2");
    }
    public void operation3() {
        System.out.println("B 實現了 operation3");
    }
    public void operation4() {
        System.out.println("B 實現了 operation4");
    }
    public void operation5() {
        System.out.println("B 實現了 operation5");
    }
}
 
class D implements Interface1 {
    public void operation1() {
        System.out.println("D 實現了 operation1");
    }
    public void operation2() {
        System.out.println("D 實現了 operation2");
    }
    public void operation3() {
        System.out.println("D 實現了 operation3");
    }
    public void operation4() {
        System.out.println("D 實現了 operation4");
    }
    public void operation5() {
        System.out.println("D 實現了 operation5");
    }
}
 
class A { //A 類通過接口Interface1 依賴(使用) B類，但是只會用到1,2,3方法
    public void depend1(Interface1 i) {
        i.operation1();
    }
    public void depend2(Interface1 i) {
        i.operation2();
    }
    public void depend3(Interface1 i) {
        i.operation3();
    }
}
 
class C { //C 類通過接口Interface1 依賴(使用) D類，但是只會用到1,4,5方法
    public void depend1(Interface1 i) {
        i.operation1();
    }
    public void depend4(Interface1 i) {
        i.operation4();
    }
    public void depend5(Interface1 i) {
        i.operation5();
    }
}
 
public class Segregation1 {
    public static void main(String[] args) {
        A a = new A();
        a.depend1(new B()); // A類通過接口去依賴B類
        a.depend2(new B());
        a.depend3(new B());
 
        C c = new C();
        c.depend1(new D()); // C類通過接口去依賴(使用)D類
        c.depend4(new D());
        c.depend5(new D());
    }
}

代碼雖然很長，但是不難理解。A類依賴了B類，但是只會用到頂級接口中的1、2、3這三個方法；而C類依賴了D類，但是只會用到頂級接口中的1、4、5這三個方法，也就是說在A和B這兩個類的層面上而言，和頂級接口中的4、5兩個方法是沒什么關聯的，那么B類在實現頂級接口的時候就沒必要重寫4、5這兩個方法了。但是這里有一個問題就是頂級接口中包括了1到5這五個方法，你如果實現這個接口就必須重寫這五個方法，那么我們就可以考慮將頂級接口拆分成多個接口，需要用到哪個就實現哪個，這也就是所謂的接口隔離了。

3.改進代碼

經過上面的一番敘述，我們可以將代碼改寫成下面的形式。

即將頂級接口拆分成3個小接口，B、D兩個類根據實際情況該實現哪個接口就實現哪個接口（因為這五個方法已經被分開了）。

package com.szh.principle.segregation.improve;
 
/**
 *
 */
interface Interface1 {
    void operation1();
}
 
interface Interface2 {
    void operation2();
    void operation3();
}
 
interface Interface3 {
    void operation4();
    void operation5();
}
 
class B implements Interface1, Interface2 {
    public void operation1() {
        System.out.println("B 實現了 operation1");
    }
 
    public void operation2() {
        System.out.println("B 實現了 operation2");
    }
 
    public void operation3() {
        System.out.println("B 實現了 operation3");
    }
}
 
class D implements Interface1, Interface3 {
    public void operation1() {
        System.out.println("D 實現了 operation1");
    }
 
    public void operation4() {
        System.out.println("D 實現了 operation4");
    }
 
    public void operation5() {
        System.out.println("D 實現了 operation5");
    }
}
 
class A { // A 類通過接口Interface1,Interface2 依賴(使用) B類，但是只會用到1,2,3方法
    public void depend1(Interface1 i) {
        i.operation1();
    }
 
    public void depend2(Interface2 i) {
        i.operation2();
    }
 
    public void depend3(Interface2 i) {
        i.operation3();
    }
}
 
class C { // C 類通過接口Interface1,Interface3 依賴(使用) D類，但是只會用到1,4,5方法
    public void depend1(Interface1 i) {
        i.operation1();
    }
 
    public void depend4(Interface3 i) {
        i.operation4();
    }
 
    public void depend5(Interface3 i) {
        i.operation5();
    }
}
 
public class Segregation2 {
    public static void main(String[] args) {
        A a = new A();
        a.depend1(new B()); // A類通過接口去依賴B類
        a.depend2(new B());
        a.depend3(new B());
 
        C c = new C();
        c.depend1(new D()); // C類通過接口去依賴(使用)D類
        c.depend4(new D());
        c.depend5(new D());
    }
}

4.接口隔離原則總結

類A通過接口Interface1依賴類B，類C通過接口Interfacel依賴類D，如果接口Interface1對于類A和類C來說不是最小接口，那么類B和類D必須去實現他們不需要的方法。
將接口Interface1拆分為獨立的幾個接口，類A和類C分別與他們需要的接口建立依賴關系。也就是采用接口隔離原則。

到此這篇關于Java設計模式之接口隔離原則精解的文章就介紹到這了,更多相關Java 接口隔離原則內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: