Question

我有以下界面：

public interface ISort<T extends Comparable<T>> {
    public void sort(T[] array);
}

我对此的理解是<T extends Comparable<T>>告诉编译器在这个类中，可能有一些泛型类型T，它们必须是Comparable<T>或者是任何类实现Comparable<T>。

然后我有以下课程：

public class Sort<T extends Comparable<T>> implements ISort<T> {

    public void swap(T[] array, int i, int j) {
        T temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

    public void sort(T[] array) {
        java.util.Arrays.sort(array);
    }

}

同样，我让<T extends Comparable<T>>告诉编译器在这个类中我将使用类型T，它必须与Comparable<T>形成IS-A关系。但是，为什么我只能输入implements ISort<T>，为什么我不需要写implements ISort<T extends Comparable<T>>？为了帮助我理解这一点，你能解释一下这些泛型语句究竟推断出编译器吗？

Answer 1

在类中指定T并在extends或implements子句中使用T之间存在差异。

使用类指定T时，您声明类型参数T，但在extends或implements子句中，您使用已声明的类型参数。

public class Sort<T extends Comparable<T>>  // Declare T to be Comparable<T>
    implements ISort<T>                     // Use T

在extends或implements子句中使用type参数与在类的主体中使用type参数没什么不同。

Answer 2

泛型类型用法的语法是SomeType<SomeTypeArgument>。

在你的情况下

class Sort<T extends Comparable<T>> implements ISort<T> {
        // ^ declares new type parameter             ^ uses it as a type argument 
        //

声明一个新类型参数T，其边界与T中声明的类型参数ISort中的期望相匹配。因此，您可以使用Sort#T作为ISort的类型参数。

这与

类似

class Sort implements ISort<Integer> {

唯一的区别是您没有声明类型参数，而是使用现有类型。

Answer 3

在类声明中，引入一个带有上限的类型参数。当您使用T[]作为sort方法的第一个参数的类型时，您不是声明任何内容（声明发生在文件的开头）：您是仅使用类型变量。请注意不同的措辞：

在文件的开头，您声明了一个类型参数
在排序的签名中，我们使用类型变量

类型参数的界限仅在声明站点允许，声明可以在三个地方发生：

班级宣言
构造函数定义
方法定义

这里有一个快速表：

// class
public static class Foo<T> {
    // constructor
    public <A> Foo() {}
    // method
    public <B> void doSomething() {}
    // Not really allowed
    // public void doSomethingElse(List<T extends Number> bar) {}
    // here we have a wildcard, so you can do this
    public void doSomethingElse(List<? super T> bar) {}
}

Java Generics - 在实现接口的类上指定上限，该接口本身指定上限

3 个答案: