How Does Java Handle Method Name Collisions in Interface Inheritance?

Interface Inheritance with Method Name Collisions

When multiple interfaces define methods with identical names and signatures and are implemented by a single class, the compiler identifies the overridden method by considering the following:

Compatibility:

If the methods in the interfaces are method-equivalent (having compatible return types and parameter types), then only one method is inherited. In this case, the compiler does not need to differentiate which interface the method belongs to.

Example:

Consider the following code:

interface A {
  int f();
}

interface B {
  int f();
}

class Test implements A, B {
  // Only one @Override annotation required
  @Override
  public int f() { 
    // Method implementation here
    return 0;
  }
}

In this scenario, the f method in Test is considered an implementation for both A.f and B.f.

Incompatibility:

If the methods in the interfaces are not method-equivalent (having incompatible return types or parameter types), then the compiler will issue a compilation error.

Example:

In the following code, the f method in Test will result in a compilation error because the return types in the A.f and B.f are different:

interface A {
  void f();
}

interface B {
  int f();
}

class Test implements A, B {
  @Override
  public int f() { 
    // Method implementation here
    return 0;
  }
}

Consequences:

As long as the inherited methods from multiple interfaces are compatible, there is no need to distinguish which method belongs to which interface. The compiler treats them as a single method that is implemented by the class.

The above is the detailed content of How Does Java Handle Method Name Collisions in Interface Inheritance?. For more information, please follow other related articles on the PHP Chinese website!