Multiple inheritance quagmire - which class is instantiated?

Question

Supposing I have the following classes:

abstract class A {
    static abstract class _Foo {}
}

class B extends A {
    static void doSomething() {
        System.out.println(C.saySomething());
    }

    static _Foo getInner() {
        return new C._Foo();
    }

    static abstract class _Foo extends A._Foo {}
}

final class C extends D {
    static String saySomething() {
        return "Something";
    }
}

abstract class D {
    static class _Foo extends B._Foo {
        public int value() {
            return 42;
        }
    }
}

To provide some context:

All of these classes reside in the same package.
Class C and D are generated at compile time
Class A as well as C are never instantiated; they simply provide some behaviour for class B
Class B is the only one that is actually used.
Class D is unknown until after compile time, which is why we are only using C in B.

This is similar to what one might expect when working with google autovalue

My question is with regards to the getInner function in B:

Which _Foo will be instantiated at the line return new C._Foo();? The _Foo in D or the one in A?
Is this undefined behaviour as to which gets instantiated or is it documented? Please provide documentation if possible
How is the order determined?

The last question is just as an FYI, I'm mostly interested in the first two.

Thanks for your help.

https://stackoverflow.com/questions/9898097/what-are-the-rules-dictating-the-inheritance-of-static-variables-in-java — Elliott Frisch, Aug 22 '18 at 02:36
@JimGarrison I will once I get a chance to, but I was mostly asking to see if someone has a link to some documentation that describes this behaviour. Even if I find out which one is instantiated, I still need to know if I am relying on undefined behaviour or not — smac89, Aug 22 '18 at 02:46
I am not sure how you could imaging getting an A._Foo on that line - you've explicitly qualified the expression to be `new C._Foo()` - so it has to be the _Foo that is exposed through C, which has to be the one from D... (though I confess I expected the compile to complain that there was no _Foo explicitly in C...) — moilejter, Aug 22 '18 at 03:16
@moilejter, that makes sense. I don't know what I was thinking yesterday — smac89, Aug 22 '18 at 15:15

score 1 · Accepted Answer · answered Aug 22 '18 at 05:33

To answer your three questions...

An instance of the _Foo in D will be returned from new C._Foo().
No, it isn't; the _Foos are "members" of the classes they are declared in, so they are inherited much like variables. (In this case, like static variables.) [Spec] (https://docs.oracle.com/javase/specs/jls/se8/html/jls-8.html#jls-8.2). (This is the best documentation I could muster up.)
The order is determined by what is immediately inherited by class C. Since C extends D, C will inherit whatever D has (i.e. D._Foo). If D didn't declare a class called _Foo, then D would inherit B's _Foo, and then C would inherit that.

Hope this helps. :)

Multiple inheritance quagmire - which class is instantiated?

1 Answers1