Inner/Outer classes - curious matter

Question

Hi,
This is from Sun Certified Programmer practice exam:
class Outer {
   class Inner {}
class ExtendedOuter extends Outer {
   class ExtendedInner extends Inner {}
class Main extends Outer.Inner {
   Main( Outer ref ) {
        ref.super();
   public static void main( String[] args ) {
        new Main( new ExtendedOuter() );
}The choices are:
A) Compilation fails
B) An exception is thrown at runtime
C) The code runs with no output
My answer was A because the line ref.super() doesn't make sense to me.
But the correct answer is C.
As far I as knew - super is a keyword and can be used either to access hidden members of the superclass, or to invoke specific constructor from the superclass also. What is it here???
Could somebody explain what this line does?

Answer 1

Is that because class files with no declared package
location are automatically placed in the same
package?Classes with no declared package are all part of an unnamed package, commonly referred to as the default package.
In general, you should always use packages, as support for unnamed packages is implementation dependent (although all compilers and JVMs must support an unnamed package). Depending on the platform you are using, the unnamed package might include all directories and jar files on your classpath, just the current working directory, just the first directory on your classpath, or something else.
But `ref' is not an instance of Main, but is an
instance of ExtendedOuter (whose superclass is
Object). Actually ExtendedOuter's superclass is Outer. However all that is important is that it is an instance of Outer, since the type checking is performed at compile time.
So how can it be calling Main's?Because it is a superclass constructor invocation in class Main. Therefore it calls a constructor in Main's superclass. This is the syntax used to call a superclass constructor where the superclass is an inner class and the enclosing instance needs to be specified. ref is the object to be used as the enclosing instance - there is no clever trick to it - it is just a syntax.
Also, if an instance of an innerclass exists, than an
instance of it's outerclass must also exist. Yes, in the example the outer class instance is ref.
Then
won't calling the constructor of a superclass (with
`ref.super()') be calling the constructor again after
it (the superclass) has already existed?You can not create an object (other than instances of java.lang.Object) without calling a superclass constructor.