Java <；E扩展数字>；及<；数量>；？

此方法声明之间的区别是什么：

public static <E extends Number> List<E> process(List<E> nums){

公共静态列表过程（List nums）{

及

公共静态列表过程（List nums）{

---

您将在哪里使用前者？

第一个允许

处理
列表、
列表等，而第二个不允许

Java中的泛型是不变的，它们不像数组那样是协变的

也就是说，在Java中，
Double[]
是
Number[]
的子类型，但是
List
不是
List
的子类型。但是
List
是
List后一种方法（没有
的方法）将只接受类型正好为
List
的参数，并且将始终接受该参数
返回
列表
。例如，它将不接受
列表

前一种方法（带有
的方法）是，这意味着它可以接受不同类型的
列表
它将返回相同类型的
列表
，只要
列表
是
扩展
编号
，例如
列表

例如：

import java.util.ArrayList;
import java.util.List;

public class ProcessGenerics {

    List<Number>  listNumber  = new ArrayList<Number>();
    List<Integer> listInteger = new ArrayList<Integer>();
    List<Double>  listDouble  = new ArrayList<Double>();


    public static
        List<Number> processWithoutExtends(List<Number> nums){ return nums; }

    List<Number>  resultN = processWithoutExtends(listNumber);  // OK
  //List<Integer> resultI = processWithoutExtends(listInteger); // compile-error - method not applicable
  //List<Double>  resultD = processWithoutExtends(listDouble);  // compile-error - method not applicable


    public static <E extends Number>
        List<E> processWithExtends(List<E> nums){ return nums; }

    List<Number>  resultN2 = processWithExtends(listNumber);  // OK
    List<Integer> resultI2 = processWithExtends(listInteger); // OK
    List<Double>  resultD2 = processWithExtends(listDouble);  // OK

}

import java.util.ArrayList；
导入java.util.List；
公共类进程泛型{
List listNumber=新的ArrayList（）；
List listInteger=新的ArrayList（）；
List listDouble=新的ArrayList（）；
公共静电
List processWithoutExtends（List nums）{return nums；}
List resultN=processWithoutExtends（listNumber）；//确定
//List resultI=processWithoutExtends（listInteger）；//编译错误-方法不适用
//List resultD=processWithoutExtends（listDouble）；//编译错误-方法不适用
公共静电
List processWithExtends（List nums）{return nums；}
List resultN2=processWithExtends（listNumber）；//确定
列表结果2=processWithExtends（listInteger）；//确定
List resultD2=processWithExtends（listDouble）；//确定
}

请参阅Java教程中泛型课程的通配符一章中的类似解释：


另请看，这两个问题实际上都是关于泛型和子类型的，例如
List
是否是
List
的子类型（它不是！！！）。
我认为如果我们有这样一种方法，最好也解释一下区别：
e过程（e elt）
vs
Number过程（Number elt）
import java.util.ArrayList;
import java.util.List;

public class ProcessGenerics {

    List<Number>  listNumber  = new ArrayList<Number>();
    List<Integer> listInteger = new ArrayList<Integer>();
    List<Double>  listDouble  = new ArrayList<Double>();


    public static
        List<Number> processWithoutExtends(List<Number> nums){ return nums; }

    List<Number>  resultN = processWithoutExtends(listNumber);  // OK
  //List<Integer> resultI = processWithoutExtends(listInteger); // compile-error - method not applicable
  //List<Double>  resultD = processWithoutExtends(listDouble);  // compile-error - method not applicable


    public static <E extends Number>
        List<E> processWithExtends(List<E> nums){ return nums; }

    List<Number>  resultN2 = processWithExtends(listNumber);  // OK
    List<Integer> resultI2 = processWithExtends(listInteger); // OK
    List<Double>  resultD2 = processWithExtends(listDouble);  // OK

}