为什么一个内部类的子类需要一个封闭的实例？

Question

考虑类<代码> OuterClass < />代码> <代码> InnerClass < /代码>

public class OuterClass {
    class InnerClass {

    }
}

第二个类，它试图扩展外部类的内部类

public class Clazz extends OuterClass.InnerClass {
    public Clazz(OuterClass outerClass) {
        outerClass.super();
    }
}

到目前为止还不错，这个代码会工作，编译器不应该给出警告。

但我试图理解-为什么有必要传递给OuterClass的构造函数引用？为什么需要调用它的超级构造函数？

我想知道为什么必须这样精确？

此外，考虑这个类（与前几类无关），其中类<代码>公寓和 Hall 是内部类，即 建筑< /Cord>类，其内部是“代码>解决方案< /代码>（内嵌）。

public class Solution {
    public class Building {
        public class Hall {
            private BigDecimal square;

            public Hall(BigDecimal square) {
                this.square = square;
            }
        }

        public class Apartments {
        }
    }
}

然后是顶层教室，它试图扩建内部教室大厅

class BigHall extends Solution.Building.Hall {
    public BigHall(Solution.Building building, BigDecimal square)
    {
        building.super(square);
    }
}

看看这一团糟。最后两个类也应该编译，但您能帮我澄清一下吗，为什么在扩展内部类时，BigHallclass需要将对Building对象的引用传递给构造函数，而不是解决方案对象？

如果你能提供JLS的报价，那就太好了！




Answer 1

考虑以下几点

public class Outer {
    String outerString;

    class Inner { 
        public void doStuff() {
            System.out.println("Outer string is " + outerString);
        }
    }


    static class StaticInner { 
        public void doStuff() {
            // can't access outerString here
        }
    }
}

在这个例子中...每个内部需要一个外部才能存在。内部可以从外部访问所有字段

但是StaticInner不需要Outer来存在。它无法从外部访问字段

Answer 2

为什么必须传递给OuterClass的构造函数引用？

这仅仅是因为InnerClass的实例只能存在于OuterClass的实例中，并且可以直接访问其封闭实例的方法和字段。这就是Java中内部（非静态）类的设计方式。

UPD当您要求JLS参考时，亲爱的@Boris蜘蛛在评论中提供了两次，它是JLS 8.1.3。但我个人觉得JLS对这件事的描述相当混乱。官方的Java文档教程以更简单的方式解释了这些内容。

Answer 3

匿名用户

您的InnerClass是一个内部类。

内部类是未显式或隐式声明为静态的嵌套类。

内部类可能有封闭实例

类或接口的直接内部类C[yourInnerClass]O[yourOuterClass]的实例i与O的实例关联，称为i的直接封闭实例。

只有在静态上下文中声明的内部类没有封闭实例。

声明发生在静态上下文中的内部类I的实例没有词汇封闭的实例。

示例的内部类不在静态上下文中，因此需要一个封闭实例。

然后，Java语言规范声明

非私有内部成员类的构造函数隐式声明一个变量作为第一个形式参数，该变量表示该类的直接封闭实例

（如果你感兴趣，它会进一步详细说明原因）。换句话说，您的InnerClass构造函数看起来真的像

public InnerClass(OuterClass OuterClass.this){} // this is valid syntax for entirely different reasons

它希望使用OuterClass类型的参数作为其封闭实例。子类化这个InnerClass类型不会改变这一点，特别是因为任何子类型都必须调用其超类型的超级构造函数。

关于施工人员，本规范还规定：

如果构造函数体不是以显式构造函数调用开始的，并且被声明的构造函数不是原始类Object的一部分，那么构造函数体隐式地以超类构造函数调用超级（）；开始，这是对它的直接超类不接受参数。

很明显没有参数你的代码就无法工作

public class Clazz extends OuterClass.InnerClass {
    public Clazz() {
        // implicit super() invocation
    }
}

这个super（）构造函数调用不起作用。在这种情况下，这是因为它的语法错误。但其思想是，超级构造函数期望为表示封闭实例的形式参数提供一个参数，但您没有提供。正确的语法是您已有的语法。让我们来定义它。

有多种类型的构造函数调用。你的

public Clazz(OuterClass outerClass) {
    outerClass.super();
}

是一个合格的超类构造函数调用，定义为

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

第一章解释表达式是如何计算的

如果超类构造函数调用是合格的，则将计算主表达式或紧接在""之前的ExpressionName，p。

否则，该求值的结果是关于S的i的立即封闭实例。

换句话说，由outerClass引用的对象成为您的Clazz实例所需的封闭实例。

简而言之，忽略内部类的情况，您的示例可以归结为

public class Foo {}
public class Bar {
    public Bar(Foo foo){}
}
public class SubBar extends Bar {
    public SubBar(Foo foo) {
        super(foo);
    }
}

SubBar必须满足需要Foo实例的Bar超级构造函数。这与您的Clazz类型发生的情况相同，只是它的超级类型的构造函数是隐式的。