If a type implements two interfaces, and each interface
define a method that has identical signature, then in effect there is only one method, and they are not distinguishable. If, say, the two methods have conflicting return types, then it will be a compilation error. This is the general rule of inheritance, method overriding, hiding, and declarations, and applies also to possible conflicts not only between 2 inherited interface
methods, but also an interface
and a super class
method, or even just conflicts due to type erasure of generics.
Compatibility example
Here’s an example where you have an interface Gift
, which has a present()
method (as in, presenting gifts), and also an interface Guest
, which also has a present()
method (as in, the guest is present and not absent).
Presentable johnny
is both a Gift
and a Guest
.
public class InterfaceTest {
interface Gift { void present(); }
interface Guest { void present(); }
interface Presentable extends Gift, Guest { }
public static void main(String[] args) {
Presentable johnny = new Presentable() {
@Override public void present() {
System.out.println("Heeeereee's Johnny!!!");
}
};
johnny.present(); // "Heeeereee's Johnny!!!"
((Gift) johnny).present(); // "Heeeereee's Johnny!!!"
((Guest) johnny).present(); // "Heeeereee's Johnny!!!"
Gift johnnyAsGift = (Gift) johnny;
johnnyAsGift.present(); // "Heeeereee's Johnny!!!"
Guest johnnyAsGuest = (Guest) johnny;
johnnyAsGuest.present(); // "Heeeereee's Johnny!!!"
}
}
The above snippet compiles and runs.
Note that there is only one @Override
necessary!!!. This is because Gift.present()
and Guest.present()
are “@Override
-equivalent” (JLS 8.4.2).
Thus, johnny
only has one implementation of present()
, and it doesn’t matter how you treat johnny
, whether as a Gift
or as a Guest
, there is only one method to invoke.
Incompatibility example
Here’s an example where the two inherited methods are NOT @Override
-equivalent:
public class InterfaceTest {
interface Gift { void present(); }
interface Guest { boolean present(); }
interface Presentable extends Gift, Guest { } // DOES NOT COMPILE!!!
// "types InterfaceTest.Guest and InterfaceTest.Gift are incompatible;
// both define present(), but with unrelated return types"
}
This further reiterates that inheriting members from an interface
must obey the general rule of member declarations. Here we have Gift
and Guest
define present()
with incompatible return types: one void
the other boolean
. For the same reason that you can’t an void present()
and a boolean present()
in one type, this example results in a compilation error.
Summary
You can inherit methods that are @Override
-equivalent, subject to the usual requirements of method overriding and hiding. Since they ARE @Override
-equivalent, effectively there is only one method to implement, and thus there’s nothing to distinguish/select from.
The compiler does not have to identify which method is for which interface, because once they are determined to be @Override
-equivalent, they’re the same method.
Resolving potential incompatibilities may be a tricky task, but that’s another issue altogether.
References
- JLS 8.4.2 Method Signature
- JLS 8.4.8 Inheritance, Overriding, and Hiding
- JLS 8.4.8.3 Requirements in Overriding and Hiding
- JLS 8.4.8.4 Inheriting Methods with Override-Equivalent Signatures
- “It is possible for a class to inherit multiple methods with override-equivalent signatures.”