New features of Java8 - default interface method

1. The background of introducing default interface methods

 Java8 can be regarded as the version that has changed the most in the iterative process of Java version updates (we should be happy to keep pace with the times to survive), but after so many years of development And iteration, the source code of Java is already a giant, and it will definitely not be easy to work on such a huge volume. So when I saw the default interface methods of Java 8 for the first time, my first feeling was that this was a hole dug by Java designers before they filled it.
From the previous explanations, we know that java8 has added many methods to the existing interfaces, such as the sort(Comparator0d74ac1b2f8f9ab0eb66f930789a9645 c) method of List. If you follow the design ideas of interfaces before Java 8, when adding a method declaration to an interface, the class that implements the interface must add a corresponding implementation for the newly added method. Considering compatibility, this is not advisable, so it is a pitfall, and new features require adding some new methods to the interface. In order to have the best of both worlds, the designers of Java8 proposed the default interface method the concept of.
In this way, the default interface method seems to be developed for API designers, which is still far away from us ordinary developers. It is a bit TuSimple to think like this. Although we do not need to design jdk, we are still in the daily development process There will still be a need to provide APIs for other business parties to call. When we update our APIs, we can use the default method to provide more advanced functions while maintaining compatibility.

2. Definition of default interface method

  The definition of default interface method is very simple, just add a default keyword before the method definition of the interface, as follows:

public interface A {    /**
     * 默认方法定义
     */
    default void method() {
        System.out.println("This is a default method!");
    }

}

When we define a default method like this, all implementations Subclasses of this interface all hold this method indirectly. Or you may feel like me that interfaces and abstract classes are becoming more and more similar, indeed, but there are still the following differences between them:

1. A class can only inherit one class, but it can implement multiple interfaces

2. Abstract classes can define variables, but interfaces cannot

    In addition to solving the problems we mentioned above, abstraction also has the following benefits:

   1. For some methods that are not required by every subclass, we give it a default implementation , thus avoiding our meaningless implementation in subclasses (generally we will throw new UnsupportedException())

   2. The default method provides a new way for multiple inheritance in Java (although we can only inherit one class, but We can implement multiple interfaces, and now interfaces can also define default methods)

   
   

3. Conflicts and their solutions

Because a class can implement multiple interfaces, when a class implements multiple Interfaces, and conflicts will occur when there are two or more default methods with the same method signature in these interfaces. Java8 defines the following three principles to resolve conflicts:

1. For methods explicitly declared in a class or parent class, their The priority is higher than all default methods

2. If rule 1 fails, select the default method with specific implementation closest to the current class

3. If rule 2 also fails, you need to show

The following are several examples to illustrate:

Example 1

public interface A {    /**
     * 默认方法定义
     */
    default void method() {
        System.out.println("A's default method!");
    }

}public interface B extends A {    /**
     * 默认方法定义
     */
    default void method() {
        System.out.println("B's default method!");
    }

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

}// 输出：B's default method!

Here, because interface B is closer to C than A, and the method of B is a specific default implementation, according to rule 2, so this What is actually called is the default method of interface B

Example 2

public class D implements A {
}public class C extends D implements A, B {    public static void main(String[] args) {        new C().method();
    }

}// 输出：B's default method!

Example 2 adds a class D that implements interface A on the basis of the original interfaces A and B. Then class C inherits from D and implements A. and B. Although C is closer to D here, because the specific implementation of D is in A, the default method in B is still the closest default implementation. According to rule 2, the default method of B is actually called here. .

Example 3

// A接口不变public interface B {    /**
     * 默认方法定义
     */
    default void method() {
        System.out.println("B's default method!");
    }

}public class C implements A, B {    @Override
    public void method() {        // 必须显式指定
        B.super.method();
    }    public static void main(String[] args) {        new C().method();
    }

}

例3中接口B不再继承自接口A，所以此时C中调用默认方法method()距离接口A和B的具体实现距离相同，编译器无法确定，所以报错，此时需要显式指定：B.super.method()。