Java 当声明两个对象各自包含另一个对象时，如何防止无限递归？

这是我的第一个问题，我已经很紧张了。我可能会以“Its for my Homegram”（这是我的家庭作业）开始，但我会努力解决这个问题： 我必须实现一个简单的售票程序，它包含两个类： 包含以下字段的类票证：

public class Ticket
{
    //Fields
    private int ticketID;
    private boolean sold;
    private Category category;

    //Constructor
    public Ticket(int ticketID, Category category)
    {
        this.ticketID = ticketID;
        this.category = category;
        this.sold = false;
    }
}

还有一个名为Category的类，应该如下所示：

public class Category
{
    char category;
    double sellPrice;
    Ticket[] tickets;

    private Random rnd;

    public Category(char category, double sellPrice, int amount)
    {
        this.category = category;
        this.sellPrice = sellPrice;

        //from here on my difficulties start!
        rnd = new Random(System.nanoTime());

        tickets = new Ticket[amount];
        for(int i = 0; i < tickets.length; i++)
        {
            tickets[i] = new Ticket(generateRandom(100000, 1000000), this); 
            //especially this line worries me!
        }
    }

公共类类别
{
炭类；
双倍售价；
票务[]票务；
私有随机rnd；
公共类别（字符类别、双倍售价、整数金额）
{
this.category=类别；
this.sellPrice=sellPrice；
//从这里开始我的困难！
rnd=新随机（System.nanoTime（））；
票证=新票证[金额]；
对于（int i=0；i

为了简单起见，我将代码简化为最小值。现在我的问题是，我应该创建一个类别数组，其中包含票证数组，但当我这样做时，我会创建一个无限循环，通过传递“this”将每个票证引用到Category对象在调试我的项目时，我真的创建了一个“无限”循环，因为我总是可以更深入地研究category->tickets[]->category->tickets[]->…等等的组合。作业中说我必须在Ticket中使用category类，但是有没有其他方法可以创建一个没有这些“循环”的系统?

当声明两个对象各自包含另一个对象时，如何防止无限递归

在您给定的示例中，不会出现所谓的无限递归问题。只有当您有以下情况时，才会出现这种情况：

class Ticket{
    public Ticket(){
        new Category();
    }
}

class Category{
    public Category(){
        new Ticket();
    }
}

---

它不会永远引用自己吗

如果您只是创建一个变量，例如：

Ticket ticket;

---

构造函数将不会被调用。构造函数将仅在实例化对象时被调用，即：

new Ticket（）；

您是对的，您总是可以深入了解

类别->tickets[]->类别->tickets[]->

，等等，如果您这样做了，这确实是一个问题，但您没有向我们展示您实际执行此操作的任何代码

引用不是实例化。因此在我们的示例中，

Category

实例化了一堆

Ticket

s，这确实占用了很多空间；但是

Ticket

没有实例化

Category

，而只是引用它。通常每个Ticket只额外64位

这样想吧。实例化（通过调用

new

）就像生孩子一样。引用就像指向某人。两个人可以互相指向对方，或者许多人可以指向你，这不会花很多钱

---

当你拜访指向B的人A，然后决定再次拜访A，然后再次拜访B等时，你可能会进入一个无限循环。他们互相指向对方的事实不会导致任何此类问题。

这个“无限循环”有什么问题？我看不出这里有什么问题，难道它不会永远引用自己吗？除非你写一些永远遵循这些引用的代码，否则它不会。引用的美妙之处在于它们可以是周期性的-

a

can reference

b

和

b

can reference

a

。然而，对于e例如，如果两个对象的

equals（）

引用这些循环字段，则

equals（）

方法无法终止。只要注意避免每个类的方法中出现无限递归，循环引用就没有问题。