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.

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

Comments

[user207421]

'Non-static inner' is a tautology.

[Colm]

Well done on your Java knowledge. The title is expedient for search purposes.

[Herbert Samuel Jennings III]

Addendum: You -can- instantiate static inner classes from static methods. This sort of code is only needed to instantiate non-static inner classes from within static methods.

[AlbeyAmakiir]

This answer just changed my outlook on life. outer.new Inner()? Never even considered it a possibility. O_O

[Can Lu]

For static inner, can't you just simply do Inner inner = new Inner() ?

[LittleLittleQ]

@CanLu to create an object for static nested class, use OuterClass.StaticNestedClass nestedObj = new OuterClass.StaticNestedClass(). Nested Classes