Java 8 默認方法（Default Methods）

Java 8 默認方法（Default Methods） Posted by Ebn Zhang on December 20, 2015

 

Java 8 引入了新的語言特性——默認方法（Default Methods）。

Default methods enable new functionality to be added to the interfaces of libraries and ensure binary compatibility with code written for older versions of those interfaces.

默認方法允許您添加新的功能到現有庫的接口中，並能確保與采用舊版本接口編寫的代碼的二進制兼容性。

默認方法是在接口中的方法簽名前加上了 default 關鍵字的實現方法。

一個簡單的例子

1 2 3 4 5 6 7 8 9 10 11 12 13 14

interface InterfaceA { default void foo() { System.out.println("InterfaceA foo"); } } class ClassA implements InterfaceA { } public class Test { public static void main(String[] args) { new ClassA().foo(); // 打印：“InterfaceA foo” } }

ClassA 類並沒有實現 InterfaceA 接口中的 foo 方法，InterfaceA 接口中提供了 foo 方法的默認實現，因此可以直接調用 ClassA 類的 foo 方法。

為什么要有默認方法

在 java 8 之前，接口與其實現類之間的 耦合度 太高了（tightly coupled），當需要為一個接口添加方法時，所有的實現類都必須隨之修改。默認方法解決了這個問題，它可以為接口添加新的方法，而不會破壞已有的接口的實現。這在 lambda 表達式作為 java 8 語言的重要特性而出現之際，為升級舊接口且保持向后兼容（backward compatibility）提供了途徑。

1 2 3 4 5 6 7

String[] array = new String[] { "hello", ", ", "world", }; List<String> list = Arrays.asList(array); list.forEach(System.out::println); // 這是 jdk 1.8 新增的接口默認方法

這個 forEach 方法是 jdk 1.8 新增的接口默認方法，正是因為有了默認方法的引入，才不會因為 Iterable 接口中添加了 forEach 方法就需要修改所有 Iterable 接口的實現類。

下面的代碼展示了 jdk 1.8 的 Iterable 接口中的 forEach 默認方法：

1 2 3 4 5 6 7 8 9 10 11 12 13

package java.lang; import java.util.Objects; import java.util.function.Consumer; public interface Iterable<T> { default void forEach(Consumer<? super T> action) { Objects.requireNonNull(action); for (T t : this) { action.accept(t); } } }

默認方法的繼承

和其它方法一樣，接口默認方法也可以被繼承。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

interface InterfaceA { default void foo() { System.out.println("InterfaceA foo"); } } interface InterfaceB extends InterfaceA { } interface InterfaceC extends InterfaceA { @Override default void foo() { System.out.println("InterfaceC foo"); } } interface InterfaceD extends InterfaceA { @Override void foo(); } public class Test { public static void main(String[] args) { new InterfaceB() {}.foo(); // 打印：“InterfaceA foo” new InterfaceC() {}.foo(); // 打印：“InterfaceC foo” new InterfaceD() { @Override public void foo() { System.out.println("InterfaceD foo"); } }.foo(); // 打印：“InterfaceD foo” // 或者使用 lambda 表達式 ((InterfaceD) () -> System.out.println("InterfaceD foo")).foo(); } }

接口默認方法的繼承分三種情況（分別對應上面的 InterfaceB 接口、InterfaceC 接口和 InterfaceD 接口）：

• 不覆寫默認方法，直接從父接口中獲取方法的默認實現。

• 覆寫默認方法，這跟類與類之間的覆寫規則相類似。

• 覆寫默認方法並將它重新聲明為抽象方法，這樣新接口的子類必須再次覆寫並實現這個抽象方法。

默認方法的多繼承

Java 使用的是單繼承、多實現的機制，為的是避免多繼承帶來的調用歧義的問題。當接口的子類同時擁有具有相同簽名的方法時，就需要考慮一種解決沖突的方案。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

interface InterfaceA { default void foo() { System.out.println("InterfaceA foo"); } } interface InterfaceB { default void bar() { System.out.println("InterfaceB bar"); } } interface InterfaceC { default void foo() { System.out.println("InterfaceC foo"); } default void bar() { System.out.println("InterfaceC bar"); } } class ClassA implements InterfaceA, InterfaceB { } // 錯誤 //class ClassB implements InterfaceB, InterfaceC { //} class ClassB implements InterfaceB, InterfaceC { @Override public void bar() { InterfaceB.super.bar(); // 調用 InterfaceB 的 bar 方法 InterfaceC.super.bar(); // 調用 InterfaceC 的 bar 方法 System.out.println("ClassB bar"); // 做其他的事 } }

在 ClassA 類中，它實現的 InterfaceA 接口和 InterfaceB 接口中的方法不存在歧義，可以直接多實現。

在 ClassB 類中，它實現的 InterfaceB 接口和 InterfaceC 接口中都存在相同簽名的 foo 方法，需要手動解決沖突。覆寫存在歧義的方法，並可以使用 InterfaceName.super.methodName(); 的方式手動調用需要的接口默認方法。

接口繼承行為發生沖突時的解決規則

值得注意的是這么一種情況：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

interface InterfaceA { default void foo() { System.out.println("InterfaceA foo"); } } interface InterfaceB extends InterfaceA { @Override default void foo() { System.out.println("InterfaceB foo"); } } // 正確 class ClassA implements InterfaceA, InterfaceB { } class ClassB implements InterfaceA, InterfaceB { @Override public void foo() { // InterfaceA.super.foo(); // 錯誤 InterfaceB.super.foo(); } }

當 ClassA 類多實現 InterfaceA 接口和 InterfaceB 接口時，不會出現方法名歧義的錯誤。當 ClassB 類覆寫 foo 方法時，無法通過 InterfaceA.super.foo(); 調用 InterfaceA 接口的 foo 方法。

因為 InterfaceB 接口繼承了 InterfaceA 接口，那么 InterfaceB 接口一定包含了所有 InterfaceA 接口中的字段方法，因此一個同時實現了 InterfaceA 接口和 InterfaceB 接口的類與一個只實現了 InterfaceB 接口的類完全等價。

這很好理解，就相當於 class SimpleDateFormat extends DateFormat 與 class SimpleDateFormat extends DateFormat, Object 等價（如果允許多繼承）。

或者換種方式理解：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

class ClassC { public void foo() { System.out.println("ClassC foo"); } } class ClassD extends ClassC { @Override public void foo() { System.out.println("ClassD foo"); } } public class Test { public static void main(String[] args) { ClassC classC = new ClassD(); classC.foo(); // 打印：“ClassD foo” } }

這里的 classC.foo(); 同樣調用的是 ClassD 類中的 foo 方法，打印結果為“ClassD foo”，因為 ClassC 類中的 foo 方法在 ClassD 類中被覆寫了。

在上面的 ClassA 類中不會出現方法名歧義的原因是所謂“存在歧義”的方法其實都來自於 InterfaceA 接口，InterfaceB 接口中的“同名方法”只是繼承自 InterfaceA 接口而來並對其進行了覆寫。ClassA 類實現的兩個接口不是兩個毫不相干的接口，因此不存在同名歧義方法。

而覆寫意味着對父類方法的屏蔽，這也是 Override 的設計意圖之一。因此在實現了 InterfaceB 接口的類中無法訪問已被覆寫的 InterfaceA 接口中的 foo 方法。

這是當接口繼承行為發生沖突時的規則之一，即 被其它類型所覆蓋的方法會被忽略。

如果想要調用 InterfaceA 接口中的 foo 方法，只能通過自定義一個新的接口同樣繼承 InterfaceA 接口並顯示地覆寫 foo方法，在方法中使用 InterfaceA.super.foo(); 調用 InterfaceA 接口的 foo 方法，最后讓實現類同時實現 InterfaceB接口和自定義的新接口，代碼如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

interface InterfaceA { default void foo() { System.out.println("InterfaceA foo"); } } interface InterfaceB extends InterfaceA { @Override default void foo() { System.out.println("InterfaceB foo"); } } interface InterfaceC extends InterfaceA { @Override default void foo() { InterfaceA.super.foo(); } } class ClassA implements InterfaceB, InterfaceC { @Override public void foo() { InterfaceB.super.foo(); InterfaceC.super.foo(); } }

注意！ 雖然 InterfaceC 接口的 foo 方法只是調用了一下父接口的默認實現方法，但是這個覆寫 不能省略，否則 InterfaceC 接口中繼承自 InterfaceA 接口的隱式的 foo 方法同樣會被認為是被 InterfaceB 接口覆寫了而被屏蔽，會導致調用 InterfaceC.super.foo() 時出錯。

通過這個例子，應該注意到在使用一個默認方法前，一定要考慮它是否真的需要。因為 默認方法會帶給程序歧義，並且在復雜的繼承體系中容易產生編譯錯誤。濫用默認方法可能給代碼帶來意想不到、莫名其妙的錯誤。

接口與抽象類

當接口繼承行為發生沖突時的另一個規則是，類的方法聲明優先於接口默認方法，無論該方法是具體的還是抽象的。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

interface InterfaceA { default void foo() { System.out.println("InterfaceA foo"); } default void bar() { System.out.println("InterfaceA bar"); } } abstract class AbstractClassA { public abstract void foo(); public void bar() { System.out.println("AbstractClassA bar"); } } class ClassA extends AbstractClassA implements InterfaceA { @Override public void foo() { InterfaceA.super.foo(); } } public class Test { public static void main(String[] args) { ClassA classA = new ClassA(); classA.foo(); // 打印：“InterfaceA foo” classA.bar(); // 打印：“AbstractClassA bar” } }

ClassA 類中並不需要手動覆寫 bar 方法，因為優先考慮到 ClassA 類繼承了的 AbstractClassA 抽象類中存在對 bar 方法的實現，同樣的因為 AbstractClassA 抽象類中的 foo 方法是抽象的，所以在 ClassA 類中必須實現 foo 方法。

雖然 Java 8 的接口的默認方法就像抽象類，能提供方法的實現，但是他們倆仍然是 不可相互代替的：

• 接口可以被類多實現（被其他接口多繼承），抽象類只能被單繼承。

• 接口中沒有 this 指針，沒有構造函數，不能擁有實例字段（實例變量）或實例方法，無法保存 狀態（state），抽象方法中可以。

• 抽象類不能在 java 8 的 lambda 表達式中使用。

• 從設計理念上，接口反映的是 “like-a” 關系，抽象類反映的是 “is-a” 關系。

接口靜態方法

除了默認方法，Java 8 還在允許在接口中定義靜態方法。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

interface InterfaceA { default void foo() { printHelloWorld(); } static void printHelloWorld() { System.out.println("hello, world"); } } public class Test { public static void main(String[] args) { InterfaceA.printHelloWorld(); // 打印：“hello, world” } }

其他注意點

• default 關鍵字只能在接口中使用（以及用在 switch 語句的 default 分支），不能用在抽象類中。

• 接口默認方法不能覆寫 Object 類的 equals、hashCode 和 toString 方法。

• 接口中的靜態方法必須是 public 的，public 修飾符可以省略，static 修飾符不能省略。

• 即使使用了 java 8 的環境，一些 IDE 仍然可能在一些代碼的實時編譯提示時出現異常的提示（例如無法發現 java 8 的語法錯誤），因此不要過度依賴 IDE。

•