普林斯顿大学算法课程中二进制堆程序中可比较的接口（Java）的实现

Question

我不使用广泛的Java进行编程，因此只掌握有关该语言的基本知识。我在做an algorithm course on coursera。

本课程中给出的二进制堆程序是：

public class MaxPQ<Key extends Comparable<Key>>
{
    private Key[] pq;
    private int N;


    public MaxPQ(int capacity)
    { pq = (Key[]) new Comparable(capacity + 1);
    }
    public boolean isEmpty()
    { return N==0;}
    public void insert(Key key)
    { pq[++N] = x;
      swim(N);}
    private void swim(int k)
    {  while(k>1 && less(k/2,k))
       {
            exch(k,k/2);
            k=k/2;
       }
    }
    public key delMax()
    {
         Key max = pq[1];
         exch(1,N--);
         sink(1);
         pq[N+1] = null; //To prevent loitering.
         return max;
    }
    private void sink(int k)
    {
         while(2*k<=N){
            int j= 2*k;
            if(j<N && less(j,j+1))j++;
            if(!less(k,j)) break;
            exch(k,j);
            k=j;}
    }
    private boolean less(int i, int j)
    { return pq[i].compareTo(pq[j])>0; }
    private void exch(int i, int j)
    { Key t = pq[i]; pq[i] = pq[j]; pq[j] = t; }

compareTo()方法将在Key类的定义中定义，当它覆盖类似接口中的默认方法compareTo时。

现在，我明白可比较的是java.lang中的内置界面。在定义MaxPQ类时，使用的泛型类型是：

public class MaxPQ < Key extends Comparable < Key > >

由于Comparable是一个接口，并且Key扩展了该接口，这意味着key也必须是一个接口。

现在我不明白这是如何工作的。

有人可以向我解释，如果一个接口可以作为泛型类型，它会做什么好，以及为什么Key需要扩展Comparable<Key>。

如果你能给我一个例子来说明如何定义Key（使用Comparable接口），那将非常有用。

Answer 1

你缺少的是理解

<Key extends Comparable<Key>>

这并不意味着Key是接口......这意味着Key是Comparable的子类，可以这样对待。

Comparable<Key> c = new Key();

最后，如果Key实现了Comparable接口，或者扩展了Comparable类，则无关紧要，因为在这两种情况下它都可以充当Comparable - 并且具有Comparable具有的方法。

Answer 2

Key extends Comparable < Key >仅表示Key实现接口Comparable < Key >。而已。