java - 为什么方法不能识别指向静态变量的变量？

Question

我正在尝试实现一个红黑树，它的每个节点都由另一个 RBTree 组成。这样我就能得到好的歌曲。第一棵树是乐队，每个节点(乐队)都有其歌曲的 RBTree。

所以我尝试将一首新歌曲插入乐队树中乐队节点的内部歌曲树中，并且内部树无法识别其'头指向的静态变量零节点。不知道为什么。

这两个 RBTree 类的插入方法是相同的。每次插入都会考虑静态变量“nilNode”并根据它进行工作。当我将节点插入外部树(带树)时，该方法会识别它。但是当我从 band 节点之一使用内部树的 getter 并使用内部树的 insert 方法时，它无法识别其方法中的 nilNode 。

插入方法如下:
1.带状树称为插入。
2.该方法首先在bandsTree中查找band的节点。
3.然后节点使用getter来获取他的内部歌曲Tree。
4.innerTree调用相同的插入方法(他的插入方法与bands Tree的插入方法相同)。

现在插入方法使用搜索方法来查看节点(乐队或歌曲)是否已经存在或需要创建。如果存在，则返回该节点，如果不存在，则返回连接到节点的每个“松散末端”的静态“nilNode”。搜索方法从树的头部开始。
在第一次插入时，歌曲树(当前乐队节点的)是空，这意味着头指向静态“nilNode”。因此搜索方法应该在第一次检查循环时停止。但它无法识别 head 等于 nilNode 因此它会继续，并且当它获取 nilNode 的左节点时出现错误这是 null 并尝试使用它。

这些是我创建的 4 个类:BandNode、BandsRBTree、SongNode、SongsRBTree

<强>1。频段节点:

import java.io.Serializable;

public class BandNode implements Serializable{
    private Band band;
    private BandNode left;
    private BandNode right;
    private BandNode parent;
    private SongsRBTree innerTreeOfSongNames = new SongsRBTree(); **// another RBTree**
    ...

    public BandNode(String bandName) **// I got 4 constructors and each looks like this one**
    {   
        Band band = new Band(bandName);
        this.band = band;
        left = null;
        right = null;
        parent = null;
        innerTreeOfSongNames = new SongsRBTree();
    }
    ...
}//end of class BandNode

<强>2。 SongNode://没有像 BandNode 这样的内部树

public class SongNode implements Serializable{
    private Song song;
    private SongNode left;
    private SongNode right;
    private SongNode parent;
    ...

    public SongNode(String songName) // same here 4 constructors
    {
        Song _song = new Song(songName);
        this.song = _song;
        left=null;
        right=null;
        parent=null;
    }
    ...
}//end of SongNode class

<强>3。 BandsRBTree

import java.io.Serializable;

public class BandsRBTree implements Serializable{
    private BandNode head; // head of the tree
    static BandNode nilNodeBand; // Nil node to be connected to every 2 (left and right) null ends of a node
    ...

    public BandsRBTree()
    {
        nilNodeBand = new BandNode("Nill)");
        head = nilNodeBand;
    }

    //******************************************************
    //          methods for inner tree:

    public BandNode insert(BandNode z , SongNode songNde)
    {
        BandNode b = search(z.getBand().getBandName()); // searches for the band node
        if(b.equals(nilNodeBand)) // meaning the band node doesn't exists
        {
            //nothing to show here since it doesn't go in this part. 
            because the band node already exsits and the condition is false
            ...
        }
        else // the band is already in the tree. 
            now update it's inner tree of songs
        {   
            //checking if the song node is good
            if(songNde != null && songNde.getSong() != null)
            {
                    if(songNde.getSong().getSongName().length()>0  ) // name of the song is good
                    {
                        b.getInnerTreeOfSongNames().insert(songNde); // using the inner tree of songs
                        return b; // return the band node
                    }
                    else 
                        //print error
            }

            return null; // something was null
        }

    }//insert


    //search in the band tree:
    public BandNode search(String bandNameToSearch)
    {
        BandNode temp = head;
        while( !temp.equals( nilNodeBand)) 
        {
            if( temp.getBand().getBandName().compareTo(bandNameToSearch) == 0  )
                return temp;
            else if(bandNameToSearch.compareTo(temp.getBand().getBandName()) < 0  )
                temp = temp.getLeft();
            else
                temp = temp.getRight();
        }
        return nilNodeBand;
    }

}// class BandsRBTree end

<强>4。歌曲RBTree

import java.io.Serializable;

public class SongsRBTree implements Serializable{
    private SongNode head; // head of the tree
    static SongNode nilNodeSong; // Nil node to be connected as every null child
    ...
    //constructor
    public SongsRBTree()
    {
        nilNodeSong = new SongNode(new Song("Nill"));
        head = nilNodeSong;  // the head is nilNode at the start
    }

    public SongNode insert(SongNode z )
    {     
        // first search:
        SongNode b = search(z.getSong().getSongName()); 

        ...
        //the method get here because of the error in the search method

    }//insert


    public SongNode search(String songNameToSearch)
    {
        SongNode temp = head; // here the head is nilNode. see in the constructor

        while( !temp.equals( nilNodeSong) ) // it enters the loop. ALTOUGH IT SHOULDN'T
        {                                   //  because temp = head. and the head suppose to be nilNodeSong
                                            //  since the tree is empty at the beginning
                                            //  see constructor
            if( temp.getSong().getSongName().compareTo(songNameToSearch) == 0  )
                return temp;
            else if(songNameToSearch.compareTo(temp.getSong().getSongName()) < 0  )
                temp = temp.getLeft();
            else
                temp = temp.getRight();
        }
        return nilNodeSong;

    }
} // end of BandsRBTree class  

无论如何，情况是这样的:
1. 我有一个带树，设置了 10 个带节点
2. 每个节点通过 bandNode 的构造函数拥有一个空的内部树。
3. 我尝试使用其中一个内部树的插入方法第一次向其中插入歌曲。
4. 搜索方法无法识别树头指向nilNode。
为什么不认识到这一点？(头在开始时是 nilNode，因为它是空的)

问题出现在BandsRBTree类的search方法中的while循环条件下。该条件假设是为了阻止该方法进入循环体，因为在第一次插入时，构造函数的头是 nilNode，但该条件无法识别这一点。为什么？？

请帮忙。

Answer 1

每次构造 SongsRBTree 时，您都会清除静态变量的先前内容，并在其位置创建一个新的 SongNode。快速分步:您创建 SongsRBTree tree1。现在，nilNodeSong 是一个SongNode，我们将其称为nill1。 tree1 的 head 是 nill1。

现在您创建SongsRBTree tree2。现在，nilNodeSong 是一个 SongNode，我们将其称为 nill2。 tree2 的 head 是 nill2，但 tree1 的 head 仍然是 >nill1。当您插入类(class)的tree1时，它无法识别nill1 == nill2。

解决方案:静态初始化器或覆盖SongNode中的equals方法，并且不用担心特殊的static SongNode nillNodeSong。我可能会选择覆盖 equals 但两者都可以解决问题。