Java:StackOverflowError

Question

我正在研究Inner Class概念并编写以下代码_

public class InnerClassConcepts {
private int x = 11;

public static void main(String... args) {
    // method local 'x' variable
    int x = new InnerClassConcepts().new InnerA().new InnerB().x;

    InnerClassConcepts in = new InnerClassConcepts();
    InnerA InnerA = in.new InnerA();
    InnerA.InnerB xx = in.new InnerA().new InnerB();

    System.out.println("InnerClassConcepts`s x = " + in.x);
    System.out.println("InnerB`s x = " + xx.x);
    System.out.println("main`s x(local variable) = " + x);
    // System.out.println("InnerA`s x = " + InnerA.x);
    System.out.println("InnerA`s y = " + InnerA.y);
}

/**
 * Local inner class.
 */
class InnerA {
    int y = 10;

    /*
     * java.lang.StackOverflowError coming over here... I don`t
     * understand why?
     */
    // int x=new InnerClassConcepts().new InnerA().new InnerB().x;//Line-29
    /**
     * Inner class inside an another Inner class.
     */
    class InnerB {
        private int x = 22;
        int z = InnerA.this.y;

    }

 }
}

Output_

InnerClassConcepts's x = 11
InnerB's x = 22
main's x(local variable) = 22
InnerA's y = 10

我很奇怪,为什么StackOverflowError是在未来line-29,当我取消线29.同样在main方法中工作的地方.

有人可以帮助我,我错了或者背后有什么概念？

Answer 1

当InnerA创建一个实例时,变量x被初始化,导致InnerA创建一个,另一个x被初始化,依此类推.

就这样 StackOverflowError

// int x=new InnerClassConcepts().new InnerA().new InnerB().x;//Line-29

在堆栈跟踪中,StackoverFlowError您应该看到InnerA一次又一次地调用Constructor .

像这样的东西

at InnerClassConcepts$InnerA.<init>(InnerClassConcepts.java:31)
at InnerClassConcepts$InnerA.<init>(InnerClassConcepts.java:31)
at InnerClassConcepts$InnerA.<init>(InnerClassConcepts.java:31)

Answer 2

让我们让这个例子更简单一点来解释会发生什么:

class Example {
    private Example example = new Example();
}

创建新Example对象时会发生什么？

创建新对象,然后初始化其成员变量.Class Example有一个成员变量Example.因此,要初始化成员变量,将Example创建一个新对象.那个又有一个Example需要初始化的成员变量.因此,再次Example创建一个新对象.而且那个又有一个Example需要初始化的成员变量.这种情况永远存在.

你有一个无限的递归循环,这导致了一个StackOverflowError.

InnerA取消注释第29行时,你的类中有完全相同的东西:成员变量x用new初始化,new InnerA有自己的成员变量,用新的初始化InnerA等等.