浅析Java泛型

什么是泛型？

泛型是JDK 1.5的一项新特性，它的本质是参数化类型（Parameterized Type）的应用，也就是说所操作的数据类型被指定为一个参数，在用到的时候在指定具体的类型。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口和泛型方法。

基本术语介绍

以ArrayList<E>和ArrayList<Integer>为例
整个ArrayList<E>称为泛型类型
ArrayList<E>中的E称为类型变量或者类型形参
整个ArrayList<Integer>称为参数化的类型
ArrayList<Integer>中的Integer称为类型参数的实例或者类型实参
ArrayList<Integer>中的<Integer>念为typeof Integer
ArrayList称为原始类型

为什么使用泛型？

泛型使类型（类和接口）在定义类、接口和方法时成为参数，好处在于：

• 强化类型安全，由于泛型在编译期进行类型检查，从而保证类型安全，减少运行期的类型转换异常。
• 提高代码复用，泛型能减少重复逻辑，编写更简洁的代码。
• 类型依赖关系更加明确，接口定义更加优好，增强了代码和文档的易读性。

一个简单的例子

public class Test1 {
    public static void main(String[] args) {
    	List list = new ArrayList();
    	list.add("kiwen1");
    	list.add("kiwen2");
    	list.add(123);

    	for (int i = 0; i < list.size(); i++) {
    	    String name = (String) list.get(i); 
    	    System.out.println("name:" + name);
    	}
    	
    }
}
//输出结果
name:kiwen1
name:kiwen2
Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
	at DateTest.Test1.main(Test.java:17)

从上面例子可以看出，定义了一个List类型的集合，向其中加入了两个字符串类型的值和 一个Integer类型的值。此时list默认的类型为Object类型。但这里有两个问题，在循环中，一是当获取一个值时必须进行强制类型转换，二是没有错误检查。由于定义了name为String类型，运行时将Integer转成String会产生错误。即编译阶段正常，而运行时会出现“java.lang.ClassCastException”异常。因此，导致此类错误编码过程中不易被发现。

public class Test2 {
    public static void main(String[] args) {
    	List<String> list = new ArrayList<String>();
    	list.add("kiwen1");
    	list.add("kiwen2");
    	//list.add(123);   //提示编译错误

    	for (int i = 0; i < list.size(); i++) {
    	    String name = list.get(i);
    	    System.out.println("name:" + name);
    	}
    }
}
//输出结果
name:kiwen1
name:kiwen2

该段代码采用泛型写法后，向list加入一个Integer类型的对象时会出现编译错误，通过List<String>，直接限定了list集合中只能含有String类型的元素，从而在输出时处无须进行强制类型转换。因为此时，集合能够记住元素的类型信息，编译器已经能够确认它是String类型了。

通过上面的例子可以证明，在编译之后程序会采取去泛型化的措施。也就是说Java中的泛型，只在编译阶段有效。在编译过程中，正确检验泛型结果后，会将泛型的相关信息擦出，并且在对象进入和离开方法的边界处添加类型检查和类型转换的方法。也就是说，泛型信息不会进入到运行时阶段。

对此总结成一句话：泛型类型在逻辑上看以看成是多个不同的类型，实际上都是相同的基本类型。

泛型类

在类的申明时指定参数，即构成了泛型类。泛型类的类型参数部分可以有一个或多个类型参数，它们之间用逗号分隔。这些类称为参数化类或参数化类型，因为它们接受一个或多个参数。

定义一个简单的泛型类

//在实例化泛型类时，必须指定T的具体类型
public class Test<T>{
    //在类中声明的泛型整个类里面都可以用，除了静态部分，因为泛型是实例化时声明的。
    //静态区域的代码在编译时就已经确定，只与类相关
    class A <E>{
        T t;
    }
    //类里面的方法或类中再次声明同名泛型是允许的，并且该泛型会覆盖掉父类的同名泛型T
    class B <T>{
        T t;
    }
    //静态内部类也可以使用泛型，实例化时赋予泛型实际类型
    static class C <T> {
        T t;
    }
    public static void main(String[] args) {
        //报错，不能使用T泛型，因为泛型T属于实例不属于类
//        T t = null;
    }

