Java中接口隔離原則是什么

小編給大家分享一下Java中接口隔離原則是什么，相信大部分人都還不怎么了解，因此分享這篇文章給大家參考一下，希望大家閱讀完這篇文章后大有收獲，下面讓我們一起去了解一下吧！

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.接口隔離原則總結

1. 類A通過接口Interface1依賴類B，類C通過接口Interfacel依賴類D，如果接口Interface1對于類A和類C來說不是最小接口，那么類B和類D必須去實現他們不需要的方法。

2. 將接口Interface1拆分為獨立的幾個接口，類A和類C分別與他們需要的接口建立依賴關系。也就是采用接口隔離原則。

以上是“Java中接口隔離原則是什么”這篇文章的所有內容，感謝各位的閱讀！相信大家都有了一定的了解，希望分享的內容對大家有所幫助，如果還想學習更多知識，歡迎關注億速云行業資訊頻道！