Java泛型

为什么要引入泛型？

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

  • 适用于多种数据类型执行相同的代码（代码复用） ```java private static int add(int a, int b) { System.out.println(a + “+” + b + “=” + (a + b)); return a + b; }

private static float add(float a, float b) { System.out.println(a + “+” + b + “=” + (a + b)); return a + b; }

private static double add(double a, double b) { System.out.println(a + “+” + b + “=” + (a + b)); return a + b; } // 上面的方法可以通过泛型进行代码复用为一个方法 private static double add(T a, T b) { System.out.println(a + “+” + b + “=” + (a.doubleValue() + b.doubleValue())); return a.doubleValue() + b.doubleValue(); }

  3. - 
  4. 泛型中的类型在使用时指定，不需要强制类型转换（**类型安全，编译器会检查类型**）
  5. ```java
  6. // 比如，不使用泛型时
  7. List list = new ArrayList();
  8. list.add(1);
  9. list.add("a");
  10. list.add(new Date());
  11. // 这样，list中的元素将都是Object类型，在取出list中的元素时需要进行强制类型转换，容易出错。
  12. // 而使用泛型后，可以提供类型的约束，提供编译前检查
  13. List<String> list = new ArrayList();
  14. list.add("a");
  15. list.add(1); // 编译器将报错，编译无法通过

泛型的基本使用

泛型类

  1. class Point<T>{         // 此处可以随便写标识符号，T是type的简称  
  2.     private T var ;     // var的类型由T指定，即：由外部指定  
  4.     public T getVar(){  // 返回值的类型由外部决定  
  5.         return var ;  
  6.     }  
  7.     public void setVar(T var){  // 设置的类型也由外部决定  
  8.         this.var = var ;  
  9.     }  
  10. }  
  12. // 多元泛型
  13. class Notepad<K,V>{       // 此处指定了两个泛型类型  
  14.     private K key ;     // 此变量的类型由外部决定  
  15.     private V value ;   // 此变量的类型由外部决定  
  16. }

泛型接口

  1. interface Info<T>{        // 在接口上定义泛型  
  2.     public T getVar() ;   // 定义抽象方法，抽象方法的返回值就是泛型类型  
  3. }  
  4. class InfoImpl<T> implements Info<T>{   // 定义泛型接口的子类  
  5.     private T var ;             // 定义属性  
  6.     public InfoImpl(T var){     // 通过构造方法设置属性内容  
  7.         this.setVar(var) ;    
  8.     }  
  9.     public void setVar(T var){  
  10.         this.var = var ;  
  11.     }  
  12.     public T getVar(){  
  13.         return this.var ;  
  14.     }  
  15. } 
  16. public class GenericsDemo24{  
  17.     public static void main(String arsg[]){  
  18.         Info<String> i = null;        // 声明接口对象  
  19.         i = new InfoImpl<String>("汤姆") ;  // 通过子类实例化对象  
  20.         System.out.println("内容：" + i.getVar()) ;  
  21.     }  
  22. }

泛型方法

泛型方法的定义格式

Java泛型 - 图1

泛型方法的调用格式

Java泛型 - 图2

  1. Object obj = getObject(Class.forName("java.lang.String"));
  2. system.out.println(obj.getClass()); // java.lang.String
  • 定义泛型方法时，必须在返回值前边加一个<T>，来声明这是一个泛型方法，持有一个泛型T，然后才可以用泛型T作为方法的返回值。因为是泛型方法，就代表着我们不知道具体的类型是什么，也不知道构造方法如何，因此没有办法去new一个对象，但可以利用变量c的newInstance方法去创建对象，也就是利用反射创建对象。
  • Class<T>的作用就是指明泛型的具体类型，而Class<T>类型的变量c，可以用来创建泛型类的对象。泛型方法要求的参数是Class<T>类型，而Class.forName()方法的返回值也是Class<T>，因此可以用Class.forName()作为参数

因为泛型类在实例化的时候就需要指定类型，如果需要换一种类型，就需要重新new对象，而使用泛型方法则可以在调用的再时候指定类型，增加灵活性。

数组的泛型