    //key这个成员变量的类型为T,T的类型由外部指定
    private T key;

    public Test(T key) { //泛型构造方法形参key的类型也为T，T的类型由外部指定
        this.key = key;
    }

    public T getKey(){ //泛型方法getKey的返回值类型为T，T的类型由外部指定
        return key;
    }
}

在使用泛型的时候如果传入泛型实参，则会根据传入的泛型实参做相应的限制，此时泛型才会起到本应起到的限制作用，但是，泛型的类型参数只能是类类型，不能是简单类型。如果不传入泛型类型实参的话，在泛型类中使用泛型的方法或成员变量定义的类型可以为任何的类型。换句话说，泛型类可以看成普通类的工厂。

//不传入泛型类型实参
List list = new List();
list.add(123);
list.add("hello");
//传入的泛型实参
List list<String> = new List<String>();
list.add("hello");

如何继承一个泛型类

如果不传入具体的类型，则子类也需要指定类型参数，

class Son<T> extends Test<T>{}

如果传入具体参数，则子类不需要指定类型参数

class Son extends Test<String>{}

泛型接口

泛型接口与泛型类的定义基本一致

//定义一个泛型接口
public interface Generator<T> {
    public T next();
}

如何实现一个泛型接口

一个简单的例子

/**
 * 传入泛型实参时：
 * 定义一个生产器实现这个接口,虽然我们只创建了一个泛型接口Generator<T>
 * 但是我们可以为T传入无数个实参，形成无数种类型的Generator接口。
 * 在实现类实现泛型接口时，如已将泛型类型传入实参类型，则所有使用泛型的地方都要替换成传入的实参类型
 * 即：Generator<T>，public T next();中的的T都要替换成传入的String类型。
 */

public class FruitGenerator implements Generator<String> {
    private String[] fruits = new String[]{"Apple", "Banana", "Pear"};
    @Override
    public String next() {
        Random rand = new Random();
        return fruits[rand.nextInt(3)];
    }
}

泛型通配符

我们知道，Box<Number>和Box<Integer>实际上都是Box类型，现在需要继续探讨一个问题，那么在逻辑上，类似于Box<Number>和Box<Integer>是否可以看成具有父子关系的泛型类型呢？

为了弄清楚这个问题，我们使用Box这个泛型类继续看下面的例子：

package DateTest;
public class GenericTest {
	class Box<T> {
	    private T data;
	    public Box() {
	    }
	    public Box(T data) {
	        this.data = data;
	    }
	    public T getData() {
	        return data;
	    }
        public void setData(T data) {
        this.data = data;
    	}
	}
    public static void main(String[] args) {
        Box<Number> name = new Box<Number>(99);
        Box<Integer> age = new Box<Integer>(712);
        getData(name);
        //The method getData(Box<Number>) in the type GenericTest is 
        //not applicable for the arguments (Box<Integer>)
        getData(age);   // 1
    }
    public static void getData(Box<Number> data){
        System.out.println("data :" + data.getData());
    }
}

通过提示信息我们可以看到Box<Number>不能被看作为Box<Integer>的子类。由此可以看出:同一种泛型可以对应多个版本（因为参数类型是不确定的），不同版本的泛型类实例是不兼容的。

回到上面的例子，如何解决上面的问题？总不能为了定义一个新的方法来处理Generic类型的类，这显然与java中的多态理念相违背。因此我们需要一个在逻辑上可以表示同时是Box<Integer>和Box<Number>的父类的引用类型。由此类型通配符应运而生。

我们可以将上面的方法改一下：

public static void getData(Box<?> data) {
    System.out.println("data :" + data.getData());
}

类型通配符一般是使用？代替具体的类型实参，注意， 此处的？和Number、String、Integer一样都是一种实际的类型，可以把？看成所有类型的父类。是一种真实的类型。

可以解决当具体类型不确定的时候，这个通配符就是 ? ；当操作类型时，不需要使用类型的具体功能时，只使用Object类中的功能。那么可以用 ? 通配符来表未知类型。

泛型无限定通配符

无限定通配符使用<?>的格式，代表未知类型的泛型。 当可以使用Object类中提供的功能或当代码独立于类型参数来实现方法时，这样的参数可以使用任何对象。

public void showKeyValue1(List<?> list) {
    for (Object item : list) {  
        System.out.print(item + " ");   
    } 
}

泛型上限通配符

通配符上界使用<? extends T>的格式，意思是需要一个T类型或者T类型的子类，一般T类型都是一个具体的类型，例如下面的代码。

//只能传入number的子类或者number
public void showKeyValue2(List<? extends Number> list) {  
    for (Number number : list) {  
        System.out.print(number.intValue()+" ");   
    }  
}
//假如传入String类型，list.add("hello");会提示
//The method add(Number) in the type List<Number> is not applicable for the arguments (String)

无论传入的是何种类型的集合，我们都可以使用其父类的方法统一处理。

泛型下限通配符

通配符下界使用<? super T>的格式，意思是需要一个T类型或者T类型的父类，一般T类型都是一个具体的类型，例如下面的代码。

//只能传入Integer的父类或者Integer
public void showKeyValue3(List<? super Integer> obj){
    System.out.println(obj);
}
//假如传入String类型，list.add("hello");会提示
//The method add(Number) in the type List<Number> is not applicable for the arguments (String)

泛型方法

在java中，泛型类的定义非常简单，但是泛型方法就比较复杂了。
尤其是我们见到的大多数泛型类中的成员方法也都使用了泛型，有的甚至泛型类中也包含着泛型方法，这样在初学者中非常容易将泛型方法理解错了。
泛型类，是在实例化类的时候指明泛型的具体类型；泛型方法，是在调用方法的时候指明泛型的具体类型 。

定义泛型方法如下

调用泛型方法如下

定义泛型方法时，必须在返回值前边加一个<T>，来声明这是一个泛型方法，持有一个泛型T，然后才可以用泛型T作为方法的返回值。
Class<T>的作用就是指明泛型的具体类型，而Class<T>类型的变量c，可以用来创建泛型类的对象。
为什么要用变量c来创建对象呢？既然是泛型方法，就代表着我们不知道具体的类型是什么，也不知道构造方法如何，因此没有办法去new一个对象，但可以利用变量c的newInstance方法去创建对象，也就是利用反射创建对象。
泛型方法要求的参数是Class<T>类型，而Class.forName()方法的返回值也是Class<T>，因此可以用Class.forName()作为参数。其中，forName()方法中的参数是何种类型，返回的Class<T>就是何种类型。在本例中，forName()方法中传入的是User类的完整路径，因此返回的是Class<User>类型的对象，因此调用泛型方法时，变量c的类型就是Class<User>，因此泛型方法中的泛型T就被指明为User，因此变量obj的类型为User。

/**
 * 泛型方法的基本介绍
 * 说明：
 *     1）public 与 返回值中间<T>非常重要，可以理解为声明此方法为泛型方法。
 *     2）只有声明了<T>的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。
 *     3）<T>表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。
 *     4）与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型。
 */
public class Generic<T> {
    public T name;
    public  Generic(){}
    public Generic(T param){
        name=param;
    }
    public T m(){
        return name;
    }
    public <E> void m1(E e){ }
    public <T> T m2(T e){ }
}

上面代码中，m()方法不是泛型方法，m1()和m2()都是泛型方法。

泛型方法与可变参数

