Java8是Oracle於2014年3月釋出的一個重要版本，其API在現存的介面上引入了非常多的新方法。

例如，Java8的List介面新增了sort方法。在Java8之前，則每個實現了List介面的類必須定義sort方法的實現，或者從父類中繼承它的實現。想象一下，如果List介面的繼承體系非常龐雜，那麼整個集合框架的維護量有多麼大！

為此，在Java8中引入了一種新的機制：介面支援申明帶實現的方法。

預設方法

前文提到了Java8中List介面新增了sort方法，其原始碼如下：

public interface List<E> extends Collection<E> {
    
    // ...其他成員
        
    default void sort(Comparator<? super E> c) {
      ...
      ...
    }
}
 

可以看到，這個新增的sort方法有方法體，由default修飾符修飾，這就是介面的預設方法。

很顯然，預設方法不是static的，所以必須由介面的實現類的例項來呼叫這些預設方法。

下面自定義一個介面，練習使用預設方法。

public interface Sized {
    // 普通抽象方法，預設是public abstract修飾的，沒有方法體
    int size();

    /*
     * 預設方法，有方法體
     * 任何一個實現了Sized介面的類都會向動繼承isEmpty的實現
     */
    default boolean isEmpty() {
        return this.size() == 0;
    }
}
 

其實，隨著JDK版本的不斷升級，API在不斷演進，預設方法在Java8的API中已經大量地使用了，上面List介面中的sort方法就是其中一個。

和抽象類的區別

有同學可能發現了，Java8中加入了預設方法的介面，這不就是以前的抽象類嗎？其實，兩者還是有區別的。

• 一個類只能繼承一個抽象類；但是一個類可以實現多個介面。
• 抽象類有例項變數，而介面只能有類變數

解決衝突

我們知道Java語言中一個類只能繼承一個父類，但是一個類可以實現多個介面。隨著預設方法在Java8中的引入，有可能出現一個類繼承了多個簽名一樣的方法。這種情況下，類會選擇使用哪一個函式呢？

為解決這種多繼承關係，Java8提供了下面三條規則：

1. 類中的方法優先順序最高，類或父類中宣告的方法的優先順序高於任何宣告為預設方法的優先順序。
2. 如果第一條無法判斷，那麼子介面的優先順序更高：方法簽名相同時，優先選擇擁有最具體實現的預設方法的介面， 即如果B繼承了A，那麼B就比A更加具體。
3. 最後，如果還是無法判斷，繼承了多個介面的類必須通過顯式覆蓋和呼叫期望的方法， 顯式地選擇使用哪一個預設方法的實現。

讓我們一起看幾個例子 。

場景1：

public interface A {
    default void hello() {
        System.out.println("hello from A");
    }
}

public interface B extends A {
    default void hello() {
        System.out.println("hello from B");
    }
}

public class C implements A, B {
    public static void main(String[] args) {
        new C().hello();
    }
}

如圖1，是這個場景的UML圖。

我們對照上面三條規則來看，類C中main()方法會輸出什麼？

1. 規則(1))不滿足。
2. 因為B繼承了A，所以B比A更具體，所以應該選擇B的hello()方法。所以，程式會列印輸出"hello from B"。

場景2：

如果C像下面這樣繼承了D，會怎麼樣？

public class D implements A {

}

public class C extends D implements A, B {
    public static void main(String[] args) {
        new C().hello();
    }
}

如圖2，是這個場景的UML圖。

同樣，我們對照著三條規則來看：

1. C雖然繼承了D，但D中未覆蓋A的預設方法。
2. 接著，編譯器會在A和B中做選擇，由於B更具體，所以，程式會列印輸出"hello from B"。

場景3：

將上面的D稍作修改：

public class D implements A {
    public void hello() {
        System.out.println("hello from D");
    }
}

結果又如何？

由於依據規則(1)，父類中宣告的方法具有更高的優先順序，所以程式會列印輸出"hello from D"。

場景4：

假設現在B不在繼承A：

public interface A {
    default void hello() {
        System.out.println("hello from A");
    }
}

public interface B {
    default void hello() {
        System.out.println("hello from B");
    }
}

public class C implements A, B {
    public static void main(String[] args) {
        new C().hello();
    }
}

如圖3，是這個場景的UML圖。

此時，由於編譯器無法識別A還是B的實現更加具體，所以會丟擲編譯錯誤：”C inherits unrelated defaults for hello() from types A and B“。

像這種場景要解決衝突，可以在C中覆蓋hello()方法並在方法內顯示的選擇呼叫A還是B的方法。

呼叫方式如下：

public class C extends D implements A, B {
    public void hello() {
        // 顯式地選擇呼叫介面B中的方法
        // 同理，要呼叫介面A中的方法，可以這樣：A.super.hello()
        B.super.hello();
    }

    public static void main(String[] args) {
        // 輸出 hello from B
        new C().hello();
    }
}

場景5：

public interface A {
    default void hello() {
        System.out.println("hello from A");
    }
}

public interface B extends A{

}

public interface C extends A{

}

public class D implements B, C {
    public void hello() {
        new D().hello();
    }
}

此時，只有一個方法申明可以選擇，所以程式會輸出"hello from A"。

END

相關推薦