Instantiate inner class object from current outer class object

Question

I am wondering if the following is valid in Java:

class OuterClass {

    OuterClass(param1, param2) {
        ...some initialization code...
    }

    void         


        

Answer 1

Every instance of an inner class, unless the Class is declared as static, must have a 'connected' instance of an outer class, in order to be instantiated.

This won't work:

public class Outer {
    public class Inner { 
    }
    public static void main(String[] args) {
        Inner inner = new Inner(); //compilation error
    }
}

However, this will work, it doesn't need an instance of Outer, since the static keyword is used:

public class Outer {
    public static class Inner { 
    }
    public static void main(String[] args) {
        Inner inner = new Inner(); 
    }
}

more info: java inner classes

Answer 2

Above is the example for creating Inner class object inside outer class and outside outer class:

public class OuterClass {

public class InnerClass{

    public void myMethod(){
        System.out.println("inside inner class");
    }
}

public void myMethod(){
    System.out.println("outer class method");
    InnerClass class1 = new InnerClass();
    class1.myMethod();
}

public static void main(String[] args){
    //OuterClass.InnerClass class1 = new OuterClass().i
    OuterClass outerClassObj = new OuterClass();
    OuterClass.InnerClass innerClassObj = outerClassObj.new InnerClass();
    innerClassObj.myMethod();
}
}

Answer 3

Regarding:

public class OuterClass {

   OuterClass() {
       // ...some initialization code...
   }

   void doSomething() {
      OuterClass.InnerClass ic = this.new InnerClass();
   }

   class InnerClass {

   }

You don't need the explicit OuterClass identifier nor the this as they're implied.

So this is unnecessary:

OuterClass.InnerClass ic = this.new InnerClass();

And this is fine inside of an instance method:

InnerClass ic = new InnerClass();

Things get dicier though if you're creating an object of InnerClass in a static method such as main that is held inside of OuterClass. There you'll need to be more explicit:

This won't work

public class OuterClass {
    public static void main(String[] args) {
       InnerClass otherInnerVar = new InnerClass(); // won't work
    }

But this will work fine:

public class OuterClass {
    public static void main(String[] args) {
       InnerClass otherInnerVar2 = new OuterClass().new InnerClass(); // will  work
    }