Inner Class - Initialization Sequence

[Thomas Markl]

Initialization Sequence of this code:
- When outer is created in line 1 the constructor OuterTest(String id) is called
and „id“ of OuterTest is initialized to „STP“ and „Default Constructor
is printed to console.
- Then the instance „inner“ of the inner class is created. As inner class extends
The outer class the Default-Constructor of OuterTest is called and „NonDefault
Constructor“ is printed.
MY QUESTION is: Why didn’t get „id“ of OuterTest the value „Default“ which is
Set by the default constructor of „OuterTest“?
Instead the „Outer.Test.this.id“ keeps ist old value „STP“ from the creation of the
OuterTest-instance „outer“.

class OuterTest {
String id ;
OuterTest ( ) {
                System.out.println("Default-Constructor");
this.id = " Default " ;
}
OuterTest ( String id ) {
                System.out.println("NonDefault-Constructor");
this.id = id ;
}
class InnerTest extends OuterTest {
void doSomething ( ) {
System.out.println( "InnerTest"+OuterTest.this.id );
System.out.println( "InnerTest"+id );
}
}
        public static void main ( String args [ ] ) {
OuterTest outer = new OuterTest( " STP " ) ; //line 1
InnerTest inner = outer.new InnerTest( ) ;
inner.doSomething( );
}
}

C:\Java\EigeneJavaProgramme>java OuterTest
NonDefault-Constructor
Default-Constructor
InnerTest STP
InnerTest Default
=> Question: Why is „OuterTest.this.id“ still „STP“ and not „Default“?

[Ilja Preuss]

Try the following code (warning: I didn't tested it...):

public class Outer {
  public Outer getOuter() {
    return null;
  }
  public class Inner extends Outer {
    public Outer getOuter() {
      return Outer.this;
    }
  }
  public static void main(String[] args) {
    Outer outer = new Outer();
    Outer inner = outer.new Inner();
    System.out.println(inner == inner.getOuter());
    System.out.println(outer == inner.getOuter());
  }
}

This should give you
false
true
Did that help?

[Pete Lyons]

Let's see if I can explain what's going on. The key thing to focus on is that Inner is BOTH an inner class and a subclass. Because it's an inner class, it is automatically associated with an instance of it's outer class. Because it is a subclass, it inherits all it's superclass's properties. So when you construct the OuterTest in line 1, you get 1 instance with id set to " STP ". Now in line 2, you construct a new InnerTest via this new OuterTest, but remember that this new instance is a subclass of OuterTest, so it has it's OWN String id property, and that's what get's set to " Default ", leaving the outer instance's id unchanged. So from within the InnerTest class, OuterTest.this.id refers to the id property of the instance of Outertest that the current instance of InnerTest is implicitly associated with, and just id refers to the id property that the current instance of InnerTest inherits from the OuterTest class. Does that clarify things at all? This stuff can get very confusing.