如何在Java中实例化内部类真正起作用？

Question

I'm making an instance from an inner class, but I can't understand what does this syntax mean.

OuterClass outerObject = new OuterClass();

OuterClass.InnerClass innerObject = outerObject.new InnerClass();

I know that I can't get an object from an inner class without getting an object from the outer one OuterClass outerObject = new OuterClass(); , then we use the object from the outer class outerObject to get an instance from the inner class outerObject.new InnerClass(); , so what does OuterClass.InnerClass actually means as it is not explained in the Java documentation as it states:

To instantiate an inner class, you must first instantiate the outer class. Then, create the inner object within the outer object with this syntax OuterClass.InnerClass innerObject = outerObject.new InnerClass();

Answer 1

If I recall correctly, the syntactic meaning is as follows:

OuterClass.InnerClass innerObject = outerObject.new InnerClass(); 
           InnerClass                                             The class InnerClass
          .                                                       which is an inner class of
OuterClass                                                        OuterClass
                      innerObject                                 has an instance named innerObject
                                  =                               which is assigned the value
                                                new InnerClass()  of a new InnerClass instance
                                               .                  such that when you use
                                                                  OuterClass.this from within
                                                                  InnerClass methods invoked on
                                                                  innerObject, it refers to
                                    outerObject                   outerObject.

The key here is that inner classes are created through a reference to the outer class. If your InnerClass is static (one InnerClass for the entire OuterClass class), you'll see that the reference to the outer class is static:

static class InnerClass { ... }
...
//Initialization will become:
OuterClass.InnerClass innerObject = new OuterClass.InnerClass();
                                        ^ this part is a static OuterClass reference

On the other hand, in your current scenario (InnerClass is not static), the inner class must be created with a reference to the OuterClass in the form of an object - outerObject . Furthermore, you are actually able to access outerObject from within InnerClass by referring to OuterClass.this :

OuterClass.java

public class OuterClass
{
  class InnerClass
  {
    public OuterClass getOuterClassReference()
    {
      return OuterClass.this;
    }
  }
}

Main.java

class Main
{
  public static void main(String[] args)
  {
    OuterClass outerObject = new OuterClass();
    OuterClass.InnerClass innerObject = outerObject.new InnerClass(); 
    System.out.println(outerObject);
    System.out.println(innerObject.getOuterClassReference());
    System.out.println(outerObject == innerObject.getOuterClassReference());
  }
}

Output:

OuterClass@36baf30c
OuterClass@36baf30c
true

Here, 36baf30c in the output is an arbitrary memory address. These two output lines will always be the same. As you can clearly see, referring to OuterClass.this from within an InnerClass instance will return the OuterClass instance that was provided at initialization. This is part of the reason that you can't just call new InnerClass() - the reference OuterClass.this cannot be initialized properly without being provided with an instance.

Answer 2

This is the name of the class, and it's likely named this way to make it easier for the compiler to find the definition.

If you declare your variable as just being of type InnerClass , it will look for the file InnerClass.java , but there is no such file.

The dot notation indicates that it's actually a member of OuterClass , so it will look for the definition within the file OuterClass.java .

This is the same thing as using a class from a library,

com.example.MyLibrary.ExternalClass myExternalObject;

Answer 3

JVM does not make a difference between OuterClass and InnerClass : both classes are POJO and separate classes. But InnerClass is not static and therefore it has internal this refers to the instance of OuterClass (therefore it should be created only with existed OuterClass instance)

public class OuterClass {
    public class InnerClass {
        public OuterClass getOuterClassReference() {
            return OuterClass.this;
        }
    }
}

OuterClass outerObject = new OuterClass();
OuterClass.InnterClass innerObject = outerObject.new InnerClass(); // innerObject has this reference to outerObject

---

public class OuterClass {
    public static class InnerClass {}
}

OuterClass outerObject = new OuterClass();
OuterClass.InnerClass innerObject = new OuterClass.InnerClass(); // innerObject does not have this reference to outerObject

---

In other words, you can emulate InnterClass by yourself like this:

public class OuterClass {   
}

public class InnerClass {
    private final OuterClass outer;

    public InnerClass(OuterClass outer) {
        this.outer = outer;
    }   
}

Answer 4

Outerclass.Innerclass is just a part of the Innerclass' full path.
The full path would be something like packagename.Outerclass.Innerclass .

Thus, OuterClass.InnerClass innerObject = outerObject.new InnerClass(); is really no different from something like:
java.util.ArrayList<T> varName = new java.util.ArrayList<T>();

Answer 5

You can define the inner class as static member of OuterClass

public class OuterClass {
    public static class StaticInnerClass {
        int i = 0;

        public String call() {
            i++;
            return this.getClass().getName() + " i=" + i;
        }
    }
}

so defining the static inner class the compile knows that members is a class, the memory area is instanced at compile time (it is accessible in static way) and you can apply the new operator and the new operator instances the class in another memory area.

For example in a main class

public class Main {
    public static void main(String[] args) {

        /**
         * https://stackoverflow.com/questions/57581397/how-instantiating-an-inner-class-in-java-really-works
         *
         * @@@ New instance of Inner class
         */
        OuterClass.StaticInnerClass staticInnerClass = new OuterClass.StaticInnerClass();

        System.out.println(staticInnerClass.call());
        System.out.println(staticInnerClass.call());


        staticInnerClass = new OuterClass.StaticInnerClass();
        System.out.println("\n" + staticInnerClass.call());
        System.out.println(staticInnerClass.call());
    }
}

with output

// new of inner class and i = 0
innerclass.OuterClass$StaticInnerClass i=1
innerclass.OuterClass$StaticInnerClass i=2

// new of inner class and i = 0 
innerclass.OuterClass$StaticInnerClass i=1
innerclass.OuterClass$StaticInnerClass i=2

References: https://docs.oracle.com/javase/tutorial/java/javaOO/nested.html .