Java泛型的定义和使用详解

一，为什么我们需要泛型

二，什么是泛型，泛型的定义

三，如何定义和使用泛型

四、限定类型变量

五、泛型中的约束和局限性

六、泛型类型的继承规则

七、通配符类型

八、虚拟机是如何实现泛型的？

一，为什么我们需要泛型

通过分析下面两种情况，来得出我们为什么需要泛型。

1.对两个数值类型求和的情况，如下代码，当两个数值是int类型时，需要实现一个方法对int类型的数值求和。当两个数值是Float类型时，需要实现一个方法对Float类型的数值求和。如果两个数值是Double类型时，还需要再实现一个方法对Double类型的数值求和。

 public int addInt(int x, int y) {return x+y;}public float addFloat(float x, float y) {return x+y;}

我们发现对两个数值求和时，都是一样的操作(加法运算)，但当两个数值的数据类型改变时，就需要重新实现一个新的求和方法。同样的一段代码，只是因为传入的参数不同，这里就必须要重写这个方法，这样会导致代码非常臃肿，也不灵活。

这种情况下我们能不能写出一段代码，代码的逻辑是一样的，根据传入的参数不同，自动进行运算。这就是泛型需要的地方之一。

适用多种数据类型，执行相同的代码，这是泛型的用处之一。

2.声明一个List集合，如下代码，不带任何的类型说明，向List里面添加一些元素，加入String和Integer对象，这时候编译不会报错。然后我们打印出List中的元素，运行的时候抛出一个异常"java.lang.Integer cannot be cast to java.lang.String"，Integer对象不能转换成一个String对象。

因为这里声明的List没有规定它的类型，此时List默认的类型是Object，Object是所有类的父类，所以把不同类型的数据添加到List中没有问题。但是从List中取数据的时候，取到的所有数据都是Object，所以在使用这些数据的时候就需要强制类型转换。如下代码中需要打印出String，就需要强制转换成String类型，但是由于List中还添加了Integer类型的数据，这时候强制类型转换就会报异常"ClassCastException"。

所以这里就需要使用到泛型，List集合定义了泛型之后，List集合中只能添加指定类型的数据，不然会编译不通过，在编译的时候就找到错误。而且从List集合中取数据的时候，不需要强制类型转换，可以直接用。