泛型数组的声明

  1. List<String>[] list11 = new ArrayList<String>[10]; //编译错误，非法创建 
  2. List<?>[] list14 = new ArrayList<String>[10]; //编译错误，非法创建 
  3. List<String>[] list12 = new ArrayList<?>[10]; //编译错误，需要强转类型  
  4. List<String>[] list13 = (List<String>[]) new ArrayList<?>[10]; //OK，但是会有警告
  5. List<String>[] list6 = new ArrayList[10]; //OK，但是会有警告
  6. List<?>[] list15 = new ArrayList<?>[10]; //OK

使用场景

  1. public class GenericsDemo30{  
  2.     public static void main(String args[]){  
  3.         Integer i[] = fun1(1,2,3,4,5,6) ;   // 返回泛型数组  
  4.         fun2(i) ;  
  5.     }  
  6.     public static <T> T[] fun1(T...arg){  // 接收可变参数  
  7.         return arg ;            // 返回泛型数组  
  8.     }  
  9.     public static <T> void fun2(T param[]){   // 输出  
  10.         System.out.print("接收泛型数组：") ;  
  11.         for(T t:param){  
  12.             System.out.print(t + "、") ;  
  13.         }  
  14.     }  
  15. }
  17. public ArrayWithTypeToken(Class<T> type, int size) {
  18.     array = (T[]) Array.newInstance(type, size);
  19. }

泛型的上下限

  1. <?> 无限制通配符
  2. <? extends E> extends 关键字声明了类型的上界，表示参数化的类型可能是所指定的类型，或者是此类型的子类
  3. <? super E> super 关键字声明了类型的下界，表示参数化的类型可能是指定的类型，或者是此类型的父类
  5. // 使用原则《Effictive Java》
  6. // 为了获得最大限度的灵活性，要在表示 生产者或者消费者 的输入参数上使用通配符，使用的规则就是：生产者有上限、消费者有下限
  7. 1. 如果参数化类型表示一个 T 的生产者，使用 < ? extends T>;
  8. 2. 如果它表示一个 T 的消费者，就使用 < ? super T>；
  9. 3. 如果既是生产又是消费，那使用通配符就没什么意义了，因为你需要的是精确的参数类型。
  1. private  <E extends Comparable<? super E>> E max(List<? extends E> e1) {
  2.     if (e1 == null){
  3.         return null;
  4.     }
  5.     //迭代器返回的元素属于 E 的某个子类型
  6.     Iterator<? extends E> iterator = e1.iterator();
  7.     E result = iterator.next();
  8.     while (iterator.hasNext()){
  9.         E next = iterator.next();
  10.         if (next.compareTo(result) > 0){
  11.             result = next;
  12.         }
  13.     }
  14.     return result;
  15. }

上述代码中的类型参数 E 的范围是<E extends Comparable<? super E>>，我们可以分步查看：

  • 要进行比较，所以 E 需要是可比较的类，因此需要 extends Comparable<…>（注意这里不要和继承的 extends 搞混了，不一样）
  • Comparable< ? super E> 要对 E 进行比较，即 E 的消费者，所以需要用 super
  • 而参数 List< ? extends E> 表示要操作的数据是 E 的子类的列表，指定上限，这样容器才够大

使用多个限制时，用&符号

  1. public class Client {
  2.     // 工资低于2500元的上斑族并且站立的乘客车票打8折
  3.     public static <T extends Staff/*站客*/ & Passenger/*上班族*/> void discount(T t){
  4.         if(t.getSalary()<2500 && t.isStanding()){
  5.             System.out.println("恭喜你！您的车票打八折！");
  6.         }
  7.     }
  8.     public static void main(String[] args) {
  9.         discount(new Me());
  10.     }
  11. }

泛型深入理解

如何理解Java中的泛型是伪泛型？泛型中类型擦除？

泛型的类型擦除原则是：

  • 消除类型参数声明，即删除<>及其包围的部分。
  • 根据类型参数的上下界推断并替换所有的类型参数为原生态类型：如果类型参数是无限制通配符或没有上下界限定则替换为Object，如果存在上下界限定则根据子类替换原则取类型参数的最左边限定类型（即父类）。比如形如<T extends Number>和<? extends Number>的类型参数被替换为Number，<? super Number>被替换为Object。方法的泛型擦除和类定义的泛型参数一样。
  • 为了保证类型安全，必要时插入强制类型转换代码。
  • 自动产生“桥接方法”以保证擦除类型后的代码仍然具有泛型的“多态性”。

Java泛型 - 图3

Java泛型 - 图4

Java泛型 - 图5

怎么擦除泛型：

