How Does Java Handle Multiple Interfaces with Identical Method Signatures?

Implementing Multiple Interfaces with Same Method Signatures

In Java, when a class implements multiple interfaces that define methods with the same name and signature, the question arises: which method is overridden?

According to the Java Language Specification (JLS), the compiler will determine the method to be overridden based on the following rule:

Inherited methods from multiple interfaces are considered "override-equivalent" (JLS 8.4.8.4) if they have the same signature. Therefore, only one method implementation is necessary.

Example:

public class Test implements A, B {   <br>  public static void main(String... args) throws Exception{   </p>
<p>}</p>
<p>@Override<br>  public int f() {  // from which interface A or B</p>
<pre class="brush:php;toolbar:false">return 0;

}
}

In this code, class Test implements interfaces A and B, which both have a method named f() with the same signature. Since these methods are override-equivalent, it doesn't matter which interface's f() method is overridden by Test.f(). Only one implementation is required, and the compiler will not distinguish between the two interfaces.

This behavior extends to inheritance and method hiding. If an interface method conflicts with a method in the superclass or another interface, the conflicting methods must be override-equivalent for the code to be valid.

Compatibility Example:

<br>public interface Gift  { void present(); }<br>public interface Guest { void present(); }</p>
<p>public class Presentable implements Gift, Guest { <br>  @Override <br>  public void present() {</p>
<pre class="brush:php;toolbar:false">System.out.println("Heeeereee's Johnny!!!");

}
}

Here, both Gift and Guest have a present() method. The Presentable class implements both interfaces and provides a single implementation for present(). The compiler recognizes that these methods are override-equivalent and does not require separate implementations.

Incompatibility Example:

<br>public interface Gift  { void present(); }<br>public interface Guest { boolean present(); }</p>
<p>public class Presentable implements Gift, Guest {  // DOES NOT COMPILE!!!<br>  // Error: types Gift and Guest are incompatible<br>}<br>

In this case, the return types of present() methods are different. According to JLS 8.4.8.3, overriding methods must have compatible signatures and return types. Since Gift.present() and Guest.present() do not have compatible return types, the code does not compile.

In summary, when implementing multiple interfaces with same method signatures, the compiler will identify the method to be overridden as the one that is override-equivalent. This means that only one method implementation is required, regardless of which interface defines the method.

The above is the detailed content of How Does Java Handle Multiple Interfaces with Identical Method Signatures?. For more information, please follow other related articles on the PHP Chinese website!