一塊兒來學Java8（五）——接口默認方法

Java8新加入一個特性，容許在接口方法中給定一個默認實現。前提是在方法前面加一個default關鍵字。

public interface InterfaceMethod {
	default void say() {
		System.out.println("hello");
	}
	
	default int getAge() {
		return 1;
	}
}

這種設計看起來是有點違背接口設計原則的，由於當初規定接口中的全部方法都是抽象方法，須要子類去實現它。

可是在Java8中不得不打破這種規則，Java設計者們也有苦衷，考慮到這樣一種狀況，若是要在接口中新增一個方法，那麼以前已經實現它的那些類必然要實現新增的方法。若是接口實現類比較多的話那改起來會很是痛苦，這種牽一髮而動全身的行爲顯然是不可取的。

因而Java8就有了接口默認方法這個特性，如此一來在接口中新增一個默認方法，對於其下面的實現類是無感知的。

Java系統中的接口默認方法很是多，好比一些函數式接口和集合接口就有定義它的默認方法，常見的有如下幾個

• java.util.function.Predicate.and(Predicate<? super T>)
• java.util.function.Function.compose(Function<? super V, ? extends T>)
• java.util.Collection.stream()

接口實現

接口中已經有默認方法後，其實現類不用實現這個默認方法

interface MyInterface {
	default void say() {
		System.out.println("hello");
	}
}

public class MyClass implements MyInterface {

}

固然也能夠覆蓋重寫這個默認方法

public class MyClass implements MyInterface {
	@Override
	public void say() {
		System.out.println("goodbye");
	}
}

若是要在覆蓋的方法中調用原來的默認方法，格式以下：

接口名字.super.方法名

如：MyInterface.super.say();

public class MyClass implements MyInterface {
	@Override
	public void say() {
		System.out.println("goodbye");
		// 調用默認方法
		MyInterface.super.say();
	}
	
	public static void main(String[] args) {
		new MyClass().say();
	}
}

多重繼承問題

並列多繼承

有了接口默認方法這個新特性後，會帶來一些新的問題，假如兩個接口A,B都有一個統一的默認方法 void say()，若是一個類同時實現這兩個接口會發生什麼狀況呢。

interface A {
	default void say() {
		System.out.println("A");
	}
}

interface B {
	default void say() {
		System.out.println("B");
	}
}

static class MyClass implements A,B {
    
}

很顯然這種狀況是不容許的，編譯會報錯。

若是把接口B的方法改成抽象方法，會發生什麼狀況呢

interface A {
	default void say() {
		System.out.println("A");
	}
}

interface B {
	void say();
}

static class MyClass implements A, B {

}

這個編譯也是會報錯的，提示須要實現接口B中的方法

static class MyClass implements A, B {
    // 實現B
	@Override
	public void say() {
		System.out.println("myclass");
	}
}

這個時候若是調用say方法會調用MyClass中的實現方法

new MyClass().say(); 輸出myclass，若是想要調用接口A中默認方法，則能夠這樣寫：

static class MyClass implements A, B {
	@Override
	public void say() {
		// 調用A接口中的默認方法
		A.super.say();
		System.out.println("myclass");
	}
	
	public static void main(String[] args) {
		new MyClass().say();
	}
}

間接多繼承

在上面的例子中，若是把接口B改爲繼承接口A，而後調用say方法會打印什麼內容呢？

interface A {
	default void say() {
		System.out.println("A");
	}
}

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

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

輸出B

爲何是B而不是A呢，這裏Java列出三條規則，在遇到這種方法衝突的狀況下，可參考這三條規則

1. 類中的方法優先級最高
2. 子接口的優先級最高，優先選擇有具體實現的默認方法接口。
3. 顯示覆蓋並調用指定接口的默認方法。

在上面的例子中，經過規則2能夠看到，B繼承了A，那麼B中的方法優先級最高，所以打印B。

那麼第三條規則是什麼意思呢，回到一開始提到的例子，並列繼承

interface A {
	default void say() {
		System.out.println("A");
	}
}

interface B {
	default void say() {
		System.out.println("B");
	}
}

static class MyClass implements A, B {

}

這裏編譯報錯，解決方式爲重寫say方法，並指定調用哪一個接口中的默認方法：

static class MyClass implements A, B {
	@Override
	public void say() {
		A.super.say();
	}
}

菱形繼承

菱形繼承是C++中遇到的一個問題，C++支持多重繼承，可是會存在一個問題。

有一個類A，A中有個say方法，B繼承A，C繼承A，而後MyClass繼承了B和C，以下表示

A
 ╱    ╲   
B       C
 ╲    ╱
 MyClass

繼承圖很像一個菱形，此時在若是調用myClass.say()在C++下會報request for member 'say' is ambiguous錯誤。

那麼在Java8下會是怎樣的狀況呢？一塊兒來看下面的代碼：

public class RhombusTest {

    interface A {
        default void say() {
            System.out.println("A");
        }
    }

    interface B extends A {}
    interface C extends A {}

    static class MyClass implements B,C {}

    public static void main(String[] args) {
        new MyClass().say();
    }
}

上面的代碼會編譯經過並打印A。

根據規則2:子接口的優先級最高，優先選擇有具體實現的默認方法接口。B和C都擁有A的默認方法，有具體實現的默認方法在A當中，最終仍是會選擇A。此時若是在B中添加一個一樣的方法

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

那麼根據就近原則，優先選擇B。若是把B中的方法改爲抽象方法，那麼會編譯報錯，提示須要實現B中的方法，由於選擇了B，可是沒有具體實現。

interface B extends A {
    void say();
}

總結

本篇主要介紹了Java8中的接口默認方法，以及在多重繼承的狀況下Java系統的判斷規則。

按期分享技術乾貨，一塊兒學習，一塊兒進步！