Question

我希望以下程序的输出为：

Inside Static Block A
Inside A
Inside Constructor B

但输出是：

Inside Static Block A
Inside A
Inside A
Inside A
.
.
.
Inside A(Infinite times)

代码是：

public class First
{
    public static void main(String args[])
    {
        A op=new A();
    }
}
class A
{
    private int a=100;
    private int b;
    A()
    {
        System.out.print("Inside A");
        B obj=new B();
    }
    static
    {
        System.out.print("Inside Static Block A");
    }
    class B
    {
        B()
        {
            System.out.print("Inside Constructor B");
        }
        A o=new A();
    }
}

有人可以告诉我为什么输出是这样的吗？

Answer 1

B和A之间有一个循环引用。在A的构造函数中，您创建一个B，在B中创建一个带有A的字段。

在A（）的构造函数中，你可以：

B obj = new B();

所以，你创建一个新的B（）。

在B（）中，您可以使用A（）创建一个字段。这将创建另一个A（）实例，它再次在其构造函数中创建一个B（），依此类推。

Answer 2

看看

A() {
    System.out.print("Inside A");
    B obj = new B();
}

因此，要创建类A的实例，您需要创建类B的实例。

但是类B的代码是

class B {
    B() {
        System.out.print("Inside Constructor B");
    }

    A o = new A();
}

（因为字段的初始化发生在每个构造函数的开始处）类似于

class B {
    B() {
        o = new A();
        System.out.print("Inside Constructor B");
    }

    A o = null;
}

因此，您还需要创建类A的实例。

所以当你打电话

public static void main(String args[])
{
    A op=new A();
}

new A()首先加载执行

的A类

static {
    System.out.print("Inside Static Block A");
}

然后尝试执行构造函数A(){

System.out.print("Inside A");
B obj = new B();

但在它结束执行之前，它会调用new B()来调用构造函数B(){中的代码，如前所示，这是

o = new A();
System.out.print("Inside Constructor B");

我们甚至在我们能够打印A之前必须创建另一个Inside Constructor B实例。

因此，当您看到创建类A的实例时，您需要创建类B的实例，该实例需要创建另一个类A的实例，该实例需要创建另一个类实例B ......依此类推，直到堆栈溢出。

Answer 3

这是因为你在A类和B类之间有一个循环引用。在你的构造函数中，创建一个对象B

cache: false

在B组中，您正在创建A类的新对象

$ionicView.loaded

在这里创建一个A类对象，它再次调用A类的构造函数，再次创建一个B类对象，因此整个过程进入无限循环

Answer 4

由于递归调用，无法访问该点。

B()
{
    System.out.println("Inside Constructor B");
    A o=new A();
}

A o=new A();

此代码应返回所需的输出：

Inside Static Block A
Inside A
Inside Constructor B

java中的非静态嵌套类

4 个答案: