How to instantiate non static inner class within a static method?

Question

I have the following piece of code:

public class MyClass {     class Inner {      int s, e, p;    }     public static void main(String args[]) {      Inner in;    } } 

Up to this part the code is fine, but I am not able to instantiate 'in' within the main method like in = new Inner() as it is showing non static field cannot be referenced in static context.

What is the way I can do it? I do not want to make my Inner class static.

Answer 1

You have to have a reference to the other outer class as well.

Inner inner = new MyClass().new Inner(); 

If Inner was static then it would be

Inner inner = new MyClass.Inner(); 

Answer 2

A "regular" inner class has a hidden (implicit) pointer to a Outer class instance. This allows the compiler to generate the code to chase the pointer for you without you having to type it. For instance, if there is a variable "a" in the outer class then the code in your inner class can just do "a=0", but the compiler will generate code for "outerPointer.a=0" maintaining the hidden pointer under the covers.

This means when you create an instance of an inner class you have to have an instance of a outer class to link it to. If you do this creation inside a method of the outer class then the compiler knows to use "this" as the implicit pointer. If you want to link to some other outer instance then you use a special "new" syntax (see code snippet below).

If you make your inner class "static" then there is no hidden pointer and your inner class cannot reference members of the outer class. A static inner class is identical to a regular class, but its name is scoped inside the parent.

Here is a snippet of code that demonstrates the syntax for creating static and non-static inner classes:

public class MyClass {      int a,b,c; // Some members for MyClass      static class InnerOne {         int s,e,p;         void clearA() {             //a = 0;  Can't do this ... no outer pointer         }     }      class InnerTwo {         //MyClass parentPointer;      Hidden pointer to outer instance         void clearA() {                      a = 0;             //outerPointer.a = 0      The compiler generates this code         }            }      void myClassMember() {         // The compiler knows that "this" is the outer reference to give         // to the new "two" instance.         InnerTwo two = new InnerTwo(); //same as this.new InnerTwo()     }      public static void main(String args[]) {          MyClass outer = new MyClass();          InnerTwo x = outer.new InnerTwo(); // Have to set the hidden pointer         InnerOne y = new InnerOne(); // a "static" inner has no hidden pointer         InnerOne z = new MyClass.InnerOne(); // In other classes you have to spell out the scope      }  }