public class Test{
    @Test
    public void test () {
        printMsg("hello1",1,"hello2",2.0,false);
        print("hello1","hello2", "hello3");
    }
    //普通可变参数只能适配一种类型
    public void print(String ... args) {
        for(String t : args){
            System.out.println(t);
        }
    }
    //泛型的可变参数可以匹配所有类型的参数。。有点无敌
    public <T> void printMsg( T... args){
        for(T t : args){
            System.out.println(t);
        }
    }
}

静态方法与泛型

如果在类中定义使用泛型的静态方法，需要添加额外的泛型声明（将这个方法定义成泛型方法）。即使静态方法要使用泛型类中已经声明过的泛型也不可以。

public class Test<T> {
    private static T num;//此时编译器会提示错误信息
    public static void test(T t){//此时编译器会提示错误信息:
        ...
        //Cannot make a static reference to the non-static type T
    }
}

因为静态方法和静态变量属于类所有，而泛型类中的泛型参数的实例化是在创建泛型类型对象时指定的，所以如果不创建对象，根本无法确定参数类型。但是静态泛型方法是可以使用的，我们前面说过，泛型方法里面的那个类型和泛型类那个类型完全是两回事。

public class StaticGenerator<T> {
    public static <T> void show(T t){
    }
}

泛型的限制

Java泛型不能使用原始类型

使用泛型，原始类型不能作为类型参数传递。例如

Test<Integer> test = new Test<Integer>();

如果将int原始类型传递给Test类，那么编译器会报错。为了避免这种情况，需要传递Integer对象而不是int原始类型。

Java泛型不能使用实例

类型参数不能用于在方法中实例化其对象。例如

public static <T> void show(Test<T> test) {
   //compiler error
   //Cannot instantiate the type T
   //T item = new T();  
   //test.add(item);
}

如果需要实现这样的功能，可以使用反射。

public static <T> void show(Test<T> test, Class<T> clazz) 
   throws InstantiationException, IllegalAccessException{
   T item = clazz.newInstance();   // OK
   test.add(item);
   System.out.println("Item showed.");
}

Java泛型不能使用静态域

使用泛型时，类型参数不允许为静态(static)。由于静态变量在对象之间共享，因此编译器无法确定要使用的类型。如果允许静态类型参数。

Java泛型不能转换类型

除非由无界通配符进行参数化，否则不允许转换为参数化类型。

Test<Integer> integerTest = new Test<Integer>();
Test<Number> numberTest = new Test<Number>();
//Compiler Error: Cannot cast from Test<Number> to Test<Integer>，下面用法是错误的
integerTest = (Test<Integer>)numberTest;
//可以使用无界通配符进行转换功能
private static void add(Test<?> test){
   Test<Integer> integerTest = (Test<Integer>)test;
}

Java泛型instanceof运算符

因为编译器使用类型擦除，运行时不会跟踪类型参数，所以在Test <Integer>和Test <String>之间的运行时差异无法使用instanceOf运算符进行验证。

Java泛型不能使用异常

泛型类不允许直接或间接扩展Throwable类。

//The generic class Test<T> may not subclass java.lang.Throwable
class Test<T> extends Exception {}
//The generic class Test1<T> may not subclass java.lang.Throwable
class Test1<T> extends Throwable {}

在一个方法中，不允许捕获一个类型参数的实例，但throws子句中允许使用类型参数。

public static <T extends Exception, J> 
   void execute(List<J> jobs) {
      try {
         for (J job : jobs){}

         // compile-time error
         //Cannot use the type parameter T in a catch block
      } catch (T e) { 
         // ...
   }
}

//
class Test<T extends Exception>  {
   private int t;

   public void add(int t) throws T {
      this.t = t;
   }
   public int get() {
      return t;
   }   
}

Java泛型不能使用数组

错误代码

//Cannot create a generic array of Test<Integer>
Test<Integer>[] arrayOfLists = new Test<Integer>[2];

因为编译器使用类型擦除，类型参数被替换为Object，用户可以向数组添加任何类型的对象。但在运行时，代码将无法抛出ArrayStoreException。

