Java：结合泛型、内部 class 和 "implements" 的问题

Question

我在结合泛型、implements 和内部 classes 时遇到问题。我正在创建一个包含内部 class 的 LinkedBinaryHeap class。这个内部 class 是泛型 HeapNode，它扩展了我创建的泛型 Node class；它只是为 key/priority.

添加了一个变量和方法

在 LinkedBinaryHeap 中，我创建了一个通用的 LinkedList 来存储 HeapNode。我假设存储的通用数据扩展 Comparable class.

这是什么存储什么的布局：

BinaryHeap->LinkedList(Nodes)->HeapNode(extends Node)->DATA,KEY

我的问题是在声明 LinkedList 时：

LinkedList<HeapNode> heap;

eclipse 下划线 HeapNode 并给我错误：

绑定不匹配：类型 LinkedBinaryHeap.HeapNode 不是
有界参数的有效替代>
类型为 LinkedList

我认为错误告诉我 HeapNode 必须实现 Comparable，但是我的 Node class 实现Comparable，这样就处理好了，对吗？

我尝试了各种不同的方法，但似乎没有任何效果，下面的代码是我最接近的。请注意，我尝试将 implements Comparable Node<T> 离开 HeapNode 内部 class，但它没有任何改变。

代码：

LinkedBinaryHeap.java:

public class LinkedBinaryHeap<E extends Comparable<E>> {
    private LinkedList<HeapNode> heap;

    public LinkedBinaryHeap(){
        heap = new LinkedList<HeapNode>();
    }

    /* INNER CLASS DECLARATION. */
    private class HeapNode extends Node<E> implements Comparable<Node<E>>{
        int key;
        public HeapNode(int key, E data){
            super(data);
            this.key = key;
        }

        public int getKey(){
            return key;
        }

        public void setKey(int key){
            this.key = key;
        }
    }
}

Node.java:

public class Node<T extends Comparable<T>> implements Comparable<Node<T>>{
    protected T data;
    protected Node<T> next;
    protected Node<T> previous;

    public Node(T data){
        next = null;
        previous = null;
        this.data = data;
    }   

    /* Some other methods left out here. */

    public int compareTo(Node<T> node) {
        return data.compareTo(node.getData());
    }
}

LinkedList.java:

public class LinkedList<T extends Comparable<T>> implements Comparable<LinkedList<T>>{
    private Node<T> head;
    private Node<T> tail;
    private int size;

    public LinkedList(){
        head = null;
        tail = null;
        size = 0;
    }

    /* Other methods left out. */

    public int compareTo(LinkedList<T> list){
        // does stuff.
    }
}

Answer 1

LinkedList 要求 T 实现 Comparable。 HeapNode 实现 Comparable<Node<E>>。 HeapNode != Node 所以它不满足类型绑定。将 LinkedList 的声明更改为 T extends Comparable<? super T>。这在类型方面很好：HeapNode 声明它可以将自己与任何 Node 或 Node 的子类型进行比较。当然，这意味着 HeapNode 需要覆盖 compareTo，但你有点卡在那里，Node 已经实现了 Comparable。

编辑：正如评论指出的那样，这个答案是错误的，不值得修正，因为有一个正确的答案。让它留给子孙后代，作为……某事的教训。也许我对泛型的了解不如我想的那样。

Answer 2

根据您的定义：

HeapNode 是 Node<E> 的子类型，但 implements Comparable<Node<E>>
LinkedList 需要一个类型参数，这样 T implements Comparable<T>
即LinkedList<HeapNode> 要求 HeapNode implements Comparable<HeapNode>
它不是（从上面的（1）开始，它implements Comparable<Node<E>>）

所以两者不兼容

您需要在 LinkedList 中将节点类型表示为类型参数，适当地限制，以及节点类型的组件类型参数，也适当地限制：

public class LinkedList<N extends Node<E>, 
                        E extends Comparable<E>> 
  implements Comparable<LinkedList<N, E>>{
  private N head;
  private N tail;
  private int size;
  ...

现在您的 LinkedBinaryHeap 需要调整它对 LinkedList 的使用：

public class LinkedBinaryHeap<E extends Comparable<E>> {
  private LinkedList<HeapNode, E> heap;

  public LinkedBinaryHeap(){
      heap = new LinkedList<HeapNode, E>();
  }

现在应该可以编译了。它是否实现了你将所有事物与其他事物进行比较的目标就很难说了！

Java：结合泛型、内部 class 和 "implements" 的问题

Java: Issue combining Generics, Inner class, and "implements"

java

generics

inner-classes

implements