Java：继承自我的类

Question

我知道这毫无意义：我只是觉得这很有趣，我想进一步了解当您创建一个继承自身的类时会发生什么，从而导致堆栈溢出崩溃。令人惊奇的是，Java 允许您从一开始就创建这样的构造。

我只是在猜测，但 JVM 是否将自身置于无限循环中试图在实例化类之前解析它，或者它实际上是在无休止地实例化该类的多个副本？

我应该更具体一些；我正在使用内部类从封闭类派生。

 public class Outside {
    private int outsideValue;

    public class Inside extends Outside {
        private int insideValue;
        public Inside(int val) {
            insideValue = val;
        }
    }

    public Outside() {
        Inside o = new Inside(0);
    }
}

public class Main {
    public static void main(String args[]) {
        Outside o = new Outside();
    }
}

Answer 1

请记住，由于Inside 扩展了Outside，它有一个隐式调用super()，这是Outside 的构造函数（它又调用Inside 的构造函数) 就这样。

您发布的代码在概念上与以下程序没有区别：

class A {
    B b = new B();
}

class B extends A {
}

public class Test {
    public static void main(String[] args) {
        new A(); // Create an A...
                 //   ... which creates a B
                 //   ... which extends A thus implicitly creates an A
                 //   ... which creates a B
                 //   ...
    }
}

Answer 2

这个问题的最终形式与循环继承和内部类无关。这只是由未绑定的递归构造函数调用引起的无限递归。同样的效果可以用下面这个简单的例子来展示：

public class A {
    public A() {
        new A();
    }
}

请注意，此代码完全有效，因为 Java 对递归调用没有任何限制。

在您的情况下，由于继承，它稍微复杂一些，但如果您回想子类的构造函数隐式调用超类的构造函数，应该清楚这些调用形成无限递归。

Answer 3

在 Eclipse 之类的 IDE 中尝试，它不允许您这样做。即给出这样的错误。

检测到循环：Test 类型无法扩展/实现自身或其自己的成员类型之一

Answer 4

如果我们再修改一下，您发布的示例可能会出现问题：

public class Outside {

    public class Inside extends Outside {

            public Inside(int val) {
        }

    }

    private Inside i;

    public Outside() {
        i = new Inside();
    }
}

但这与Inside 是Outside 的内部类这一事实并没有真正的关系，它可能同样发生在单独的顶级类中。

Answer 5

java 编译器在尝试进入循环继承链时不会进入无限循环。毕竟，每条继承链都是一个最终有限的图（从计算上讲，节点和边的数量非常少。）更准确地说，从子类 A 到（最终）超类 Z 的继承图必须是一条线（而不是其他方式，不过），编译器可以很容易地确定它是否是一条线。

程序不需要太多的时间来确定这样一个小图是否是循环的，或者它是否是一条线，这是编译器所做的。因此编译器不会进入无限循环，并且 JVM 永远不会用完堆栈空间，因为 1）编译器既不会在 JVM 上运行，也不会 2）JVM 可以执行（因为没有任何东西可以编译并且编译器永远不会调用在这种情况下，JVM 无论如何。）

我不知道有任何语言允许这种循环继承图（但我已经 11 年只做 Java 了，所以我对 Java 以外的任何东西的记忆都是糊状的。）此外，我看不到使用这种构造（在建模或现实生活中）。不过，理论上可能很有趣。

编辑

好的，我运行了您的代码，确实会导致堆栈溢出。你是对的。我将不得不坐下来真正研究一下，以了解编译器为什么允许这样的构造。

很好的发现！！！！

Answer 6

扩展自身会产生循环继承错误（java 不允许）。您的代码示例确实可以编译并且是有效的。

---

由于Vladimir Ivanov's 的坚持，我将修复我的编辑。

由于以下原因，您的代码会抛出 StackOverflowError。

Inside o = new Inside(0);

由于Inside 扩展Outside，Inside 首先隐式调用super() 方法（因为您自己没有调用它）。 Outside() 构造函数初始化Inside o 并再次循环运行，直到堆栈已满并溢出（堆堆栈内有太多Inside 和Outside）。

希望这对弗拉基米尔·伊万诺夫特别有帮助。

Answer 7

您可以通过以下方式获得答案：

Class.forName("MyClass");

这样它会被解析但不会被实例化。因此，您可以检查分辨率本身是否会导致崩溃。

我猜这取决于你使用的 JVM。

Answer 8

当我尝试编译时：

class A extends A {
}

我明白了：

$ javac A.java
A.java:1: cyclic inheritance involving A
class A extends A {
^
1 error

所以Java 不允许你做这种事情。欲知详情，java version "1.6.0_24"