Java泛型<? extends T>和<? super T>

Posted 2023-02-15

谁能否详细给我讲明
Java泛型<? extends T>和<? super T>的应用场景，作用等等

2分党就免了，谢过

泛型中<? extends T>和<? super T> 差别
<? extends T>和<? super T>含有JAVA5.0的新的概念。由于它们的外表导致了很多人误解了它们的用途：
1.<?
extends T>首先你很容易误解它为继承于T的所有类的集合，这是大错特错的，相信能看下去你一定见过或用过List<?
extends T>吧？为什么我说理解成一个集合是错呢？如果理解成一个集合那为什么不用List<T>来表示？所以<?
extends
T>不是一个集合，而是T的某一种子类的意思，记住是一种，单一的一种，问题来了，由于连哪一种都不确定，带来了不确定性，所以是不可能通过
add（）来加入元素。你或许还觉得为什么add(T)不行?因为<? extends
T>是T的某种子类，能放入子类的容器不一定放入超类，也就是没可能放入T。
2.<? super T>这里比较容易使用，没<? extends T>这么多限制，这里的意思是，以T类为下限的某种类，简单地说就是T类的超类。但为什么add(T)可以呢？因为能放入某一类的容器一定可以放入其子类，多态的概念。
擦除
也
许泛型最具挑战性的方面是擦除（erasure），这是 Java
语言中泛型实现的底层技术。擦除意味着编译器在生成类文件时基本上会抛开参数化类的大量类型信息。编译器用它的强制类型转换生成代码，就像程序员在泛型出
现之前手工所做的一样。区别在于，编译器开始已经验证了大量如果没有泛型就不会验证的类型安全约束。
通过擦除实现泛型的含意是很重要的，并
且初看也是混乱的。尽管不能将List<Integer> 赋给List<Number>，因为它们是不同的类型，但是
List<Integer> 和 List<Number> 类型的变量是相同的类！要明白这一点，请评价下面的代码：
new List<Number>().getClass() == new List<Integer>().getClass()
编译器只为 List 生成一个类。当生成了 List 的字节码时，将很少剩下其类型参数的的跟踪。
当
生成泛型类的字节码时，编译器用类型参数的擦除替换类型参数。对于无限制类型参数（<V>），它的擦除是
Object。对于上限类型参数（<K extends Comparable<K>>），它的擦除是其上限（在本例中是
Comparable）的擦除。对于具有多个限制的类型参数，使用其最左限制的擦除。
如果检查生成的字节码，您无法说出 List<Integer> 和 List<String> 的代码之间的区别。类型限制 T 在字节码中被 T 的上限所取代，该上限一般是 Object。

多重限制
一个类型参数可以具有多个限制。当您想要约束一个类型参数比如说同时为 Comparable 和 Serializable 时，这将很有用。多重限制的语法是用“与”符号分隔限制：
class C<T extends Comparable<? super T>&Serializable>
通配符类型可以具有单个限制 —— 上限或者下限。一个指定的类型参数可以具有一个或多个上限。具有多重限制的类型参数可以用于访问它的每个限制的方法和域。
类型形参和类型实参
在
参数化类的定义中，占位符名称（比如 Collection<V> 中的 V）叫做类型形参（type
parameter），它们类似于方法定义中的形式参数。在参数化类的变量的声明中，声明中指定的类型值叫做类型实参（type
argument），它们类似于方法调用中的实际参数。但是实际中二者一般都通称为“类型参数”。所以给出定义：
interface Collection<V> ...
和声明：
Collection<String> cs = new HashSet<String>();
那么，名称 V（它可用于整个 Collection 接口体内）叫做一个类型形参。在 cs 的声明中，String 的两次使用都是类型实参（一次用于 Collection<V>，另一次用于 HashSet<V>）。
关
于何时可以使用类型形参，存在一些限制。大多数时候，可以在能够使用实际类型定义的任何地方使用类型形参。但是有例外情况。不能使用它们创建对象或数组，
并且不能将它们用于静态上下文中或者处理异常的上下文中。还不能将它们用作父类型（class Foo<T> extends
T），不能用于 instanceof 表达式中，不能用作类常量。
类似地，关于可以使用哪些类型作为类型实参，也存在一些限制。类型实参
必须是引用类型（不是基本类型）、通配符、类型参数，或者其他参数化类型的实例化。所以您可以定义
List<String>（引用类型）、List<?>（通配符）或者
List<List<?>>（其他参数化类型的实例化）。在带有类型形参 T 的参数化类型的定义中，您也可以声明
List<T>（类型形参）。 参考技术A 就效果来说和直接<T>其实效果一样，因为java有多态自带子类转父类的强制转换，- -不过那样会有一个强制转换的过程。其实用泛型通配符就是存储的时候起到约束和提高性能的作用。平时除了bat大厂代码和java源码基本看不到这玩意。

Java泛型的应用——T extends Comparable<? super T;

[转载]Java泛型的应用——T extends Comparable<? super T>

	</h1>
	<div class="clear"></div>
	<div class="postBody">
		<div  class="">

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

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

　　

　　1.  <T extends Comparable<? super T>>代表什么意思

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

　　extends后面跟的类型，如<任意字符 extends 类/接口>表示泛型的上限。示例代码如下：

import java.util.*;
class Demo<T extends List>{}
public class Test
{
    public static void main(String[] args) {
    Demo<ArrayList> p = null; // 编译正确
//这里因为ArrayList是List的子类所以通过
//如果改为Demo<Collection> p = null;就会报错这样就限制了上限
    }
}

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

　

