为什么我需要提供封闭类对象而不是封闭类对象

Question

class OuterA {
    class InnerA {
    }
}
class SubclassC extends OuterA.InnerA { 
    SubclassC(OuterA outerRef) {
        outerRef.super(); 
    }
}
class XYZ {
    public static void main(String[] args) {
        new SubclassC(new OuterA());
    }
}

在上面的代码中

1. 为什么我需要将OuterA 对象引用传递给SubclassC 构造函数才能编译.java 文件？
2. 为什么 InnerA 对象引用不需要传递给 SubclassC 构造函数？

Answer 1

为什么我需要将 OuterA 对象引用传递给 SubclassC 构造函数才能编译 .java 文件？

因为SubclassC 扩展了 InnerA 类的定义。同时，InnerA 类绑定到OuterA（即InnerA 的所有实例都将绑定到OuterA 的相应实例）。因此，要获取SubclassC的实例，就需要OuterA的实例。

为什么 InnerA 对象引用不需要传递给 SubclassC 构造函数？

因为在创建SubclassC 时，在底层首先会创建其超类的实例，即会有InnerA 的实例。您实际上可以将SubclassC 视为一种特殊 类型的InnerA。

Answer 2

1. 为什么我需要将 OuterA 对象引用传递给 SubclassC 构造函数才能编译 .java 文件？

因为InnerA 是OuterA 的内部类。这意味着OuterA.InnerA 类型的对象或其任何子类型（例如SubclassC）只能存在于封闭类（在本例中为OuterA）实例的上下文中。

这称为合格的超类构造函数调用。来自JLS：

合格的超类构造函数调用以 Primary 表达式开头。它们允许子类构造函数显式指定新创建的对象相对于直接超类的直接封闭实例（第 8.1.3 节）。 当超类是内部类时，这可能是必要的。

如果您不需要将SubclassC 实例链接到OuterA 的现有实例，您可以在OuterA 构造函数中创建新的OuterA 对象：

static class SubclassC extends OuterA.InnerA {
    SubclassC() {
        new OuterA().super();
    }
}

1. 为什么不需要将 InnerA 对象引用传递给 SubclassC 构造函数？

由于SubclassC 扩展OuterA.InnerA，当您执行outerRef.super() 时，您调用的是OuterA.InnerA 构造函数。要看到这种情况，请考虑以下代码：

public class Example {
    static class OuterA {
        OuterA() {
            System.out.println("Call OuterA constructor");
        }
        class InnerA {
            InnerA() {
                System.out.println("Call InnerA constructor");
            }

        }
    }

    static class SubclassC extends OuterA.InnerA {
        SubclassC(OuterA outerRef) {
            outerRef.super();
            System.out.println("Call SuperclassC constructor");
        }
    }

    public static void main(String[] args) {
        OuterA outerA = new OuterA();
        System.out.println("Before new SuperclassC()");
        new SubclassC(outerA);
    }
}

输出：

Call OuterA constructor
Before new SuperclassC()
Call InnerA constructor
Call SuperclassC constructor

Answer 3

1.Why do I need to pass OuterA object reference to SubclassC constructor for the .java file to compile? 

因为SubclassC扩展了类OuterA.InnerA：SubclassC extends OuterA.InnerA {

SubclassC(OuterA outerRef) {
        outerRef.super(); 

第二次

2. Why is InnerA object reference not required to be passed to SubclassC constructor?

因为 Innera 在 Outtera 内部，您在创建对象 new SubclassC(new OuterA()); 时调用它（即，您不需要创建单独的对象，因为 InnerA 在 OuterA 内部。创建 OuterA 就足够了在这种情况下

Answer 4

我们预计在构造函数运行之前会发生两件事：

• 应该已经运行了基类（Object 如果extends 未使用）构造函数
• 封闭的实例（如果有的话）应该已经完全构造好，并且在程序中会出现对它的引用

Java 通过在构造函数的开头自动放置super() 调用来强制执行第一条规则。请注意，没有任何东西作为 父实例：当您执行 new File() 时，您不需要提供 Object - 所以在构建 @ 时您不需要 InnerA 987654327@.

当一个非静态类在另一个类的词法范围内定义时，它可以访问封闭对象的字段：

class Outer {
  int val;
  class Inner {
    int val() {
      return val; // <-- we can access val, it's in scope
    }
  }
}

所以很明显我们需要一个指向它的链接。以下是通常创建链接的方式：

Outer outer = new Outer();
Outer.Inner inner = outer.new Inner(); // baroque, I admit

同样的事情发生在扩展Inner的类的第一行：

class InnerExtended extends Outer.Inner {
  public InnerExtended(Outer outer) {
    outer.super(); // <-- calls Outer.Inner ctor
  }
}

即使不容易看出相似之处：

super();            // plain superclass ctor call
outer.new Inner();  // instantiation of inner class
outer.super();      // super() call in class extending inner