JavaSE——泛型详解

概述：

泛型，即“参数化的类型”，指将类型定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。

引入的原因：

引入泛型我觉得最主要的原因是使得程序更为灵活，去掉许多冗余不必要的代码。最直接的例子就是方法重载，比如需要设计一个计算器，仅针对加法运算的方法，我们就需要仅因为参数的类型的差异而需要设计很多重载的方法，这些代码看上去都是很相似的、可以用一个更通用的方法所替代的，因此我们引入泛型，在使用的时候仅传入具体的类型就可以了。

一个特殊的栗子:

public class Test01 {
    public static void main(String[] args) throws ParseException {
        List<String> stringList = new ArrayList<>();
        List<Integer> integerList = new ArrayList<>();
        
        System.out.println(stringList.getClass().equals(integerList.getClass()));	//true
    }
}

我们感觉当对同一个泛型类传入具体类型时，原占位符会替换成具体的类型，看上去好像是两个不一样的类，因为这个类里面有占位符的地方被替换了不同的类型（可以这么理解，但会产生误区），但实际上它们的Class对象是一样的，这就表明它们都属于同一个类型，调用Class对象的getName()方法可以得到它们都是java.util.ArrayList类，为什么会这样呢？

原理：

为什么这样的原因是在编译期间，所有的泛型信息都会被擦除，List和List类型，在编译后都会变成List类型（原始类型）。Java中的泛型基本上都是在编译器这个层次来实现的，这也是Java的泛型被称为“伪泛型”的原因。

原始类型：

原始类型就是泛型类型擦除了泛型信息后，在字节码中真正的类型。无论何时定义一个泛型类型，相应的原始类型都会被自动提供。原始类型的名字就是删去类型参数后的泛型类型的类名。擦除 类型变量，并替换为 限定类型（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;  
    }  
}  

所以经编译后上述的List和List类型都会变成原始类型，所以类型都是一样的。

注意：如果是Pair，擦除后，类型变量用Number类型替换。

结论：

泛型变量会在编译时候擦除变为原始类型Object，需要使用泛型变量的时候编译器会自动进行强制类型转换，将该对象转为原类型

泛型的作用：

注意：这里专指在使用泛型定义的类、接口、方法的时候，传递了具体的参数的情况，如果在使用的时候没有指定具体的参数，默认为Object类型。

1. 类型安全：在编译阶段就会对类型进行检查类型是否一致的问题。
2. 消除强制类型转换和安全隐患：因为确定了具体的类型，所以不需要进行类型转换，也不会产生因强制类型转换引发的异常。

突破泛型约束：

既然Java泛型是伪泛型，编译后泛型的相关信息就被擦除了，我们仍可以通过反射机制获取到这些泛型，当然这和我们这个问题没什么关系。试想？由于我们对泛型类传递了具体的类型，编译器会在编译阶段就进行类型检查，因此我们就不能再插入其他类型的对象了，有没有什么方法可以帮助我们突破这个约束呢？

我们知道泛型信息在编译之后被擦除了，只保留了原始类型，类型变量（T）被替换为Object，在运行时，我们可以行其中插入任意类型的对象。因此我们就可以通过反射机制去调用这个方法，就没有类型的限制了。

public class Test01 {
    public static void main(String[] args) throws ParseException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        List<String> stringList = new ArrayList<>();

        Class c1 = stringList.getClass();

        Method addMethod = c1.getMethod("add", Object.class);   //获取到add这个方法
        addMethod.invoke(stringList,new Integer(1));

        System.out.println(stringList); //[1]	//Integer对象确实被加进去了
    }
}

泛型的使用：

1. 泛型类

   public class Test02 {
       public static void main(String[] args) {
           //泛型类的使用，创建对象时的具体类型可写可不写
           GenericClass<Integer> c1 = new GenericClass<>();
           System.out.println(c1.test(1));
   
           //当没传递具体的类型时，默认为Object类型
           GenericClass c2 = new GenericClass();
           System.out.println(c2.test("123"));
       }
   }
   
   //泛型类的定义
   class GenericClass<T>{
       T test(T value){
           return value;
       }
   }
   

2. 泛型接口：

   //泛型接口
   interface GenericInterface<T>{
       T test(T value);
   }
   
   //泛型接口的实现类可以继续使用泛型，也可以传递具体的类型
   class GenericClass2 implements GenericInterface<String>{
   
       @Override
       public String test(String value) {
           return null;
       }
   }
   class GenericClass3<T> implements GenericInterface<T>{
       @Override
       public T test(T value) {
           return null;
       }
   }
   

3. 泛型方法：

   /*
   	在调用泛型方法的时候，可以指定泛型类型，也可以不指定。
   
   	在不指定泛型类型的情况下，泛型类型为该方法中的几种参数类型的共同父类的最小级，直到Object。
   
   	在指定泛型类型的时候，该方法中的所有参数类型必须是该泛型类型或者其子类。
   */
   public class Test03 {
       public static void main(String[] args) {
           //泛型方法的使用
           //不指定泛型的时候
           int i=GenericMethod.test(1, 2); //这两个参数都是Integer，所以T替换为Integer类型  
           Number f=GenericMethod.test(1, 1.2);//这两个参数一个是Integer，另一个是Float，所以取同一父类的最小级，为Number  
           Object o=GenericMethod.test(1, "asd");//这两个参数一个是Integer，另一个是String，所以取同一父类的最小级，为Object
   
           //指定泛型的时候
           int a=GenericMethod.<Integer>test(1, 2);//指定了Integer，所以只能为Integer类型或者其子类  
           int b=GenericMethod.<Integer>test(1, 2.2);//编译错误，指定了Integer，不能为Float  
           Number c=GenericMethod.<Number>test(1, 2.2); //指定为Number，所以可以为Integer和Float
       }
   }
   
   //泛型方法
   class GenericMethod{
       //T只对方法生效，其他方法无效
       public static <T> T test(T value1,T value2){
           return value1;
       }
   }
   

通配符"?"的使用:

一般用于集合中：

1. List<? extends Person>

   表示List的泛型为Person或者它的子类

2. List<? super Person>

   表示List的泛型为Person或者它的父类

3. List<? extends Comparable>

   表示List的泛型为Comparable的实现类

4. List<?>

   表示List的泛型为任意类型，因此可以传任意泛型的集合进去。

注意List<?>和List<Object>还是有很大区别的，List<?>可以接受任何泛型的集合，而List<Object>只接受泛型参数为Object的集合。

参考：
《Java核心技术 卷一》