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

Solution 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();

Solution 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

    }

}

Solution 3:

If you want to create new Inner() from within a method, do it from an instance method of the class MyClass:

public void main(){
  Inner inner = new Inner();
}

public static void main(String args[]){
  new MyClass().main();
}