New features of Java 8: Default interface methods

Abstract: Starting from java8, the interface is not only a place where methods can only be declared. We can also give the method a default implementation when declaring the method. We call it the default interface method, so that all children that implement the interface Classes can hold a default implementation of this 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 (only by advancing with the times can we We should be pleased that it is immortal), but after so many years of development and iteration, the source code of Java has become a behemoth, and it will definitely not be easy to make a big move 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 interface, such as the

sort(Comparator<? super E> 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 confusing to think like this. Although we do not need to design JDK, we 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 the default interface method

The definition of the default interface method is very simple, just add a

default

key before the interface method definition Just use the following words:

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

When we define a default method like this, all subclasses that implement this interface indirectly hold this method. 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 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 things that are not every For methods that all subclasses need, we give it a default implementation to avoid meaningless implementations in subclasses (generally we will throw new UnsupportedException())

2. The default method is java. Multiple inheritance provides a new way (although we can only inherit one class, 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 there are two or more default methods with the same method signature in these interfaces, a conflict will occur, java8 definition The following three principles are used to resolve conflicts:

1. Explicitly declared methods in a class or parent class have a higher priority than all default methods

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

3. If rule 2 also fails, you need to explicitly specify the interface
The following is explained through several examples:

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 what is actually called here is 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, and then class C inherits from D, and implements A and B. Although C is closer to D, because the specific implementation of D is in A, the default method in B is still the closest default implementation. According to rule 2, what is actually called here Is the default method of B.

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();
    }
}

In Example 3, interface B no longer inherits from interface A, so the default method is called in C at this time

method()

Distance interface The specific implementation distance of A and B is the same, and the compiler cannot determine it, so an error is reported. At this time, you need to specify it explicitly:

B.super.method()

.

The above is the content of the new feature of Java8, the default interface method. For more related content, please pay attention to the PHP Chinese website (m.sbmmt.com)!