Java 构造函数中的StackOverflowerr异常

我收到了这个例外

Exception in thread "main" java.lang.StackOverflowError
at java.util.AbstractCollection.<init>(AbstractCollection.java:66)
at java.util.AbstractList.<init>(AbstractList.java:76)
at java.util.ArrayList.<init>(ArrayList.java:151)

线程“main”java.lang.StackOverflower中出现异常 位于java.util.AbstractCollection。（AbstractCollection.java:66） 位于java.util.AbstractList。（AbstractList.java:76） 位于java.util.ArrayList。（ArrayList.java:151） 这是否意味着类不能将自身的对象作为变量包含？但在链表实现中，节点可以包含指向自身的节点

public class Test {

String name;
List<Test> related;

public Test() {

    name = "dog";
    related = new ArrayList<Test>();    
    related.add(new Test());
    related.add(new Test());
    related.add(new Test());
}

public List<Test> relate() {

    return related;
}

public String toString() {
    return name;
}

public static void main(String[] args) {

    Test test = new Test();
    for(Test t : test.relate()) {
        System.out.println(t);
    }
}
}

公共类测试{
字符串名；
与清单有关；
公开考试（）{
name=“dog”；
related=新的ArrayList（）；
添加（新测试（））；
添加（新测试（））；
添加（新测试（））；
}
公开名单{
回归相关；
}
公共字符串toString（）{
返回名称；
}
公共静态void main（字符串[]args）{
测试=新测试（）；
for（Test t:Test.relate（））{
系统输出打印ln（t）；
}
}
}

您的构造函数为自己创建三个新实例，每个实例创建三个新实例，每个实例创建三个新实例，依此类推

---

要解决这个问题，您应该创建两个独立的类—一个实现链表，另一个创建并使用链表。

您的构造函数创建了三个自身的新实例，每个实例创建了三个新实例，每个实例创建了三个新实例，依此类推

public Test() {

    name = "dog";
    related = new ArrayList<Test>();    
    related.add(new Test()); // Here, you can calling the constructor
    related.add(new Test()); // recursively within the constructor?
    related.add(new Test()); // Hence the StackOverflowError?
}

要解决这个问题，您应该创建两个独立的类—一个实现链表，另一个创建并使用链表。

public Test（）{
public Test() {

    name = "dog";
    related = new ArrayList<Test>();    
    related.add(new Test()); // Here, you can calling the constructor
    related.add(new Test()); // recursively within the constructor?
    related.add(new Test()); // Hence the StackOverflowError?
}

name=“dog”；
related=新的ArrayList（）；
related.add（new Test（））；//在这里，您可以调用构造函数
related.add（new Test（））；//在构造函数中递归？
related.add（new Test（））；//因此出现StackOverflower错误？
}

不要认为它与包含自身对象作为变量的类有关。

public Test（）{
name=“dog”；
related=新的ArrayList（）；
related.add（new Test（））；//在这里，您可以调用构造函数
related.add（new Test（））；//在构造函数中递归？
related.add（new Test（））；//因此出现StackOverflower错误？
}

---

不要认为它与包含自身对象作为变量的类有关。

您可以通过向构造函数添加一个参数来解决此问题，该参数指定要添加多少元素，从而证明此问题是代码中的无限递归，而不是在构造函数中创建新实例的固有问题：

import java.util.ArrayList;
import java.util.List;

public class Test {

  String name;
  List<Test> related;

  public Test(int numberToAdd) {

    name = "dog";
    related = new ArrayList<Test>();
    for (int i = 0; i < numberToAdd; i++) {
      related.add(new Test(0));
    }
  }

  public List<Test> relate() {

    return related;
  }

  public String toString() {
    return name;
  }

  public static void main(String[] args) {

    Test test = new Test(3);
    for (Test t : test.relate()) {
      System.out.println(t);
    }
  }
}

import java.util.ArrayList；
导入java.util.List；
公开课考试{
字符串名；
与清单有关；
公共测试（整数加）{
name=“dog”；
related=新的ArrayList（）；
for（int i=0；i

您可以通过向构造函数添加一个参数来修复该问题，该参数指定要添加的元素数量，从而证明该问题是代码中的无限递归，而不是在构造函数中创建新实例的固有问题：

import java.util.ArrayList;
import java.util.List;

public class Test {

  String name;
  List<Test> related;

  public Test(int numberToAdd) {

    name = "dog";
    related = new ArrayList<Test>();
    for (int i = 0; i < numberToAdd; i++) {
      related.add(new Test(0));
    }
  }

  public List<Test> relate() {

    return related;
  }

  public String toString() {
    return name;
  }

  public static void main(String[] args) {

    Test test = new Test(3);
    for (Test t : test.relate()) {
      System.out.println(t);
    }
  }
}

import java.util.ArrayList；
导入java.util.List；
公开课考试{
字符串名；
与清单有关；
公共测试（整数加）{
name=“dog”；
related=新的ArrayList（）；
for（int i=0；i

这个怎么样：

package com.my.test;

import java.util.ArrayList;
import java.util.List;

public class Test {

private String name;
private List<Test> related;

public Test(String name, int times) {
    this.name = name;
    related = new ArrayList<Test>();
    for(int i = 0; i < times; i++) {
        related.add(new Test("child"+i, 0));
    }
}

public List<Test> relate() {
    return related;
}

public String toString() {
    return name;
}

public static void main(String[] args) {
    Test test = new Test("parent", 3);
    for (Test t : test.relate()) {
        System.out.println(t);
    }
}
}

package com.my.test；
导入java.util.ArrayList；
导入java.util.List；
公开课考试{
私有字符串名称；
私人名单相关；
公共测试（字符串名称，整数倍）{
this.name=名称；
related=新的ArrayList（）；
for（int i=0；i

这个怎么样：

package com.my.test;

import java.util.ArrayList;
import java.util.List;

public class Test {

private String name;
private List<Test> related;

public Test(String name, int times) {
    this.name = name;
    related = new ArrayList<Test>();
    for(int i = 0; i < times; i++) {
        related.add(new Test("child"+i, 0));
    }
}

public List<Test> relate() {
    return related;
}

public String toString() {
    return name;
}

public static void main(String[] args) {
    Test test = new Test("parent", 3);
    for (Test t : test.relate()) {
        System.out.println(t);
    }
}
}

package com.my.test；
导入java.util.ArrayList；
导入java.util.List；
公开课考试{
私有字符串名称；
私人名单相关；
公共测试（字符串名称，整数倍）{
this.name=名称；
related=新的ArrayList（）；
for（int i=0；i

new Test（）在内部做什么？这不是CALS将其对象作为成员变量的问题，我认为这是因为方法的递归调用，您应该遵循一个逻辑，该逻辑将退出递归调用What does

new Test（）

do internal？这不是CALS将其对象作为成员变量存在的问题，我认为这是因为方法的递归调用，您应该遵循一个将退出递归调用的逻辑