一塊兒來學Java8(五)——接口默認方法

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

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

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

可是在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()

接口實現

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

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.方法名get

如:MyInterface.super.say();io

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系統的判斷規則。

按期分享技術乾貨,一塊兒學習,一塊兒進步!

相關文章
相關標籤/搜索