Tutorial :Getting hold of the outer class object from the inner class object


I have the following code. I want to get hold of the outer class object using which I created the inner class object inner. How can I do it?

public class OuterClass {        public class InnerClass {          private String name = "Peakit";      }        public static void main(String[] args) {          OuterClass outer = new OuterClass();          InnerClass inner = outer.new InnerClass();         // How to get the same outer object which created the inner object back?          OuterClass anotherOuter = ?? ;            if(anotherOuter == outer) {               System.out.println("Was able to reach out to the outer object via inner !!");          } else {               System.out.println("No luck :-( ");          }      }  }  

EDIT: Well, some of you guys suggested of modifying the inner class by adding a method:

public OuterClass outer() {     return OuterClass.this;  }  

But what if I don't have control to modify the inner class, then (just to confirm) do we have some other way of getting the corresponding outer class object from the inner class object?


Within the inner class itself, you can use OuterClass.this. This expression, which allows to refer to any lexically enclosing instance, is described in the JLS as Qualified this.

I don't think there's a way to get the instance from outside the code of the inner class though. Of course, you can always introduce your own property:

public OuterClass getOuter() {      return OuterClass.this;  }  

EDIT: By experimentation, it looks like the field holding the reference to the outer class has package level access - at least with the JDK I'm using.

EDIT: The name used (this$0) is actually valid in Java, although the JLS discourages its use:

The $ character should be used only in mechanically generated source code or, rarely, to access pre-existing names on legacy systems.


OuterClass.this references the outer class.


You could (but you shouldn't) use reflection for the job:

import java.lang.reflect.Field;    public class Outer {      public class Inner {      }        public static void main(String[] args) throws Exception {            // Create the inner instance          Inner inner = new Outer().new Inner();            // Get the implicit reference from the inner to the outer instance          // ... make it accessible, as it has default visibility          Field field = Inner.class.getDeclaredField("this$0");          field.setAccessible(true);            // Dereference and cast it          Outer outer = (Outer) field.get(inner);          System.out.println(outer);      }  }  

Of course, the name of the implicit reference is utterly unreliable, so as I said, you shouldn't :-)


I think this may be abuse of the use of an inner class. It seems to me that what you want to do is violating the fundamental concepts of Object-Oriented programming. If you want to access the outer class from the inner class then include a reference to the outer class so you have access to it. When you have to do tricky things like this it usually is a sign that you should reconsider your design choices.


Here's the example:

// Test  public void foo() {      C c = new C();      A s;      s = ((A.B)c).get();      System.out.println(s.getR());  }    // classes  class C {}    class A {     public class B extends C{       A get() {return A.this;}     }     public String getR() {       return "This is string";     }  }  


I just did it like this:

public class CherryTree {      public class Cherry {          public final CherryTree cherryTree = CherryTree.this;          // [...]      }      // [...]  }  

Of course you need to be able to modify the inner class and everyone who gets the inner class object has access to the outer class object now. In my case it's just fine.


if you don't have control to modify the inner class, the refection may help you (but not recommend). this$0 is reference in Inner class which tells which instance of Outer class was used to create current instance of Inner class.


The more general answer to this question involves shadowed variables and how they are accessed.

In the following example (from Oracle), the variable x in main() is shadowing Test.x:

class Test {      static int x = 1;      public static void main(String[] args) {          InnerClass innerClassInstance = new InnerClass()          {              public void printX()              {                  System.out.print("x=" + x);                  System.out.println(", Test.this.x=" + Test.this.x);              }          }          innerClassInstance.printX();      }        public abstract static class InnerClass      {          int x = 0;            public InnerClass() { }            public abstract void printX();      }  }  

Running this program will print:

x=0, Test.this.x=1  

More at: http://docs.oracle.com/javase/specs/jls/se7/html/jls-6.html#jls-6.6

Note:If u also have question or solution just comment us below or mail us on toontricks1994@gmail.com
Next Post »