Inner class strange behavior

[Sun LiWei]

  
class Outer {
  
    private String foo = "Outer.foo";
    private String bar = "Outer.bar";
    private Inner1 inner1 = new Inner1();
    private Inner2 inner2 = new Inner2();
    
    private class Inner1 {
        private String bar = "Inner1.bar";
        
        Inner1() {
            System.out.println("new " + getClass().getName() + ": ");
            System.out.println("  foo=" + getFoo());
            System.out.println("  bar=" + getBar());
        }
        
        String getFoo() {
            return foo;
        }
    
        String getBar() {
            return bar;
        }
    }    
    
    private class Inner2 extends Inner1 {
        private String foo = "Inner2.foo";
        
        Inner2() {
        }
        
        String getFoo() {
            return foo;
        }
    
        String getBar() {
            return bar;
        }
    }
  
  
    public static void main(String[] args) {
        new Outer();
    }
    
}

Output:
new Outer$Inner1:
foo=Outer.foo
bar=Inner1.bar
new Outer$Inner2:
foo=null
java.lang.NullPointerException
at Outer.access$100(JavaTest.java:1)
at Outer$Inner2.getBar(JavaTest.java:37)
at Outer$Inner1.<init>(JavaTest.java:14)
at Outer$Inner2.<init>(JavaTest.java:29)
at Outer.<init>(JavaTest.java:6)
at Outer.main(JavaTest.java:43)


I can't explain the null situation here.


why NullPointerExceptin is thrown??? why foo is null in Inner2 class?what is the initiating order of a java class ??

[Vlado Zajac]

Constructor of Inner2 calls constructor of Inner1 before initialization of
Inner2.foo so when the Inner1 constructor calls getFoo (from Inner2) it
returns null.

The NullPointerException is thrown because Inner2's hidden reference to
Outer is also initialized after Inner1 constructor so getBar (from Inner2)
calls null.access$100() (the hidded reference is null). I believe that this hidden method is used to retrieve value of bar from Outer class.

[Vlado Zajac]

In Outer foo and bar are private so to access them from inner classes
the compiler creates special methods access$000 and access$100.

[marc weber]

I agree with Vlado...

When you attempt to create an instance of Inner2 (which extends Inner1), the constructor of Inner1 is called before instance variables of Inner2 are initialized. Within the Inner1 constructor, getFoo() is called. This is invoking the overridden method in Inner2 (which you'll see if you add a println to the method), which is trying to access the foo variable in Inner2, which is not yet initialized. That explains the null.

If you comment out the bar declaration in Inner1, you will see that Outer.bar has been initialized before the exception is thrown. However, making Outer.bar static allows the program to run. Therefore, it makes sense that Inner2 simply does not yet have its reference to Outer (which it needs regardless of whether Outer.bar is private).

[Sun LiWei]

So,is the initiating order of a inner class is

1)super()
3)the hidden reference to the outter class(maybe here)
2)instance variable(s)
3)the hidden reference to the outter class(also maybe here)
4)it's own constructor

This hidden reference is the thing i don't know before.when exactly this reference is initialized?

[marc weber]

Well, this is a tangled web of partially constructed objects and polymorphism among inner classes. But I believe the outer reference is available to the extended inner class when super() returns.

In my test code below, I've commented the NullPointerExceptions. Here's what I think is happening...

We're trying to make an Outside object. In the process of initializing the members, we try to make an instance of an inner class that extends another inner class. So the constructor of the extended class implicitly calls the constructor of its parent class. Within the constructor of that parent class, a method is called (via polymorphism) in the not-yet-constructed extended class. And that method attempts to reference a variable of the outer class. This is where the problem occurs (regardless of whether that variable is private). However, if we simply comment out the polymorphic method call in the inner parent constructor and allow the extended constructor's super() to return, then we're okay. The constructor of the extended class is then able to access the variable in the outer class.

class Outside{ //NULL 6 -- occurs only if s is private
  Outside(){
    System.out.println("Outside con: " + s);
    returnS();
  }
  private String s = "Outer String";
  private InsideBase iB = new InsideBase();
  private InsideExt iE = new InsideExt(); //NULL 2 -- initializing Outside variables
  void returnS(){
    System.out.println("Outside.returnS(): " + s);
  }

  class InsideBase{
    InsideBase(){
      System.out.println("InsideBase con: " + s);
      //here's the problem...
      returnS(); //NULL 4 -- polymorphism calls InsideExt.returnS()
    }
    void returnS(){
      System.out.println("InsideBase.returnS(): " + s);
    }
  }

  class InsideExt extends InsideBase{
    InsideExt(){ //NULL 3 -- implicit call to super()
      System.out.println("InsideExt con: " + s);
      returnS();
    }
    void returnS(){
      System.out.println("InsideExt.returnS(): " + s); //NULL 5 -- no ref to Outside
    }
  }

  public static void main(String[] args){
    new Outside(); //NULL 1 -- making Outside object
  }
}

NOTE: I was only able to do this with inner class constructors calling polymorphic methods that reference outer class variables. I was unable to reproduce the problem in a simpler context.
[ September 11, 2004: Message edited by: marc weber ]