[http://softlab.sdut.edu.cn/blog/subaochen/2017/01/generics-type-erasure

如何证明类型的擦除呢？

只需要证明在泛型被编译后的类型是否都为Object或者替换的类型即可。

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         ArrayList<String> list1 = new ArrayList<String>();
  4.         list1.add("abc"); // String
  5.         ArrayList<Integer> list2 = new ArrayList<Integer>();
  6.         list2.add(123); // Integer
  7.         System.out.println(list1.getClass() == list2.getClass()); // true
  8.     }
  9. }
  1. public class Test {
  2.     public static void main(String[] args) throws Exception {
  3.         ArrayList<Integer> list = new ArrayList<Integer>();
  4.         list.add(1);  // 这样调用 add 方法只能存储整形，因为泛型类型的实例为 Integer
  5.         // 反射获取的是编译后的方法,此时泛型也被擦除
  6.         list.getClass().getMethod("add", Object.class).invoke(list, "String");
  7.         for (int i = 0; i < list.size(); i++) {
  8.             System.out.println(list.get(i)); // 可获取String
  9.         }
  10.     }
  11. }

如何理解类型擦除后保留的原始类型?

原始类型 就是擦除去了泛型信息，最后在字节码中的类型变量的真正类型，无论何时定义一个泛型，相应的原始类型都会被自动提供，类型变量擦除，并使用其限定类型（无限定的变量用Object）替换。

  1. class Pair<T> {  
  2.     private T value;  
  3.     public T getValue() {  
  4.         return value;  
  5.     }  
  6.     public void setValue(T  value) {  
  7.         this.value = value;  
  8.     }  
  9. } 
  10. // 擦除泛型后的原始类型
  11. class Pair {  
  12.     private Object value;  
  13.     public Object getValue() {  
  14.         return value;  
  15.     }  
  16.     public void setValue(Object  value) {  
  17.         this.value = value;  
  18.     }  
  19. }

如何理解泛型的编译期检查？

Java编译器是通过先检查代码中泛型的类型，然后在进行类型擦除，再进行编译。

  1. public class Test {  
  3.     public static void main(String[] args) {  
  5.         ArrayList<String> list1 = new ArrayList();  
  6.         list1.add("1"); //编译通过  
  7.         list1.add(1); //编译错误  
  8.         String str1 = list1.get(0); //返回类型就是String  
  10.         ArrayList list2 = new ArrayList<String>();  
  11.         list2.add("1"); //编译通过  
  12.         list2.add(1); //编译通过  
  13.         Object object = list2.get(0); //返回类型就是Object  
  15.         new ArrayList<String>().add("11"); //编译通过  
  16.         new ArrayList<String>().add(22); //编译错误  
  18.         String str2 = new ArrayList<String>().get(0); //返回类型就是String  
  19.     }  
  20. }

因为类型检查就是编译时完成的，new ArrayList()只是在内存中开辟了一个存储空间，可以存储任何类型对象，而真正设计类型检查的是它的引用，因为我们是使用它引用list1来调用它的方法，比如说调用add方法，所以list1引用能完成泛型类型的检查。而引用list2没有使用泛型，不能完成泛型检查。

通过上面的例子，可以明白，类型检查就是针对引用的，谁是一个引用（list1，list2），用这个引用调用泛型方法，就会对这个引用调用的方法进行类型检测，而无关它真正引用的对象（new ArrayList()，new ArrayList()）。

如何理解泛型的多态？泛型的桥接方法

如何理解基本类型不能作为泛型类型？

泛型被擦除后的原始类型都是引用类型，而基本类型不是引用类型，只能使用基本类型的包装类型。

如何理解泛型类型不能实例化？

  1. T test = new T(); // ERROR

Java在编译器不能确定泛型的具体类型，所以在new 对象的时候无法找到具体的类文件，无法通过编译。并且T类型会被擦除为Object，new Object()不本意，如果要实例化泛型，可以通过反射的方式。

  1. static <T> T newTclass (Class < T > clazz) throws InstantiationException, IllegalAccessException {
  2.     T obj = clazz.newInstance();
  3.     return obj;
  4. }

泛型数组：能不能采用具体的泛型类型进行初始化？

