Java泛型你必须知道的知识

开发 后端
Java 泛型(generics)是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制,该机制允许程序员在编译时检测到非法的类型。

[[384110]]

 一 什么是泛型

Java 泛型(generics)是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制,该机制允许程序员在编译时检测到非法的类型。

简单理解就是:泛型指定编译时的类型,减少运行时由于对象类型不匹配引发的异常。其主要用途是提高我们的代码的复用率。

我们Java标准库中的ArrayList就是泛型使用的典型应用:

  1. public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable { 
  2.         
  3.       ...... 
  4.  
  5.     public ArrayList(Collection<? extends E> c) { 
  6.         elementData = c.toArray(); 
  7.         if ((size = elementData.length) != 0) { 
  8.             // c.toArray might (incorrectly) not return Object[] (see 6260652) 
  9.             if (elementData.getClass() != Object[].class) 
  10.                 elementData = Arrays.copyOf(elementData, size, Object[].class); 
  11.         } else { 
  12.             // replace with empty array. 
  13.             this.elementData = EMPTY_ELEMENTDATA; 
  14.         } 
  15.     } 
  16.  
  17.     public void sort(Comparator<? super E> c) { 
  18.         final int expectedModCount = modCount; 
  19.         Arrays.sort((E[]) elementData, 0, size, c); 
  20.         if (modCount != expectedModCount) { 
  21.             throw new ConcurrentModificationException(); 
  22.         } 
  23.         modCount++; 
  24.     } 
  25.     
  26.   ..... 
  27.  
  28.     public E get(int index) { 
  29.         rangeCheck(index); 
  30.  
  31.         return elementData(index); 
  32.     } 
  33.  
  34.     public boolean add(E e) { 
  35.         ensureCapacityInternal(size + 1);  // Increments modCount!! 
  36.         elementData[size++] = e; 
  37.         return true
  38.     } 
  39.  
  •  源码中,ArrayList中的E称为类型参数变量,而整个ArrayList我们称为泛型类型。 我们可以指定除基本类型之外的任何类型,如:ArrayList
  • 源码中Collection 中? 通配符类型 表示类型的上界,表示参数化类型的可能是T 或是 T的子类。
  • 源码中Comparator 表示类型下界(Java Core中叫超类型限定),表示参数化类型是此类型的超类型(父类型),直至Object。

二 extends和super通配符

在定义泛型类型Generic的时候,也可以使用extends通配符来限定T的类型:

  1. public class Generic<T extends Number> { ... } 

现在,我们只能定义:

  1. Generic<Number> p1 = null
  2. Generic<Integer> p2 = new Generic<>(1, 2); 
  3. Generic<Double> p3 = null

因为Number、Integer和Double都符合

非Number类型将无法通过编译:

  1. Generic<String> p1 = null; // compile error! 
  2. Generic<Object> p2 = null; // compile error! 

 因为String、Object都不符合,因为它们不是Number类型或Number的子类。

我们看一个例子:

  1. public class Test { 
  2.  
  3.     static class Food { 
  4.  
  5.     } 
  6.  
  7.     static class Fruit extends Food { 
  8.     } 
  9.  
  10.     static class Apple extends Fruit { 
  11.     } 
  12.  
  13.     static class Orange extends Fruit { 
  14.     } 
  15.  
  16.     public void testExtend() { 
  17.         List<? extends Fruit> list = new ArrayList<Apple>(); 
  18.  
  19.         //无法安全添加任何具有实际意义的元素,报错,extends为上界通配符,只能取值,不能放. 
  20.         //因为Fruit的子类不只有Apple还有Orange,这里不能确定具体的泛型到底是Apple还是Orange,所以放入任何一种类型都会报错 
  21.  
  22.         //list.add(new Apple()); 
  23.         //list.add(new Orange()); 
  24.  
  25.         //可以添加null,因为null可以表示任何类型 
  26.         list.add(null); 
  27.  
  28.         //可以正常获取,用java多态 
  29.         Food foot = list.get(0); 
  30.         Apple apple = (Apple) list.get(0); 
  31.     } 
  32.  
  33.     public void testSuper() { 
  34.         List<? super Fruit> list = new ArrayList<Fruit>(); 
  35.  
  36.         //super为下界通配符,可以存放元素,但是也只能存放当前类或者子类的实例,以当前的例子来讲, 
  37.         list.add(new Fruit()); 
  38.         list.add(new Apple()); 
  39.  
  40.         //无法确定Fruit的父类是否只有Food一个(Object是超级父类) 
  41.         //因此放入Food的实例编译不通过,只能放自己的实例 或者根据java多态的特性放子类实例 
  42.         //list.add(new Food()); 
  43.         //List<? super Fruit> list2 = new ArrayList<Apple>(); 
  44.         //Fruit fruit = list.get(0); //不能确定返回类型 
  45.  
  46.     } 
  47.  

 在testExtend方法中,因为泛型中用的是extends,在向list中存放元素的时候,我们并不能确定List中的元素的具体类型,即可能是Apple也可能是Orange。因此调用add方法时,不论传入new Apple()还是new Orange(),都会出现编译错误。

理解了extends之后,再看super就很容易理解了,即我们不能确定testSuper方法的参数中的泛型是Fruit的哪个父类,因此在调用get方法时只能返回Object类型。结合extends可见,在获取泛型元素时,使用extends获取到的是泛型中的上边界的类型(本例子中为Fruit),范围更小。

总结:

  • 在使用泛型时,存取元素时用super。
  • 获取元素时,用extends。

有了上面的结论我们看下Java标准库的Collections类定义的copy()方法,这个copy()方法的定义就完美地展示了extends和super的意图:

  • copy()方法内部不会读取dest,因为不能调用dest.get()来获取T的引用;
  • copy()方法内部也不会修改src,因为不能调用src.add(T)。
  1. public class Collections { 
  2.     // 把src的每个元素复制到dest中: 
  3.     public static <T> void copy(List<? super T> dest, List<? extends T> src) { 
  4.         for (int i=0; i<src.size(); i++) { 
  5.             T t = src.get(i); 
  6.             dest.add(t); 
  7.         } 
  8.     } 

 三 泛型擦除

Java的泛型是伪泛型,这是因为Java在编译期间,所有的泛型信息都会被擦掉,正确理解泛型概念的首要前提是理解类型擦除。Java的泛型基本上都是在编译器这个层次上实现的,在生成的字节码中是不包含泛型中的类型信息的,使用泛型的时候加上类型参数,在编译器编译的时候会去掉,这个过程成为类型擦除

我们看一个示例:

  1. public class Test2 { 
  2.  
  3.     public static void main(String[] args) { 
  4.         Map<String, Animal> map = new HashMap<>(); 
  5.         Animal animal = new Animal(); 
  6.         animal.setVegetarian(true); 
  7.         animal.setEats("fish"); 
  8.         map.put("cat", animal); 
  9.  
  10.         String json = new Gson().toJson(map); 
  11.         System.out.println(json); 
  12.  
  13.         Map<String, Animal> jsonToMap = fromJson(json); 
  14.         System.out.println(jsonToMap); 
  15.  
  16.         Animal animal1 = jsonToMap.get("cat"); 
  17.         System.out.println(animal1.getEats()); 
  18.     } 
  19.  
  20.     public static <T> T fromJson(String str) { 
  21.         return new Gson().fromJson(str, new TypeToken<T>() { 
  22.         }.getType()); 
  23.     } 
  24.  

 上的代码运行会提示如下异常:

  1. Exception in thread "main" java.lang.ClassCastException: com.google.gson.internal.LinkedTreeMap cannot be cast to com.uaf.rabbitmq.producer.Animal 
  2.     at com.uaf.rabbitmq.producer.Test2.main(Test2.java:30) 

 异常原因主要是这句:new Gson().fromJson(str, new TypeToken() {}.getType());

这句在实际执行的时候,List中的T并未传入实际的泛型参数,导致Gson按照LinkedTreeMap来解析JSON,以致发生了错误;这就是一个在编译期泛型类型擦除所导致的问题;

解决这个问题我们需要修改fromJson方法

  1. public class Test2 { 
  2.  
  3.     public static void main(String[] args) { 
  4.         Map<String, Animal> map = new HashMap<>(); 
  5.         Animal animal = new Animal(); 
  6.         animal.setVegetarian(true); 
  7.         animal.setEats("fish"); 
  8.         map.put("cat", animal); 
  9.  
  10.         String json = new Gson().toJson(map); 
  11.         System.out.println(json); 
  12.  
  13.         Map<String, Animal> jsonToMap = fromJson(json,  
  14.         new TypeToken<Map<String, Animal>>() {}.getType()); 
  15.         System.out.println(jsonToMap); 
  16.  
  17.         Animal animal1 = jsonToMap.get("cat"); 
  18.         System.out.println(animal1.getEats()); 
  19.  
  20.     } 
  21.  
  22.     public static <T> T fromJson(String str, Type type) { 
  23.         return new Gson().fromJson(str, type); 
  24.     } 
  25.  

 在Gson中提供了TypeToken解决泛型运行时类型擦除问题,TypeToken 这个类来帮助我们捕获像Map这样的泛型信息。上文创建了一个匿名内部类,这样Java编译器就会把泛型信息编译到这个匿名内部类里,然后在运行时就可以被getType()方法用反射API提取到。

 

责任编辑:姜华 来源: 今日头条
相关推荐

2017-12-07 15:28:36

2017-12-07 15:47:25

2017-10-11 15:50:18

光纤通信传输

2011-05-13 11:41:55

2012-09-29 09:22:24

.NETGC内存分配

2012-09-29 10:29:56

.Net内存分配继承

2021-06-29 15:56:39

MYSQL开发数据库

2020-02-28 14:05:00

Linuxshell命令

2021-10-29 08:44:22

推拉机制面试broker

2015-07-23 10:37:13

Linux命令

2011-11-30 09:09:13

王涛Windows Pho移动开发

2015-06-29 09:40:10

Rails新特性

2019-05-30 08:25:50

5G4G网络

2021-10-17 13:10:56

函数TypeScript泛型

2011-12-16 17:05:58

2012-11-05 09:19:37

2011-05-11 15:28:05

2017-10-17 15:18:58

综合布线网络

2009-06-04 10:20:34

Hibernate持久化Java

2021-09-15 09:20:37

Python函数代码
点赞
收藏

51CTO技术栈公众号