Super class method and Interface default method conflict resolution
Asked Answered
A

3

13

Consider the below example,

public class Testing extends SupCls implements Intf {
    public static void main(String[] args) {
        new Testing().test();
    }
}

class SupCls {
    public void test() {
        System.out.println("From SupCls");
    }
}

interface Intf {
    public default void test() {
        System.out.println("From Intf");
    }
}

As you can see, there's no connection between SupCls class and Intf interface. But both are defining a common method.

And Testing class is extending SupCls and implementing Intf.

So, when I call test() method on Testing the output is,

From SupCls

Which I think makes sense because extending from a class should take higher priority than implementing from an interface.

But eclipse reports otherwise, as shown in the below screen capture.

Screen Capture of Eclipse

I strongly believe this is a bug in Eclipse.

But before assuming, is this behavior defined & documented in the JLS? Or is there something else which defines this behavior?

Edit: Eclipse version is Mars Release (4.5.0), if it matters.

Aplomb answered 9/9, 2015 at 4:59 Comment(3)
Should be a bug in eclipse. Default methods are part of Java8 and this scenario wouldn't have made sense for JDK 7 or below.Hildegard
Its eclipse default behavior. It shows interface method instead of super class method. In Even below java 1.8 It shows interface methods(Even its not a default method)Fronia
Check Rule #1 regarding default method Mail From Brian GoetzGeyserite
R
12

Your assumption is right, the concrete method inherited from the superclass takes precedence over the default method from the interface:

JLS §8.4.8. Inheritance, Overriding, and Hiding

A class C inherits from its direct superclass and direct superinterfaces all abstract and default (§9.4) methods m for which all of the following are true:

  • No method declared in C has a signature that is a subsignature (§8.4.2) of the signature of m.
  • No concrete method inherited by C from its direct superclass has a signature that is a subsignature of the signature of m.

The second cited bullet applies here, there is a concrete method inherited from the direct superclass with an appropriate signature, so the default method is not inherited.

The documentation even clears any doubt with an additional remark:

Note that it is possible for an inherited concrete method to prevent the inheritance of an abstract or default method. (Later we will assert that the concrete method overrides the abstract or default method "from C".)

So it’s like SupCls.test() overrides Intf.test() when it comes to class Testing.

In other words, you are right, it’s a bug in Eclipse, but as long as it only affects the way the proposal is rendered, I’d consider it a minor bug. The inserted source will be the same, regardless of whether a D has been rendered in the proposal or not.

Remsen answered 9/9, 2015 at 11:12 Comment(0)
E
5

This certainly is a bug in eclipse but in the code completion proposals rather than in the compiler. Hovering over the call to test or Open Declaration take you to the SupCls method and running the code correctly prints "From SupCls" which proves this. Please file a bug against jdt ui for investigation

Establishment answered 9/9, 2015 at 8:30 Comment(0)
G
2

Looks like eclipse version matters!

In Eclipse Luna (4.4.1) the reference points to SupCls instead of Intf

enter image description here

Probably a bug in Eclipse Mars

Gynaecology answered 9/9, 2015 at 7:31 Comment(0)

© 2022 - 2024 — McMap. All rights reserved.