　　2.  <T extends Comparable<T>> 和 <T extends Comparable<? super T>> 有什么不同

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

• <T extends Comparable<T>>

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

　　代码如下所示：

import java.util.GregorianCalendar;
class Demo<T extends Comparable<T>>{}
//注意这里是没有? super的
public class Test
{
    public static void main(String[] args) {
       Demo<GregorianCalendar> p = null; 
        }
}

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

• <T extends Comparable<? super T>>　　

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

import java.util.GregorianCalendar;
class Demo<T extends Comparable<? super T>>{}
public class Test1

{

public static void main(String[] args) {

Demo<GregorianCalendar> p = null; // 编译正确

    }

}　　

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

 

　　3.　实例代码演示

　　代码如下所示：

 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
public class Test

{

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

public static <T extends Comparable<T>> void mySort1(List<T> list)

{

Collections.sort(list);

}
 </span><span style="color: rgba(0, 128, 0, 1)">//</span><span style="color: rgba(0, 128, 0, 1)">第二种声明：复杂，灵活性高</span>
 <span style="color: rgba(0, 0, 255, 1)">public</span> <span style="color: rgba(0, 0, 255, 1)">static</span> &lt;T <span style="color: rgba(0, 0, 255, 1)">extends</span> Comparable&lt;? <span style="color: rgba(0, 0, 255, 1)">super</span> T&gt;&gt; <span style="color: rgba(0, 0, 255, 1)">void</span> mySort2(List&lt;T&gt;<span style="color: rgba(0, 0, 0, 1)"> l)
 {
     Collections.sort(list);
 }

 </span><span style="color: rgba(0, 0, 255, 1)">public</span> <span style="color: rgba(0, 0, 255, 1)">static</span> <span style="color: rgba(0, 0, 255, 1)">void</span><span style="color: rgba(0, 0, 0, 1)"> main(String[] args)
 {
     </span><span style="color: rgba(0, 128, 0, 1)">//</span><span style="color: rgba(0, 128, 0, 1)">主函数中将分别创建Animal和Dog两个序列，然后调用排序方法对其进行测试<br>　　　　　//main函数中具体的两个版本代码将在下面具体展示<br></span>

     }

}
class Animal implements Comparable<Animal>

{

protected int age;
 </span><span style="color: rgba(0, 0, 255, 1)">public</span> Animal(<span style="color: rgba(0, 0, 255, 1)">int</span><span style="color: rgba(0, 0, 0, 1)"> age)

 {
     </span><span style="color: rgba(0, 0, 255, 1)">this</span>.age =<span style="color: rgba(0, 0, 0, 1)"> age;
 }

 </span><span style="color: rgba(0, 128, 0, 1)">//</span><span style="color: rgba(0, 128, 0, 1)">使用年龄与另一实例比较大小</span>

     @Override

public int compareTo(Animal other)

{

return this.age - other.age;

}

}
class Dog extends Animal

{

public Dog(int age)

{

super(age);

}

}

上面的代码包括三个类：

1. Animal实现了Comparable<Animal>接口，通过年龄来比较实例的大小
2. Dog从Animal继承，为其子类。
3. Test类中提供了两个排序方法和测试用的main()方法：
   • mySort1()使用<T extends Comparable<T>>类型参数
   • mySort2()使用<T extends Comparable<? super T>>类型参数
   • main()测试方法。在这里将分别创建Animal和Dog两个序列，然后调用排序方法对其进行测试。

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

// 创建一个 Animal List
List<Animal> animals = new ArrayList<Animal>();
animals.add(new Animal(25));
animals.add(new Dog(35));
// 创建一个 Dog List

List<Dog> dogs = new ArrayList<Dog>();

dogs.add(new Dog(5));

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

mySort1(animals);

mySort1(dogs);

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

The method mySort1(List<T>) in the type TypeParameterTest is not applicable for the arguments (List<Dog>)

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

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

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

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

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

public static void main(String[] args)
{
    // 创建一个 Animal List
    List<Animal> animals = new ArrayList<Animal>();
    animals.add(new Animal(25));
    animals.add(new Dog(35));
</span><span style="color: rgba(0, 128, 0, 1)">//</span><span style="color: rgba(0, 128, 0, 1)"> 创建一个 Dog List</span>
List&lt;Dog&gt; dogs = <span style="color: rgba(0, 0, 255, 1)">new</span> ArrayList&lt;Dog&gt;<span style="color: rgba(0, 0, 0, 1)">();
dogs.add(</span><span style="color: rgba(0, 0, 255, 1)">new</span> Dog(5<span style="color: rgba(0, 0, 0, 1)">));
dogs.add(</span><span style="color: rgba(0, 0, 255, 1)">new</span> Dog(18<span style="color: rgba(0, 0, 0, 1)">));

</span><span style="color: rgba(0, 128, 0, 1)">//</span><span style="color: rgba(0, 128, 0, 1)"> 测试  mySort2() 方法</span>

    mySort2(animals);

mySort2(dogs);

}

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

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

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

　　代码如下所示：

class Dog extends Animal implements Comparable<Dog>
{
    public Dog(int age)
    {
        super(age);
    }
}

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

The interface Comparable cannot be implemented more than once with different arguments: Comparable<Animal> and Comparable<Dog>

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

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

 

　　4. 总结　

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