这就是使用泛型的好处，在编码的过程中，可以指定数据类型，不需要进行强制类型转换。以及如果我们插入错误的数据类型，在编译期间就能够发现，不至于在运行的时候才抛类转换异常。

 public static void main(String[] args) {// TODO Auto-generated method stubList list = new ArrayList();list.add("mark");list.add("OK");list.add(new Integer(100));for(int i = 0; i < list.size(); i++){String name = (String) list.get(i);System.out.println("name: " + name);}}

所以泛型的好处就是：

1，适用多种数据类型，执行相同的代码。

2，在编码的过程中，指定数据类型，不需要进行强制类型转换。以及如果我们插入错误的数据类型，在编译期间就能够发现，不至于在运行的时候才抛类转换异常。

二，什么是泛型，泛型的定义

泛型的定义：参数化类型

泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？

顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。

简单点说普通的方法定义，已经明确确定了需要传入的参数类型，调用方法的时候，只能改变传入的参数值，不能改变传入的参数类型，否则编译时会报错。

使用泛型定义方法，需要传入的参数类型和参数值都是没有明确确定的，调用方法的时候，由调用者确定传入的参数类型和参数值。

参数化类型，不同类型的参数可以由同一段代码处理。

泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。

三，如何定义和使用泛型

假如我们自己要定义泛型，如何去定义泛型呢？

泛型分为三种：泛型类、泛型接口、泛型方法。

泛型使用时引入一个类型变量，比较常用的有T，E，K，V等等，一般来讲就这么几种，都是约定俗成的。

泛型类

定义泛型类，在类名后面加尖括号T(也可以是其他的字符)，然后可以用T去定义变量和方法(方法返回值和参数。泛型类是允许有多个类型变量的。

实现和测试代码去下。

public class NormalGeneric<T> {private T data;public NormalGeneric(){}public NormalGeneric(T data){this.data = data;}public T getData(){return data;}public void setData(T data){this.data = data;}/*** @param args*/public static void main(String[] args) {// TODO Auto-generated method stubNormalGeneric<String> normalGeneric = new NormalGeneric<>();normalGeneric.setData("hello Generic");//normalGeneric.setData(12); //编译不通过报错，因为已经声明了泛型类的类型了System.out.println(normalGeneric.getData());}}

public class NormalGeneric2<T, K> {private T data;private K result;
}

泛型接口

除了泛型类，接口也可以定义泛型。泛型接口的定义和泛型类差不多。

定义泛型接口，在接口名后面加尖括号T，然后可以用T去定义抽象方法。

public interface Genertor<T> {public T next();
}

我们平时用接口的时候，都是用它的实现类。那么对于泛型接口来讲，要怎么去写它的实现类，

这里有两种方式。

第一种实现方式，使用泛型类实现泛型接口。

在实现泛型接口的时候，并不给泛型赋一个实际类型，这个类本身还是一个泛型类，在类名后面加尖括号T，这是一种实现泛型接口的方式。

泛型类实现泛型接口，它在使用上和其他普通的泛型类并没有什么区别。

public class ImplGenertor<T> implements Genertor<T> {@Overridepublic T next() {// TODO Auto-generated method stubreturn null;}}

第二种实现方式，在实现泛型接口的时候，直接规定泛型接口的类型。在泛型接口里面，T是一个参数化类型，实现泛型接口的时候，规定了参数化类型的类型。

public class ImplGenertor2 implements Genertor<String> {@Overridepublic String next() {// TODO Auto-generated method stubreturn null;}}

泛型方法

泛型方法和泛型类以及泛型接口都有所不同，泛型方法可以是完全独立的，没有要求泛型方法一定要声明在泛型类或泛型接口中，泛型方法可以声明在普通类和普通接口中。

如下代码中声明的泛型方法。方法的返回值变成参数化类型，在修饰符和返回值之间多了一个用尖括号括起来的类型，这样声明定义的方法就是泛型方法。尖括号括起来的类型变量是声明定义泛型方法必须要的，没有这个就不是泛型方法。

public class GenericMethod {public <T> T genericMethod(T...a){return a[a.length / 2];}public void test(int x, int y){System.out.println(x + y);}/*** @param args*/public static void main(String[] args) {// TODO Auto-generated method stubGenericMethod genericMethod = new GenericMethod();genericMethod.test(54, 864);System.out.println(genericMethod.<String>genericMethod("hello", "word", "2021"));System.out.println(genericMethod.genericMethod(11, 22, 33));}}

不管是泛型类还是泛型方法，都是允许定义多个泛型的。

那么泛型方法与泛型类或泛型接口有什么区别呢？

泛型类或泛型接口必须是在new创建对象实例的时候，告诉编译器类型变量的具体类型。而泛型方法是在调用的时候，告诉编译器当前这个泛型方法传入的具体参数类型是什么。

泛型方法是在调用方法的时候指明泛型的具体类型，可以在任何地方和任何场景中使用，包括普通类和泛型类，注意泛型类中定义的普通方法和泛型方法是有区别的。

下面代码讲述泛型方法的区别。

/*** 这是一个普通类*/
public class GenericMethod2{/*** 这个类是个泛型类* @param <T>*/public class Generic<T> {private T key;public Generic(){}public Generic(T key){this.key = key;}/*** 虽然在方法中使用了泛型，但是这并不是一个泛型方法。* 这只是泛型类中一个普通的成员方法，只不过他的返回值是在声明泛型类已经声明过的泛型。* 所以在这个方法中才可以继续使用 T 这个泛型。* * @return*/public T getKey(){return key;}/*** 编译报错* 这个方法显然是有问题的，在编译器会给我们提示这样的错误信息"E cannot be resolved to a type"* 因为在类的声明中并未声明泛型E，所以在使用E做形参和返回值类型时，编译器会无法识别。*/public E setKey(E key){this.key = key;}/*** 这才是一个真正的泛型方法。* 首先在public与返回值之间的<T>必不可少，这表明这是一个泛型方法，并且声明了一个泛型T* 这个T可以出现在这个泛型方法的任意位置.* 泛型的数量也可以为任意多个* @param container* @return*/public <E,K> K showKeyName(Generic<E> container){return null;}/*** 这也不是一个泛型方法，这就是一个普通的方法，* 只是使用了NormalGeneric<Number>这个泛型类做形参而已。* @param Obj*/public void show(Generic<Number> Obj){}}/*** 这个方法是有问题的，编译错误，编译器会为我们提示错误信息："E cannot be resolved to a type"* 虽然我们声明了<T>,也表明了这是一个可以处理泛型类型的泛型方法。* 但是只声明了泛型类型T，并未声明泛型类型E，因此编译器并不知道该如何处理E这个类型。* @param ab* @return*/public <T> T show(Generic<E> ab){}/*** 这个方法是有问题的，编译错误，编译器会为我们提示错误信息："T cannot be resolved to a type"* 对于编译器来说T这个类型并未在类或方法中声明过，因此编译也不知道该如何编译这个类。* 所以这也不是一个正确的泛型方法声明。* @param obj*/public void show(T obj){}
}

使用泛型的时候有几点需要注意的地方：

1.不是声明在泛型类里面的方法，就是泛型方法。

2.泛型方法声明在泛型类中，也要遵守泛型方法的定义规则。

下面代码泛型方法的用法和定义：

public class GenericMethod3 {static class Fruit{@Overridepublic String toString() {return "fruit";}}static class Apple extends Fruit{@Overridepublic String toString() {return "apple";}}static class Person{@Overridepublic String toString() {return "person";}}static class GenerateTest<T>{public void show_1(T t){System.out.println(t.toString());}/*** 在泛型类中声明了一个泛型方法，使用泛型E，这个泛型E可以为任意类型。* 类型可以与T相同，也可以不同。* 由于泛型方法在声明的时候会声明泛型<E>，因此即使在泛型类中并未声明该泛型，* 编译器也能够正确识别泛型方法中的泛型。* @param e*/public <E> void show_2(E e){System.out.println(e.toString());}/*** 在泛型类中声明了一个泛型方法，使用泛型T，* 注意这个T是一种全新的类型，可以与泛型类中声明的T不是同一种类型。* 泛型类和泛型方法中定义的泛型，它的作用域是不一样的。前者是在整个类中可以使用，后者只能在该方法中使用* @param t*/public <T> void show_3(T t){System.out.println(t.toString());}}/*** @param args*/public static void main(String[] args) {// TODO Auto-generated method stubApple apple = new Apple();Person person = new Person();GenerateTest<Fruit> generateTest = new GenerateTest<>();//不会报错，因为Apple是Fruit的子类。generateTest.show_1(apple); //编译报错，因为创建GenerateTest实例时，已经确定泛型的类型是FruitgenerateTest.show_1(person);generateTest.show_2(apple);generateTest.show_2(person);generateTest.show_3(apple);generateTest.show_3(person);}

四、限定类型变量

有时候，我们需要对类型变量加以约束，比如计算两个变量的最小或最大值。

public static <T> T min(T a, T b){if(a.compareTo(b) > 0) return a; else return b;}

如下代码，我们实现了一个泛型方法，然后调用compareTo方法比较传入的两个对象，但是编译报错"The method compareTo(T) is undefined for the type T"，泛型T找不到找不到方法compareTo。

那么确保传入的两个变量一定有compareTo方法呢？解决这个问题的方案就是将T限定为实现了接口Comparable的类。

 public static <T extends Comparable> T min(T a, T b){if(a.compareTo(b) > 0) return a; else return b;}

T extends Comparable中 extends(派生、继承)

T表示应该绑定类型的子类型，Comparable表示绑定类型，子类型和绑定类型可以是类也可以是接口。

同时extends左右都允许有多个，如 T,V extends Comparable & Serializable

注意限定类型中，只允许有一个类，而且如果有类，这个类必须是限定列表的第一个。因为在java中类是单继承，接口是多实现。

如果这个时候，我们试图传入一个没有实现接口Comparable的类的实例，将会发生编译错误。

/*** 类说明：类型变量的限定-用在方法上**/
public class ArrayAlg {/*** 编译报错，泛型T找不到找不到方法compareTo()方法，因为泛型T没有限定类型* @param a* @param b* @return*/
//  public static <T> T min(T a, T b){
//      if(a.compareTo(b) > 0) return a; else return b;
//  }/*** 取两个对象的最小值，类型变量限定为必须要实现了Comparable接口* @param a* @param b* @return*/public static <T extends Comparable> T min(T a, T b){if(a.compareTo(b) > 0) return b; else return a;}/*** 取两个对象的最大值，类型变量限定为必须要实现了Comparable接口* @param a* @param b* @return*/public static <T extends Comparable> T max(T a, T b){if(a.compareTo(b) > 0) return a; else return b;}static class Test{}/*** @param args*/public static void main(String[] args) {// TODO Auto-generated method stubSystem.out.println(ArrayAlg.min("hello", "world"));System.out.println(ArrayAlg.min(22, 12));//编译报错，因为Test类没有实现Compareble接口//ArrayAlg.min(new Test(), new Test());System.out.println(ArrayAlg.max(22, 12));}}

这种类型变量的限定既可以用在泛型方法上也可以用在泛型类上。使用方法都是一模一样的。下面是类型变量的限定，用在泛型类上面。

/*** 类说明：类型变量的限定-用在类上** @param <T>*/
public class ClassBorder<T extends Comparable> {private T data;public T min(T outter){if(this.data.compareTo(outter) > 0)return outter;elsereturn this.data;}public T getData(){return data;}public void setData(T data){this.data = data;}/*** @param args*/public static void main(String[] args) {// TODO Auto-generated method stubClassBorder<String> classBorder = new ClassBorder<>();classBorder.setData("Java");System.out.println(classBorder.min("Python"));}}

五、泛型中的约束和局限性

/*** 泛型类的原始类型，不会带上泛型的信息。** @param <T>*/
public class Restrict<T> {private T data;/*** 编译报错：Cannot instantiate the type T* 不能实例化类型变量，不能new类型变量。*/public Restrict(){this.data = new T();}//静态域或者静态方法里面，不能引用类型变量 //因为泛型类是在new创建对象实例的时候，告诉编译器类型变量的具体类型。//而虚拟机创建对象的代码执行先后顺序是static的部分，然后才是构造函数等等。private static T instance;//静态方法本身是泛型方法就行private static <T> T getInstance(){return null;}/*** @param args*/public static void main(String[] args) {// TODO Auto-generated method stub//不能用基本类型实例化类型参数,在Java中基本类型数据不是一个对象Restrict<double> restrictDouble1 = new Restrict<>();Restrict<Double> restrictDouble2 = new Restrict<>();//泛型不能用instanceof关键字判断类型if(restrictDouble2 instanceof Restrict<Double>){}if(restrictDouble2 instanceof Restrict<T>){}//运行时类型查询只适用于原始类型,不会带上泛型的类型变量Restrict<String> restrictStr = new Restrict<>();System.out.println(restrictDouble2.getClass() == restrictStr.getClass());System.out.println(restrictDouble2.getClass().getName());System.out.println(restrictStr.getClass().getName());//编译报错：Cannot create a generic array of Restrict<Double>//可以定义泛型数组，但是不能创建泛型数组（不能创建参数化类型的数组）Restrict<Double>[] restrictArray; //可以Restrict<Double>[] resticts = new Restrict<Double>[10]; //不可以，编译失败}

不能在静态域或方法中引用类型变量。因为泛型是要在对象创建的时候才知道是什么类型的，而虚拟机创建对象的代码执行先后顺序是static的部分，然后才是构造函数等等。所以在对象初始化之前static的部分已经执行了，如果你在静态部分引用的泛型，那么毫无疑问虚拟机根本不知道是什么东西，因为这个时候类还没有初始化。

/*** 类说明：泛型和异常*/
public class ExceptionRestrict {/*** 编译报错：* The generic class ExceptionRestrict.Problem<T> may not subclass java.lang.Throwable* 泛型类不能 extends Exception/Throwable*/private class Problem<T> extends Exception{}/*** 编译报错：Cannot use the type parameter T in a catch block* 不能捕获泛型类的实例*/public <T extends Throwable> void doWork1(T t){try{}catch(T e){//todo}}/*** 这种方式是可以的。不能捕获泛型类的实例，但还可以抛出泛型类的实例。* 泛型类也可以写在throws后面。* @param t* @throws T*/public <T extends Throwable> void doWork2(T t) throws T{try{}catch(Throwable e){throw t;}}/*** @param args*/public static void main(String[] args) {// TODO Auto-generated method stub}}

六、泛型类型的继承规则

如下代码展示泛型的继承原则：

public class Employee {private String firstName;private String secondName;public String getFirstName() {return firstName;}public void setFirstName(String firstName) {this.firstName = firstName;}public String getSecondName() {return secondName;}public void setSecondName(String secondName) {this.secondName = secondName;}
}

public class Worker extends Employee {
}

public class Pair<T> {private T one;private T two;public T getOne() {return one;}public void setOne(T one) {this.one = one;}public T getTwo() {return two;}public void setTwo(T two) {this.two = two;}private static <T> void set(Pair<Employee> p){}/*泛型类可以继承或者扩展其他泛型类，比如List和ArrayList*/private static class ExtendsPair<T> extends Pair<T>{}/*** @param args*/public static void main(String[] args) {// TODO Auto-generated method stub//Pair<Employee>和Pair<Worker>没有任何继承关系Pair<Employee> employeePair = new Pair<>();Pair<Worker> workerPair = new Pair<>();//子类给父类赋值，是可以的Employee employee = new Worker();//编译报错：Type mismatch: cannot convert from Pair<Worker> to Pair<Employee>//这就说明Pair<Employee>和Pair<Worker>没有任何继承关系Pair<Employee> employeePair2 = new Pair<Worker>();//这种方式是可以的Pair<Employee> pari = new ExtendsPair<>();//可以set(employeePair);//编译报错：The method set(Pair<Employee>) in the type Pair<T> is not applicable for the arguments (Pair<Worker>)//Pair<Employee>和Pair<Worker>没有任何继承关系set(workerPair); //可以的set(pari);}
}

泛型

1.泛型的类型变量之间，不考虑任务继承关系。类型之间的继承关系，不代表泛型的参数化类型之间有继承关系。

2.泛型类可以继承或者扩展其他泛型类，比如List和ArrayList。

七、通配符类型

我们先定义一些有继承关系的类和一个泛型类

public class Fruit {private String color;public String getColor() {return color;}public void setColor(String color) {this.color = color;}
}

public class Food {}

public class Apple extends Fruit {}

public class Orange extends Fruit {}

public class HongFuShi extends Apple {}

public class GenericType<T> {private T data;public T getData() {return data;}public void setData(T data) {this.data = data;}
}

正是因为前面所述的，GenericType<Fruit>和GenericType<Orange>没有任何继承关系，现在我们有一个方法如下：

 public static void print(GenericType<Fruit> p){System.out.println(p.getData().getColor());}

在调用这个方法的时候，会出现如下的问题：

 public static void use(){GenericType<Fruit> a = new GenericType<>();print(a);GenericType<Orange> b = new GenericType<>();//编译报错：The method print(GenericType<Fruit>) in the type WildChar is not applicable for the arguments (GenericType<Orange>)//类型之间的继承关系，不代表泛型的参数化类型之间有继承关系。//GenericType<Fruit>和GenericType<Orange>没有任何继承关系。print(b);}

因为GenericType<Fruit>和GenericType<Orange>没有任何继承关系，所以调用print(GenericType<Fruit> p)方法时，传入GenericType<Orange>实例对象就会编译报错。这样的程序看起来非常不灵活，Orange和Fruit是继承关系，但泛型变量可以是Fruit，不能是Orang。

为解决这个问题，于是提出了一个通配符类型 ?

有两种使用方式：

？ extends X 表示类型的上界，类型参数是X的子类

？ super X 表示类型的下界，类型参数是X的超类

这两种方式从名字上来看，特别是super，很有迷惑性，下面我们来仔细辨析这两种方法。

通配符类型和限定类型变量的区别：

1.限定类型变量是在定义泛型类和泛型方法时，限定类型变量的类型。

2.通配符类型一般用在方法的参数上面。扩展支持的泛型类实例的类型变量。

？ extends X

表示传递给方法的泛型类实例的类型变量，必须是X的子类（包括X本身）

但是对泛型类GenericType来说，如果其中提供了get和set类型参数变量的方法的话，set方法是不允许被调用的，会出现编译错误。

get方法则没问题，会返回一个Fruit类型的值。

 public static void print2(GenericType<? extends Fruit> p){System.out.println(p.getData().getColor());}private static void use2(){GenericType<Fruit> a = new GenericType<>();print2(a);GenericType<Orange> b = new GenericType<>();//这样是可以的print2(b);//编译报错：The method print2(GenericType<? extends Fruit>) in the type WildChar is not applicable for the arguments (GenericType<Food>)//因为Food是Fruit的父类，而这里的泛型类型变量只能是Fruit的子类或本身。print2(new GenericType<Food>());//这样赋值是可以的GenericType<? extends Fruit> c = b;Apple apple = new Apple();Fruit fruit = new Fruit();//这个样是可以的，因为new创建泛型类对象的时候，确定了类型变量为Fruita.setData(fruit);//编译报错：The method setData(capture#2-of ? extends Fruit) in the type GenericType<capture#2-of ? extends Fruit> is not applicable for the arguments (Apple)c.setData(apple);c.setData(fruit);//这个样是可以的Fruit f = c.getData();//编译报错：Type mismatch: cannot convert from capture#5-of ? extends Fruit to Orange//类型转换异常，这时候编译器只知道c.getData()返回的是一个Fruit类实例。Orange o = c.getData();}

那么为什么会这样呢？

道理很简单，？ extends X 表示类型的上界，类型参数是X的子类，那么可以肯定的说，get方法返回的一定是个X（不管是X或者X的子类）编译器是可以确定知道的。但是set方法只知道传入的是个X，至于具体是X的那个子类，不知道。

总结：主要用于安全地访问数据，可以访问X及其子类型，并且不能写入非null的数据。

？ super X

表示传递给方法的泛型类实例的类型变量，必须是X的超类（包括X本身）

 public static void printSuper(GenericType<? super Apple> p){System.out.println(p.getData());}public static void useSuper(){GenericType<Fruit> fruitGeneticType = new GenericType<>();GenericType<Apple> appleGeneticType = new GenericType<>();GenericType<HongFuShi> hongfushiGeneticType = new GenericType<>();GenericType<Orange> orangeGeneticType = new GenericType<>();printSuper(fruitGeneticType);printSuper(appleGeneticType);//编译报错：The method printSuper(GenericType<? super Apple>) in the type WildChar is not applicable for the arguments (GenericType<HongFuShi>)printSuper(hongfushiGeneticType);//编译报错printSuper(orangeGeneticType);//表示GenericType的类型参数的下界是AppleGenericType<? super Apple> x = new GenericType<>();x.setData(new Apple());x.setData(new HongFuShi());//这样是不行的，编译报错。x.setData(new Fruit());//唯一可行的赋值Object data = x.getData();}

但是对泛型类GenericType来说，如果其中提供了get和set类型参数变量的方法的话，set方法可以被调用的，且能传入的参数只能是X或者X的子类。

get方法只会返回一个Object类型的值。

那么为什么会这样呢？

？ super X 表示类型的下界，类型参数是X的超类（包括X本身），那么可以肯定的说，get方法返回的一定是个X的超类，那么到底是哪个超类？不知道，但是可以肯定的说，Object一定是它的超类，所以get方法返回Object。编译器是可以确定知道的。对于set方法来说，编译器不知道它需要的确切类型，但是X和X的子类可以安全的转型为X，而X的超类不能安全的转型为X。

总结：主要用于安全地写入数据，可以写入X及其子类型。

无限定的通配符 ?

表示对类型没有什么限制，可以把？看成所有类型的父类，如Pair< ?>；

比如：

ArrayList<T> al=new ArrayList<T>(); 指定集合元素只能是T类型

ArrayList<?> al=new ArrayList<?>();集合元素可以是任意类型，这种没有意义，一般是方法中，只是为了说明用法。

在使用上：

? getFirst() ：返回值只能赋给 Object；

void setFirst(?) ： setFirst 方法不能被调用，甚至不能用 Object 调用；

八、虚拟机是如何实现泛型的？

泛型思想早在C++语言的模板（Template）中就开始生根发芽，在Java语言处于还没有出现泛型的版本时，只能通过Object是所有类型的父类和类型强制转换两个特点的配合来实现类型泛化。由于Java语言里面所有的类型都继承于java.lang.Object，所以Object转型成任何对象都是有可能的。但是也因为有无限的可能性，就只有程序员和运行期的虚拟机才知道这个Object到底是个什么类型的对象。在编译期间，编译器无法检查这个Object的强制转型是否成功，如果仅仅依赖程序员去保障这项操作的正确性，许多ClassCastException的风险就会转嫁到程序运行期之中。

泛型技术在C#和Java之中的使用方式看似相同，但实现上却有着根本性的分歧，C#里面泛型无论在程序源码中、编译后的IL中（Intermediate Language，中间语言，这时候泛型是一个占位符），或是运行期的CLR中，都是切实存在的，List＜int＞与List＜String＞就是两个不同的类型，它们在系统运行期生成，有自己的虚方法表和类型数据，这种实现称为类型膨胀，基于这种方法实现的泛型称为真实泛型。

Java语言中的泛型则不一样，它只在程序源码中存在，在编译后的字节码文件中，就已经替换为原来的原生类型（Raw Type，也称为裸类型）了，并且在相应的地方插入了强制转型代码，因此，对于运行期的Java语言来说，ArrayList＜int＞与ArrayList＜String＞就是同一个类，所以泛型技术实际上是Java语言的一颗语法糖，Java语言中的泛型实现方法称为类型擦除，基于这种方法实现的泛型称为伪泛型。

将一段Java代码编译成Class文件，然后再用字节码反编译工具进行反编译后，将会发现泛型都不见了，程序又变回了Java泛型出现之前的写法，泛型类型都变回了原生类型

 public static String method(List<String> stringList){System.out.println("String List");return "String";}public static String method(List<Integer> integerList){System.out.println("Integer List");return Integer;}

上面这段代码是不能被编译的，因为参数List＜Integer＞和List＜String＞编译之后都被擦除了，变成了一样的原生类型List＜E＞，擦除动作导致这两种方法的特征签名变得一模一样。

（方法重载时两个方法方法名和参数都相同，返回值类型不同是，jdk的编译器不会报错，但是一般IDE的编译器会报错）。

由于Java泛型的引入，各种场景（虚拟机解析、反射等）下的方法调用都可能对原有的基础产生影响和新的需求，如在泛型类中如何获取传入的参数化类型等。因此，JCP组织对虚拟机规范做出了相应的修改，引入了诸如Signature、LocalVariableTypeTable等新的属性用于解决伴随泛型而来的参数类型的识别问题，Signature是其中最重要的一项属性，它的作用就是存储一个方法在字节码层面的特征签名[3]，这个属性中保存的参数类型并不是原生类型，而是包括了参数化类型的信息。修改后的虚拟机规范要求所有能识别49.0以上版本的Class文件的虚拟机都要能正确地识别Signature参数。

另外，从Signature属性的出现我们还可以得出结论，擦除法所谓的擦除，仅仅是对方法的Code属性中的字节码进行擦除，实际上元数据中还是保留了泛型信息，这也是我们能通过反射手段取得参数化类型的根本依据。