how to define constructor of a subclass inheriting an inner class?

Question

I am learning inner and outer classes in Java. I know what inner and outer classes are and why they are used. I came across the following question on this topic and could not find an answer.

Suppose the following code is given:

class outer{
    class inner{

    }
}

class SubClass extends outer.inner{
}

Question: How should the minimal subclass constructor be defined? and why?

Option 1-
Subclass () {
    //reason: bacause the default constructor must always be provided
}
Option 2-
Subclass (Outer outer) {
    //reason : because creating an instance of **Subclass** requires an instance 
    //of outer, which the **Subclass** instance will be bound to
}

Option 3-
Subclass (Outer outer) {
    outer.super();
    //reason : because creating an instance of **Subclass** requires an explicit 
    //call to the **Outer's** constructor, in order to have an enclosing instance 
    //of **Outer** in scope.
}
Option 4- 
Subclass (Outer.inner inner) {
    //reason : bacause an instance of **inner** is necessary so that there is a 
    //source to copy the derived properties from
}

PS. This is a multiple choice question. Only 1 answer is expected

i am new to java and don't know much about these advanced topics

Thanks

Answer 1

Here is an example from the JLS that follow this same logic but by not passing the enclosing instance but by creating it directly in the constructor :

Example 8.8.7.1-1. Qualified Superclass Constructor Invocation

class Outer {
    class Inner {}
}
class ChildOfInner extends Outer.Inner {
    ChildOfInner() { (new Outer()).super(); }
}

Superclass constructor invocations may be subdivided:

• Unqualified superclass constructor invocations begin with the keyword super (possibly prefaced with explicit type arguments).

• Qualified superclass constructor invocations begin with a Primary expression.

They allow a subclass constructor to explicitly specify the newly created object's immediately enclosing instance with respect to the direct superclass (§8.1.3). This may be necessary when the superclass is an inner class .

The case the nearest in proposed answers is

public SubClass(Outer outer) {
    outer.super();
}

To extend Outer.Inner that is an inner class of Outer , SubClass constructor needs to have an instance of Outer that is the enclosing type.

outer.super(); will invoke the constructor of the Outer parent class that is the Inner constructor.

The outer.super(); syntax may be disconcerting as we don't invoke generally super() on a parameter of a constructor but in the case of a class extending a inner class, the constructor of the subclass allows this syntax.

Answer 2

I do not think, that a "outer" class can extend an inner class. That construct would mean, a class could access private members of another classes.

You could have an inner class that extends another inner class of the same outer class, though.

As for the constructors, the outer instance is specified in the instantiation, not as an argument:

class Outer {
   class Inner {
      ...
   }
   class SubInner {
      ...
   }
   void method() {
      Inner i = this.new SubInner();
   }
}