看这么一段代码：

  1. List<String>[] lsa = new List<String>[10]; // Not really allowed.
  2. Object o = lsa; // lsa 赋值给Object
  3. Object[] oa = (Object[]) o; // Object强转为Object[]
  4. List<Integer> li = new ArrayList<Integer>();
  5. li.add(new Integer(3));
  6. oa[1] = li; // Unsound, but passes run time store check
  7. String s = lsa[1].get(0); // Run-time error ClassCastException.

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

泛型数组：如何正确的初始化泛型数组实例？

这个无论我们通过new ArrayList[10] 的形式还是通过泛型通配符的形式初始化泛型数组实例都是存在警告的，也就是说仅仅语法合格，运行时潜在的风险需要我们自己来承担，因此那些方式初始化泛型数组都不是最优雅的方式。

在使用到泛型数组的场景下应该尽量使用列表集合替换，此外也可以通过使用 java.lang.reflect.Array.newInstance(Class<T> componentType, int length) 方法来创建一个具有指定类型和维度的数组，如下：

  1. public class ArrayWithTypeToken<T> {
  2.     private T[] array;
  3.     public ArrayWithTypeToken(Class<T> type, int size) {
  4.         array = (T[]) Array.newInstance(type, size); // 使用Array类的newInstance方法反射获取数组对象
  5.     }
  6.     public void put(int index, T item) {
  7.         array[index] = item;
  8.     }
  9.     public T get(int index) {
  10.         return array[index];
  11.     }
  12.     public T[] create() {
  13.         return array;
  14.     }
  15. }
  16. //...
  17. ArrayWithTypeToken<Integer> arrayToken = new ArrayWithTypeToken<Integer>(Integer.class, 100);
  18. Integer[] array = arrayToken.create();

如何理解泛型类中的静态方法和静态变量？

泛型类中的静态方法和静态变量不可以使用泛型类所声明的泛型类型参数

因为静态属性是属于类的，在类加载就存在了，不需要实例化类，而泛型参数在类没有实例化时是无法确定类型的，因此静态变量和方法不能使用泛型类所声明的泛型类型参数。

如何理解异常中使用泛型？

  • 不能抛出也不能捕获泛型类的对象 ```java public class Problem extends Exception { // 编译不通过 }

try{ // todo } catch(Problem e1) { // todo } catch(Problem e2) { // todo } // 假设编译可以 // 泛型擦除后，那么两个地方的catch都变为原始类型Object，那么也就是说，这两个地方的catch变的一模一样

  3. - 
  4. 不能再catch子句中使用泛型变量
  5. ```java
  6. // 泛型信息在编译的时候已经变为原始类型，也就是说上面的T会变为原始类型Throwable，那么如果可以再catch子句中使用泛型变量
  7. public static <T extends Throwable> void doWork(Class<T> t){
  8.     try {
  10.     } catch(T e) { //编译错误
  12.     } catch(IndexOutOfBounds e) {
  14.     }                         
  15. }
  16. // 根据异常捕获的原则，一定是子类在前面，父类在后面，那么上面就违背了这个原则
  17. // 为了避免这样的情况，禁止在catch子句中使用泛型变量。
  • 在异常声明中可以使用类型变量
    1. // 下面的使用是合法的
    2. public static<T extends Throwable>/*必须上界为异常体系类*/ void doWork(T t) throws T {
    3.   try{
    4.       ...
    5.   } catch(Throwable realCause) {
    6.       t.initCause(realCause);
    7.       throw t; // 抛出实际异常类
    8.   }
    9. }

如何获取泛型的参数类型？

通过反射的方可以获取泛型。

  1. public class GenericType<T> {
  2.     private T data;
  4.     public static void main(String[] args) {
  5.         GenericType<String> genericType = new GenericType<String>() {};
  6.         Type superclass = genericType.getClass().getGenericSuperclass();
  7.         //getActualTypeArguments 返回确切的泛型参数, 如Map<String, Integer>返回[String, Integer]
  8.         Type type = ((ParameterizedType) superclass).getActualTypeArguments()[0]; 
  9.         System.out.println(type);//class java.lang.String
  10.     }
  11. }
  1. public interface ParameterizedType extends Type {
  2.     // 返回确切的泛型参数, 如Map<String, Integer>返回[String, Integer]
  3.     Type[] getActualTypeArguments();
  5.     //返回当前class或interface声明的类型, 如List<?>返回List
  6.     Type getRawType();
  8.     //返回所属类型. 如,当前类型为O<T>.I<S>, 则返回O<T>. 顶级类型将返回null 
  9.     Type getOwnerType();
  10. }