下面使用Sun的一篇文档的一个例子来说明这个问题：

List<String>[] lsa = new List<String>[10]; // Not really allowed.    
Object o = lsa;    
Object[] oa = (Object[]) o;    
List<Integer> li = new ArrayList<Integer>();    
li.add(new Integer(3));    
oa[1] = li; // Unsound, but passes run time store check    
String s = lsa[1].get(0); // Run-time error: ClassCastException.

这种情况下，由于JVM泛型的擦除机制，在运行时JVM是不知道泛型信息的，所以可以给oa[1]赋上一个ArrayList而不会出现异常，但是在取出数据的时候却要做一次类型转换，所以就会出现ClassCastException，如果可以进行泛型数组的声明，上面说的这种情况在编译期将不会出现任何的警告和错误，只有在运行时才会出错。

而对泛型数组的声明进行限制，对于这样的情况，可以在编译期提示代码有类型安全问题，比没有任何提示要强很多。
下面采用通配符的方式是被允许的:数组的类型不可以是类型变量，除非是采用通配符的方式，因为对于通配符的方式，最后取出数据是要做显式的类型转换的。

List<?>[] lsa = new List<?>[10]; // OK, array of unbounded wildcard type.    
Object o = lsa;    
Object[] oa = (Object[]) o;    
List<Integer> li = new ArrayList<Integer>();    
li.add(new Integer(3));    
oa[1] = li; // Correct.    
Integer i = (Integer) lsa[1].get(0); // OK 

Java泛型不能重载

一个类不允许有两个重载方法，可以在类型擦除后使用相同的签名。

类型擦除

Java编译器应用类型擦除。 类型擦除是指编译器使用实际的类或桥接方法替换泛型参数的过程。 在类型擦除中，编译器确保不会创建额外的类，并且没有运行时开销。

Java编译器编译泛型的步骤：

1. 检查泛型的类型 ，获得目标类型
2. 擦除类型变量，并替换为限定类型（T为无限定的类型变量，用Object替换）
3. 调用相关函数，并将结果强制转换为目标类型。

 ArrayList<String> arrayString=new ArrayList<String>();     
 ArrayList<Integer> arrayInteger=new ArrayList<Integer>();     
 System.out.println(arrayString.getClass()==arrayInteger.getClass()); 

上面代码输入结果为 true，可见通过运行时获取的类信息是完全一致的，泛型类型被擦除了！

如何擦除：
当擦除泛型类型后，留下的就只有原始类型了，例如上面的代码，原始类型就是ArrayList。擦除类型变量，并替换为限定类型（T为无限定的类型变量，用Object替换），如下所示

擦除之前：

//泛型类型  
class Pair<T> {    
    private T value;    
    public T getValue() {    
        return value;    
    }    
    public void setValue(T  value) {    
        this.value = value;    
    }    
} 

擦除之后：

//原始类型  
class Pair {    
    private Object value;    
    public Object getValue() {    
        return value;    
    }    
    public void setValue(Object  value) {    
        this.value = value;    
    }    
}  

因为在Pair<T>中，T是一个无限定的类型变量，所以用Object替换。如果是Pair<T extends Number>，擦除后，类型变量用Number类型替换。

如果要死磕Java泛型内部原理，请参考文章泛型的内部原理：类型擦除以及类型擦除带来的问题、Java泛型深入了解

总结

在使用泛型类时，由于 Java 泛型的类型参数之实际类型在编译时会被消除，所以无法在运行时得知其类型参数的类型。虽然传入了不同的泛型实参，但并没有真正生成不同的类型，传入不同泛型实参的泛型类在内存上实际只有一个，但在逻辑上，我们可以理解为多个不同的泛型类型。

参考文章

https://blog.csdn.net/s10461/article/details/53941091

https://www.cnblogs.com/lwbqqyumidi/p/3837629.html

https://www.cnblogs.com/iyangyuan/archive/2013/04/09/3011274.html