扩展类似的通用

我正在开发一个基于模板的Java类实现各种树结构（如标准二叉树，红黑树或B树）。我的想法是让它像Java Collections中的各种列表一样完成。这是一个接口类，然后由指定的树进行扩展。不过，我打了一个奇怪的问题，在墙上：扩展类似的通用

BSTree.java:12: error: BSTree is not abstract and does not override abstract method  search(Comparable) in Tree 
public class BSTree<T extends Comparable<T>> extends Tree { 
    ^

BSTree.java:20: error: name clash: add(T#1) in BSTree and add(T#2) in Tree have the same erasure, yet neither overrides the other 
    public void add(T key) throws NullPointerException { 
       ^
    where T#1,T#2 are type-variables: 
    T#1 extends Comparable<T#1> declared in class BSTree 
    T#2 extends Comparable<T#2> declared in class Tree 

BSTree.java:28: error: method compareTo in interface Comparable<T#2> cannot be applied  to given types; 
       if (key.compareTo(ptr.key) == -1) { 
       ^
    required: T#1 
    found: Comparable 
    reason: actual argument Comparable cannot be converted to T#1 by method invocation conversion 
    where T#1,T#2 are type-variables: 
    T#1 extends Comparable<T#1> declared in class BSTree 
    T#2 extends Object declared in interface Comparable 

BSTree.java:42: error: name clash: remove(T#1) in BSTree and remove(T#2) in Tree have the same erasure, yet neither overrides the other 
    public void remove(T key) throws NullPointerException, TreeException { 
       ^
    where T#1,T#2 are type-variables: 
    T#1 extends Comparable<T#1> declared in class BSTree 
    T#2 extends Comparable<T#2> declared in class Tree 

BSTree.java:49: error: method compareTo in interface Comparable<T#2> cannot be applied  to given types; 
      if (key.compareTo(ptr.key) == 0) { 
       ^
    required: T#1 
    found: Comparable 
    reason: actual argument Comparable cannot be converted to T#1 by method invocation conversion 
    where T#1,T#2 are type-variables: 
    T#1 extends Comparable<T#1> declared in class BSTree 
    T#2 extends Object declared in interface Comparable 

BSTree.java:81: error: method compareTo in interface Comparable<T#2> cannot be applied to given types; 
      else if (key.compareTo(ptr.key) < 0) ptr = ptr.left; 
         ^
    required: T#1 
    found: Comparable 
    reason: actual argument Comparable cannot be converted to T#1 by method invocation conversion 
    where T#1,T#2 are type-variables: 
    T#1 extends Comparable<T#1> declared in class BSTree 
    T#2 extends Object declared in interface Comparable 

BSTree.java:89: error: name clash: search(T#1) in BSTree and search(T#2) in Tree have  the same erasure, yet neither overrides the other 
    public Node<T> search(T key) throws NullPointerException, KeyNotStoredException { 
       ^
    where T#1,T#2 are type-variables: 
    T#1 extends Comparable<T#1> declared in class BSTree 
    T#2 extends Comparable<T#2> declared in class Tree 

BSTree.java:94: error: method compareTo in interface Comparable<T#2> cannot be applied to given types; 
      if (key.compareTo(ptr.key) == 0) return ptr; 
       ^
    required: T#1 
    found: Comparable 
    reason: actual argument Comparable cannot be converted to T#1 by method invocation conversion 
    where T#1,T#2 are type-variables: 
    T#1 extends Comparable<T#1> declared in class BSTree 
    T#2 extends Object declared in interface Comparable 

BSTree.java:95: error: method compareTo in interface Comparable<T#2> cannot be applied to given types; 
      else if (key.compareTo(ptr.key) < 0) ptr = ptr.left; 
        ^
    required: T#1 
    found: Comparable 
    reason: actual argument Comparable cannot be converted to T#1 by method invocation conversion 
    where T#1,T#2 are type-variables: 
    T#1 extends Comparable<T#1> declared in class BSTree 
    T#2 extends Object declared in interface Comparable

它看起来像Java认为，对象是不同类型的...如何解决呢？

下面是一段我的代码：

Tree.java

class Node<T extends Comparable<T>> { 

    protected T key; 
    protected Node parent, left, right; 

    public Node(T key, Node parent) { 
     this.key = key; 
     this.parent = parent; 
     this.left = null; 
     this.right = null; 
    } 

} 

public abstract class Tree<T extends Comparable<T>> { 
    protected Node<T> root; 
protected Integer nodesCount; 

    public abstract void add(T key) throws NullPointerException; 

    public abstract void remove(T key) throws NullPointerException, TreeException; 

    public abstract Node<T> search(T key) throws NullPointerException, KeyNotStoredException; 
}

BSTree.java

public class BSTree<T extends Comparable<T>> extends Tree { 

    public BSTree() { 
     root = null; 
     nodesCount = new Integer(0); 
    } 

    @Override 
    public void add(T key) throws NullPointerException { 
     if (root == null) root = new Node<T>(key, null);  
     else {  
      boolean left = false; 
      Node ptr = root, parent = ptr.parent; 
      while (ptr != null) { 
       parent = ptr; 
       left = false; 
       if (key.compareTo(ptr.key) == -1) { 
        ptr = ptr.left; 
        left = true; 
       } else ptr = ptr.right; 
      } 

      if (left) parent.left = new Node<T>(key, parent); 
      else parent.right = new Node<T>(key, parent); 
     } 

     nodesCount++; 
    } 

    @Override 
    public void remove(T key) throws NullPointerException, TreeException { 
     /* implementation */ 
    } 

    @Override 
    public Node<T> search(T key) throws NullPointerException, KeyNotStoredException { 
     /* implementation */ 
    } 

}

编辑：感谢您的咨询件我能将错误数量减少到5.这里是：的javac -d ../bin *的.java

BSTree.java:28: error: method compareTo in interface Comparable<T#2> cannot be applied to given types; 
       if (key.compareTo(ptr.key) == -1) { 
        ^
    required: T#1 
    found: Comparable 
    reason: actual argument Comparable cannot be converted to T#1 by method invocation conversion 
    where T#1,T#2 are type-variables: 
    T#1 extends Comparable<T#1> declared in class BSTree 
    T#2 extends Object declared in interface Comparable 

BSTree.java:49: error: method compareTo in interface Comparable<T#2> cannot be applied to given types; 
      if (key.compareTo(ptr.key) == 0) { 
      ^
    required: T#1 
    found: Comparable 
    reason: actual argument Comparable cannot be converted to T#1 by method invocation conversion 
    where T#1,T#2 are type-variables: 
    T#1 extends Comparable<T#1> declared in class BSTree 
    T#2 extends Object declared in interface Comparable 

BSTree.java:81: error: method compareTo in interface Comparable<T#2> cannot be applied to given types; 
      else if (key.compareTo(ptr.key) < 0) ptr = ptr.left; 
         ^
    required: T#1 
    found: Comparable 
    reason: actual argument Comparable cannot be converted to T#1 by method invocation  conversion 
    where T#1,T#2 are type-variables: 
    T#1 extends Comparable<T#1> declared in class BSTree 
    T#2 extends Object declared in interface Comparable 

BSTree.java:94: error: method compareTo in interface Comparable<T#2> cannot be applied to given types; 
      if (key.compareTo(ptr.key) == 0) return ptr; 
       ^
    required: T#1 
    found: Comparable 
    reason: actual argument Comparable cannot be converted to T#1 by method invocation conversion 
    where T#1,T#2 are type-variables: 
    T#1 extends Comparable<T#1> declared in class BSTree 
    T#2 extends Object declared in interface Comparable 

BSTree.java:95: error: method compareTo in interface Comparable<T#2> cannot be applied to given types; 
      else if (key.compareTo(ptr.key) < 0) ptr = ptr.left; 
         ^
    required: T#1 
    found: Comparable 
    reason: actual argument Comparable cannot be converted to T#1 by method invocation conversion 
    where T#1,T#2 are type-variables: 
    T#1 extends Comparable<T#1> declared in class BSTree 
    T#2 extends Object declared in interface Comparable

现在，我的代码有Node<T>和Tree<T>它缺乏它。但是还有什么问题呢？

来源

2013-01-01 Robin92

您可能需要扩展'Tree '，而不是'Tree' ... –

您使用新的错误消息编辑没有匹配的代码，所以很难说，但它看起来像'ptr'仍然被声明为'Node'而不是'Node '。 –

当您在JDK复制功能，你应该阅读代码来得到一些想法。

您的代码需要使用Node和Tree泛型。

public class BSTree<T extends Comparable<T>> extends Tree<T> {

和

protected Node<T> parent, left, right;

BTW：你不应该使用的包装时，你可以使用原始的。

protected int nodesCount;

来源

2013-01-01 15:14:58

也可以在'BSTree＃add（T）'方法中使用'Node ptr = root，parent = ptr.parent;'。 –

谢谢它的工作 – Robin92

你缺少Tree泛型参数在BSTree声明：

public class BSTree<T ...> extends Tree<T>

这意味着BSTree的add(T)方法不会覆盖一个在Tree，因为它是，因为他们没有相同的参数类型。

然而，由于T作为一类不是更精确的比Object（我们只知道它实现了Comparable接口），这两种方法具有相同的擦除作为add(Object)，具有潜在的不兼容的类型（在所识别的编译器的错误输出为T#1和T#2）。

来源

2013-01-01 15:14:07

尝试：

public class BSTree<T extends Comparable<T>> extends Tree<T> {

来源

2013-01-01 15:14:08

扩展类似的通用

回答

相关问题