在观察Java源码的时候，发现了这么一个写法T extends Comparable super T>。不禁纳闷为什么要这么写呢？有什么好处吗，extends和super在这里的作用着实让人有点不清楚。

接下来，我将结合代码跟大家分享一下我关于这里泛型应用的看法。

1.>代表什么意思

大家可以明白的是这里应用到了Java的泛型，那么首先向大家说明一下这里extends的作用

extends后面跟的类型，如表示泛型的上限。示例代码如下：

import java.util.*;class Demo{}public classTest

{public static voidmain(String[] args) {

Demo p = null; //编译正确//这里因为ArrayList是List的子类所以通过//如果改为Demo p = null;就会报错这样就限制了上限

}

}

在理解了extends所表示的泛型的上限后，接下来介绍一下super的作用，它与extends相反，表示的是泛型的下限。

所以结合上述两点，我们来分析一下这句话整体代表什么意思。首先，extends对泛型上限进行了限制即T必须是Comparable super T>的子类，然后 super T>表示Comparable<>中的类型下限为T！

2.  > 和 > 有什么不同

接下来我们通过对比，使得大家对为何要这样编写代码有更加深刻的印象。

>

它代表的意思是：类型T必须实现Comparable接口，并且这个接口的类型是T。这样，T的实例之间才能相互比较大小。这边我们以Java中GregorianCalendar这个类为例。

代码如下所示：

importjava.util.GregorianCalendar;class Demo>{}//注意这里是没有? super的

public classTest

{public static voidmain(String[] args) {

Demo p = null;

}

}

这里编译报错，因为这里的>相当于>,但是GregorianCalendar中并没有实现Comparable，而是仅仅持有从Calendar继承过来的Comparable，这样就会因为不在限制范围内而报错。

>

它代表的意思是：类型T必须实现Comparable接口，并且这个接口的类型是T或者是T的任一父类。这样声明后，T的实例之间和T的父类的实例之间可以相互比较大小。同样还是以GregorianCalendar为例。代码如下所示：

importjava.util.GregorianCalendar;class Demo>{}public classTest1

{public static voidmain(String[] args) {

Demo p = null; //编译正确

}

}

此时编译通过，这里可以理解为>！因为Calendar为GregorianCalendar 的父类并且GregorianCalendar 实现了Comparable,具体可以在API中进行查看！

3.　实例代码演示

代码如下所示：

importjava.util.ArrayList;importjava.util.Collections;importjava.util.List;public classTest

{//第一种声明：简单，灵活性低

public static > void mySort1(Listlist)

{

Collections.sort(list);

}//第二种声明：复杂，灵活性高

public static > void mySort2(Listl)

{

Collections.sort(list);

}public static voidmain(String[] args)

{//主函数中将分别创建Animal和Dog两个序列，然后调用排序方法对其进行测试

//main函数中具体的两个版本代码将在下面具体展示

}

}class Animal implements Comparable{protected intage;public Animal(intage)

{this.age =age;

}//使用年龄与另一实例比较大小

@Overridepublic intcompareTo(Animal other)

{return this.age -other.age;

}

}class Dog extendsAnimal

{public Dog(intage)

{super(age);

}

}

上面的代码包括三个类：

Animal实现了Comparable接口，通过年龄来比较实例的大小

Dog从Animal继承，为其子类。

Test类中提供了两个排序方法和测试用的main()方法：

mySort1()使用>类型参数

mySort2()使用>类型参数

main()测试方法。在这里将分别创建Animal和Dog两个序列，然后调用排序方法对其进行测试。

3.1　对mySort1()进行测试，main方法代码如下所示：

//创建一个 Animal List

List animals = new ArrayList();

animals.add(new Animal(25));

animals.add(new Dog(35));//创建一个 Dog List

List dogs = new ArrayList();

dogs.add(new Dog(5));

dogs.add(new Dog(18));//测试 mySort1() 方法

mySort1(animals);

mySort1(dogs);

结果编译出错，报错信息为：

The method mySort1(List) in the type TypeParameterTest is not applicable for the arguments (List)

mySort1() 方法的类型参数是>，它要求的类型参数是类型为T的Comparable。

如果传入的是List程序将正常执行，因为Animal实现了接口Comparable。

但是，如果传入的参数是List程序将报错，因为Dog类中没有实现接口Comparable，它只从Animal继承了一个Comparable接口。

注意：animals list中实际上是包含一个Dog实例的。如果碰上类似的情况(子类list不能传入到一个方法中)，可以考虑把子类实例放到一个父类 list 中，避免编译错误。

3.2　对mySort12()进行测试，main方法代码如下所示：

public static voidmain(String[] args)

{//创建一个 Animal List

List animals = new ArrayList();

animals.add(new Animal(25));

animals.add(new Dog(35));//创建一个 Dog List

List dogs = new ArrayList();

dogs.add(new Dog(5));

dogs.add(new Dog(18));//测试 mySort2() 方法

mySort2(animals);

mySort2(dogs);

}

这时候我们发现该程序可以正常运行。它不但能够接受Animal implements Comparable这样的参数，也可以接收：Dog implements Comparable这样的参数。

3.3　是否可以通过将Dog实现Comparable来解决问题？

由分析可得程序出现问题是因为Dog类没有实现接口Comparable，那么我们能否将该类实现接口Comparable来解决问题呢？

代码如下所示：

class Dog extends Animal implements Comparable{public Dog(intage)

{super(age);

}

}

结果程序编译报错，错误信息如下所示：

The interface Comparable cannot be implemented more than once with different arguments: Comparable and Comparable

意义是Dog类已经从Animal中继承了Comparable该接口，无法再实现一个Comparable。

若子类需要使用自己的比较方法，则需要重写父类的public int CompareTo(Animal other)方法。

4. 总结

对Animal/Dog这两个有父子关系的类来说：>可以接受List，也可以接收 List 。而>只可以接收 List所以，>这样的类型参数对所传入的参数限制更少，提高了 API 的灵活性。总的来说，在保证类型安全的前提下，要使用限制最少的类型参数。