一文帶你認識Java8中接口的默認方法

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