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

Question

我正在从内部类创建一个实例，但我不明白这种语法是什么意思。OuterClass outerObject = new OuterClass(); OuterClass.InnerClass innerObject = outerObject.new InnerClass();我知道如果不从外部类中获取对象就无法从内部类中获取对象，然后我们使用外部类outerObjectOuterClass outerObject = new OuterClass();中的对象从内部类中获取实例，那么OuterClass.InnerClass到底是什么意思因为它在 Java 文档中没有解释，因为它指出：outerObject.new InnerClass();要实例化内部类，必须先实例化外部类。然后，使用此语法在外部对象中创建内部对象 OuterClass.InnerClass innerObject = outerObject.new InnerClass();

Answer 1

如果我没记错的话，句法含义如下：

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.

这里的关键是内部类是通过对外部类的引用创建的。如果您的 InnerClass 是静态的（一个 InnerClass 代表整个 OuterClass 类），您会看到对外部类的引用是静态的：

static class InnerClass { ... }

...

//Initialization will become:

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

                                        ^ this part is a static OuterClass reference

另一方面，在您当前的场景中（InnerClass 不是静态的），必须使用对象形式的对 OuterClass 的引用来创建内部类 - outerObject。此外，您实际上可以outerObject通过参考从 InnerClass 内部访问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());

  }

}

输出：

OuterClass@36baf30c

OuterClass@36baf30c

真

这里，36baf30c输出是一个任意的内存地址。这两条输出线将始终相同。OuterClass.this您可以清楚地看到，从 InnerClass 实例内部引用将返回初始化时提供的 OuterClass 实例。这是您不能只调用的部分原因new InnerClass()——OuterClass.this如果不提供实例，则无法正确初始化引用。

Answer 2

这是类的名称，很可能这样命名是为了让编译器更容易找到定义。

如果您将变量声明为 type InnerClass，它将查找 file InnerClass.java，但没有这样的文件。

点符号表示它实际上是 的成员OuterClass，因此它将在文件中查找定义OuterClass.java。

这与使用库中的类是一样的，

com.example.MyLibrary.ExternalClass myExternalObject;

Answer 3

OuterClassJVM 在和之间没有区别InnerClass：这两个类都是 POJO 和单独的类。但InnerClass不是static，因此它有内部this引用的实例OuterClass（因此它应该只用现有实例创建OuterClass）

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

换句话说，你可以InnterClass像这样自己模拟：

public class OuterClass {   

}

public class InnerClass {

    private final OuterClass outer;

    public InnerClass(OuterClass outer) {

        this.outer = outer;

    }   

}

Answer 4

Outerclass.Innerclass只是内部类完整路径的一部分。
完整路径类似于packagename.Outerclass.Innerclass.

因此， OuterClass.InnerClass innerObject = outerObject.new InnerClass(); 实际上与以下内容没有什么不同：
java.util.ArrayList<T> varName = new java.util.ArrayList<T>();

Answer 5

您可以将内部类定义为 OuterClass 的静态成员

public class OuterClass {

    public static class StaticInnerClass {

        int i = 0;

        public String call() {

            i++;

            return this.getClass().getName() + " i=" + i;

        }

    }

}

所以定义静态内部类编译知道成员是一个类，内存区域在编译时实例化（它可以静态方式访问）并且您可以在另一个内存区域中应用新运算符和新运算符实例类。

例如在主类中

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

    }

}

带输出

// 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

参考资料： https: //docs.oracle.com/javase/tutorial/java/javaOO/nested.html。