Java 关于一种方法；无法解析为“类型”；错误

我试图在RBTree的底部创建空节点，并希望将EMPTY实例化为空节点

这是出现错误的行：

final private Node<E> EMPTY = new Empty();

final private Node EMPTY=new EMPTY（）；

空类：

  private class Empty extends Node<E> {

    public Empty() {
        red = false;
    }
    public Node<E> add(E data) {
        count++;
        return new Node<E>(data);
    }
    public Node<E> getNode(E data) {
        return null;
    }
}

私有类空扩展节点{
公共空（）{
红色=假；
}
公共节点添加（E数据）{
计数++；
返回新节点（数据）；
}
公共节点getNode（E数据）{
返回null；
}
}

我知道这和构造器有关，但我不能专注于它。 我尝试过搜索，但我在这个网站上看到的大多数东西都与android编程和/或其他一些我不熟悉的语言有关。我尝试了以下方法：

（节点）强制转换新的空（）；然后意识到显然不是这样

和全班同学一起工作，看看公众是否会起作用

除了编程更改外，我还尝试了这里提供的解决方案：

但是没有成功

如果这个问题不合适，很抱歉，谢谢您抽出时间

完整代码：

package data_structures;



public class RedBlackTree<E extends Comparable<E>> {

private Node<E> root;

private int count = 0;

final private Node<E> EMPTY = new Empty<E>();

public RedBlackTree() {
    root = EMPTY;
}

public void add(E data) {
    root = root.add(data);
    count++;
    root.red = false;
}


public boolean find(E data) {
    return root.getNode(data) != null;
}

private class Node<E> {
    public E data;

    public boolean red;
    public Node<E>   leftChild;
    public Node<E>   rightChild;

    /** Used by Empty */
    protected Node() {
        assert EMPTY == null;
    }

    /** Nodes always begin red */
    public Node(E k) {
        data  = k;
        red = true;
        leftChild  = (Node<E>) EMPTY;
        rightChild = (Node<E>) EMPTY;
    }

    private boolean isRed() {
        return red;
    }

    public int height(){
        return 0; //returns the counts binary left most bit position to determine the height.
    }

    public Node<E> add(E newData) {
        if(((Comparable<E>) newData).compareTo(data) == -1) {
            count++;
            leftChild = leftChild.add(newData);
            return leftChild;
        }
        if(((Comparable<E>) newData).compareTo(data) == +1){
            count++;
            rightChild = rightChild.add(newData);
            return rightChild;
        }
        if(((Comparable<E>) newData).compareTo(data) == 0){
            return this;
        }

        if (leftChild.isRed() && leftChild.leftChild.isRed()) {
            return balance(leftChild.leftChild, leftChild, this, 
                           leftChild.leftChild.rightChild, leftChild.rightChild);     

        } else if (leftChild.isRed() && leftChild.rightChild.isRed()) {
            return balance(leftChild, leftChild.rightChild, this, 
                           leftChild.rightChild.leftChild, leftChild.rightChild.rightChild); 

        } else if (rightChild.isRed() && rightChild.leftChild.isRed()) {
            return balance(this, rightChild.leftChild, rightChild,     
                           rightChild.leftChild.leftChild, rightChild.leftChild.rightChild); 

        } else if (rightChild.isRed() && rightChild.rightChild.isRed()) {
            return balance(this, rightChild, rightChild.rightChild,          
                           rightChild.leftChild, rightChild.rightChild.leftChild);     
        }

        return this;
    }


    /** Returns the node for this key, or null. */
    public Node<E> getNode(E newData) {
        if(((Comparable<E>) newData).compareTo(data) == -1){
            return leftChild.getNode(newData);  
        }
        if(((Comparable<E>) newData).compareTo(data) == +1){
            return rightChild.getNode(newData);
        }
        else{
            return this;
        }
    }
private class Empty<E> extends Node<E> {

