一文带你认识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