Java 8 default method inheritance

Question

Let's say there are following types:

public interface Base {

    default void sayHi(){
        System.out.println("hi from base");
    }
}

public interface Foo extends Base {
    @Override
    default void sayHi(){
        System.out.println("hi from foo");
    }
}

public interface Bar extends Base {
}

public class MyClass implements Foo, Bar {
    public static void main(String[] args) {
        MyClass c = new MyClass();
        c.sayHi();
    }
}

In this scenario, if main is executed, "hi from foo" is printed. Why does Foo's implementation take precedence? Doesn't Bar inherit sayHi() from Base, since if MyClass was to only implement Bar, the Base implementation would be called? So it would make sense for the code to still not compile. Also, since Bar should have Base's implementation of sayHi(), why can't I override it in MyClass like:

@Override
public void sayHi() {
    Bar.super.sayHi();
}

The following error occurs when trying to do so:

bad type qualifier Bar in default super call method, sayHi() is overridden in Foo

Answer 1

This behavior is specified using almost your exact example in JLS 9.4.1, just with some names changed around:

interface Top {
    default String name() { return "unnamed"; }
}
interface Left extends Top {
    default String name() { return getClass().getName(); }
}
interface Right extends Top {}

interface Bottom extends Left, Right {}

Right inherits name() from Top, but Bottom inherits name() from Left, not Right. This is because name() from Left overrides the declaration of name() in Top.

The JLS doesn't seem to give any especially concrete reason that I can see; this is just how the Java designers decided inheritance would work.

Answer 2

This is by design. From JLS 15.12.3:

If the form is TypeName . super . [TypeArguments] Identifier, then:

• If TypeName denotes an interface, let T be the type declaration immediately enclosing the method invocation. A compile-time error occurs if there exists a method, distinct from the compile-time declaration, that overrides (§9.4.1) the compile-time declaration from a direct superclass or direct superinterface of T.

In the case that a superinterface overrides a method declared in a grandparent interface, this rule prevents the child interface from "skipping" the override by simply adding the grandparent to its list of direct superinterfaces. The appropriate way to access functionality of a grandparent is through the direct superinterface, and only if that interface chooses to expose the desired behavior. (Alternately, the developer is free to define his own additional superinterface that exposes the desired behavior with a super method invocation.)