Enclosing instance references....

Question

Ok, I turned to the holy scripture (JLS), and have turned away baffled.....
Im confused on an Inner class issue.
If inner classes are to reference fields of their inclosing instance, they have to be able to reference it some way.
Im assuming that this is implemented as a field of the inner class (is that a correct assumption?) synthesised at compile time.
Now, what I want to know is when does this reference (if it exists) become 'valid' when the inner class is a derived class?
Intuition tells me that it would be null until after the base class constructor had completed. However, in practise this is not always the case....
Heres an example:
We have some class:
class Something {
  public Something() {
    // NOTE: Call non-final method from constructor!!!
    createSomething();
  public Object createSomething() {
    return new Whatever();
}We then have a class which creates an annonymous inner class which overides the 'createSomething' method:
class UserClass {
  public void example() {
    final Object toReturn = new Object();
    Something mySomething = new Something() {
      public Object createSomething() {
        // THE ALL IMPORTANT LINE:
        System.out.println("Ref: " + UserClass.this);
        return toReturn;
}Now, when the mySomething is constructed, the 'createSomething' method is called from the base constructor. At this point, I would expect (incorrectly?) that the enclosing reference (UserClass.this) would be null.
However, on two compilers, I get two different results. Null on one, non-null on the other.
Can anyone please explain to me the way this should work - or is it undefined?

Answer 1

What Im confused about is this:
The instance of the annonymous inner class has to be able to reference its enclosing instance somehow (I.e, UserClass.this).
So, Im guessing (perhaps incorrectly...) that the instance of the annonymous inner class will have a field that is a reference to the enclosing class.
Im fully aware that the enclosing class can never really be null... However, constructors are called bottom up, and a non-final method is called from the base class constructor.
This is then overidden in the inner class to print out the reference to the enclosing class (UserClass.this).
My confusion is about when it becomes 'valid' for the inner class to reference its enclosing class (using UserClass.this) - and my intuition says not before the base constructors have been called (I.e, I would expect it to be null in my example).
Why do I think that?
Well, if we have this:
class MyBaseClass {
  public MyBaseClass() {
    dodgyMethod();   
  public void dodgyMethod() {
    System.out.println("HELLO");
class MyDerivedClass extends MyBaseClass {
  Integer someInteger = new Integer(4);
  public void dodgyMethod() {
    // Will be NULL when called from base constructor
    System.out.println("val: " + someInteger);
}We see that if a new 'MyDerivedClass' is created, then someInteger is null (because someInteger hasn't been initialised yet, coz we are still in the base class constructor).
My question is just an extension of the above.....
If the enclosing instance reference is implemented as a normal ref in the anonymous inner class, I would not expect it to get initialised until the base class constructor had completed (in the same way that I wouldn't expect someInteger to be initialise until its base constructor had completed).
So its all about calling non-final methods from a base class, where the derrived class is an inner class, and whether or not the enclosing reference should be non-null at that point in time.