    public Empty() {
        red = false;
    }
    public Node<E> add(E data) {
        count++;
        return new Node<E>(data);
    }
    public Node<E> getNode(E data) {
        return null;
    }
}

private Node<E> balance(Node<E> a, Node<E> b, Node<E> c, Node<E> d, Node<E> e) {

    a.rightChild = d;
    b.leftChild  = a;
    b.rightChild = c;
    c.leftChild  = e;
    a.red = false;
    b.red = true;
    c.red = false;
    return b;
}


}

包数据结构；
公共级红黑树{
私有节点根；
私有整数计数=0；
最终私有节点为空=新空（）；
红杉{
根=空；
}
公共空白添加（E数据）{
root=root.add（数据）；
计数++；
root.red=false；
}
公共布尔查找（E数据）{
返回root.getNode（数据）！=null；
}
私有类节点{
公共电子数据；
公共布尔红；
公共节点leftChild；
公共节点右子节点；
/**空的*/
受保护节点（）{
assert EMPTY==null；
}
/**节点总是以红色开头*/
公共节点（ek）{
数据=k；
红色=真；
leftChild=（节点）为空；
rightChild=（节点）为空；
}
私有布尔isRed（）{
返回红色；
}
公共整数高度（）{
return 0；//返回用于确定高度的二进制最左边位位置的计数。
}
公共节点添加（E新数据）{
如果（（可比较的）新数据）。比较到（数据）=-1）{
计数++；
leftChild=leftChild.add（newData）；
返回leftChild；
}
如果（（可比较的）新数据）。比较到（数据）=+1）{
计数++；
rightChild=rightChild.add（新数据）；
还权子；
}
如果（（可比较的）新数据）。比较到（数据）==0）{
归还这个；
}
if（leftChild.isRed（）&&leftChild.leftChild.isRed（））{
返回余额（leftChild.leftChild，leftChild，this，
leftChild.leftChild.rightChild，leftChild.rightChild）；
}else if（leftChild.isRed（）&&leftChild.righchild.isRed（））{
返回余额（leftChild，leftChild.rightChild，this，
leftChild.rightChild.leftChild，leftChild.rightChild.rightChild）；
}else if（rightChild.isRed（）&&rightChild.leftChild.isRed（））{
返回余额（this，rightChild.leftChild，rightChild，
rightChild.leftChild.leftChild，rightChild.leftChild.rightChild）；
}else if（rightChild.isRed（）&&rightChild.rightChild.isRed（））{
返回余额（this，rightChild，rightChild.rightChild，
rightChild.leftChild，rightChild.rightChild.leftChild）；
}
归还这个；
}
/**返回此键的节点，或null*/
公共节点getNode（E newData）{
如果（（可比较的）新数据）。比较到（数据）=-1）{
返回leftChild.getNode（newData）；
}
如果（（可比较的）新数据）。比较到（数据）=+1）{
返回rightChild.getNode（newData）；
}
否则{
归还这个；
}
}
私有类空扩展节点{
公共空（）{
红色=假；
}
公共节点添加（E数据）{
计数++；
返回新节点（数据）；
}
公共节点getNode（E数据）{
返回null；
}
}
专用节点余额（节点a、节点b、节点c、节点d、节点e）{
a、 rightChild=d；
b、 leftChild=a；
b、 rightChild=c；
c、 leftChild=e；
a、 红色=假；
b、 红色=真；
c、 红色=假；
返回b；
}
}

}你不能写

Node<E> EMPTY = new Empty<E>();

Node EMPTY=new EMPTY（）；

因为E是泛型类型。只能创建具有实际类的对象，例如：

Node<String> EMPTY = new Empty<String>()

Node EMPTY=new EMPTY（）

如果你知道你在做什么，你可以做一个丑陋的恶作剧，应该有一个警告

Node<E> EMPTY = new Empty();

Node EMPTY=new EMPTY（）；

---

另外，将空类移到节点之外。

我现在感觉被投资了：）我删除了旧答案并添加了新答案。我复制了您的代码，并将答案更新为可编译的内容。还有一个问题是空类的定义位置。是的，我把它移出了，瞧，没有更多的错误了！谢谢那个丑陋的把戏仍然会导致同样的错误。目前我正在寻找替代方案，因为我不知道该怎么办。我想重新定位这句话，但我想我不能把它放在其他地方。