基础篇：深入解析Java泛型

本文转载自微信公众号「潜行前行」，作者cscw 。转载本文请联系潜行前行公众号。

创新互联建站专业为企业提供芦山网站建设、芦山做网站、芦山网站设计、芦山网站制作等企业网站建设、网页设计与制作、芦山企业网站模板建站服务，10年芦山做网站经验，不只是建网站，更提供有价值的思路和整体网络服务。

 1 JAVA的Type类型体系

先了解下java的Type类型体系(类的类=>类型)，Type是所有类型(原生类型-Class、参数化类型-Parameterizedtype、数组类型-GenericArrayType、类型变量-TypeVariable、基本类型-Class)的共同接口;前两篇反射和注解讲到的Class 就是Type的一实现类

  • Type下面又有四个子接口类ParameterizedType、TypeVariable、GenericArrayType、WildcardType
    • List 表示泛型，E是TypeVariable类型，List 则是ParameterizedType(参数化类型)，List 里的String称为实际参数类型
    • 具体化泛型中的类型时，可以使用 ? extends 或 ? super来表示继承关系;如List ，而里面的 ? 称为通配符类型WildcardType
    • GenericArrayType 表示一种元素类型是ParameterizedType(参数化类型)或者TypeVariable(类型变量)的数组类型，如T[] 或者 List []
  • 注解是JDK1.5才出现了的，为了表示被注解的类型的，加入AnnotatedElement类型，字面意思就是被注解的元素。JDK1.8又有了AnnotatedType将Type和被注解元素的概念关联起来。

  • AnnotatedType也有四个子接口，和Type的四个子接口一一对应，如：ParameterizedType类型被注解则被编译器解析成AnnotatedParameterizedType: @AnTest("list")List list

2 泛型的概念

  • Java 泛型(generics)是JDK1.5中引入的一个新特性，其本质是参数化类型，解决不确定具体对象类型的问题;其所操作的数据类型被指定为一个参数(type parameter)这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法

泛型: 把类型明确的工作推迟到创建对象或调用方法的时候才去明确的特殊的类型

3 泛型类和泛型方法的示例

  • 泛型类的定义
 
 
 
 
    
  
  
  
  
  1. public class MainTest { 
    2.   
  
  
  
  2.     private  T param; 
    3.   
  
  
  
  3. } 
    4.   
  
  
  
  4. public static void main(String[] args){ 
    5.   
  
  
  
  5.         MainTest data = new MainTest(){}; 
    6.   
  
  
  
  6.         ParameterizedType genType1 = (ParameterizedType)data.getClass().getGenericSuperclass(); 
    7.   
  
  
  
  7.   } 
    8.
  • 泛型方法的定义
 
 
 
 
    
  
  
  
  
  1. public class MainTest{ 
    2.   
  
  
  
  2.     public static void main(String[] args){ 
    3.   
  
  
  
  3.         printData("siting"); 
    4.   
  
  
  
  4.     } 
    5.   
  
  
  
  5.     static   T printData(T t){ 
    6.   
  
  
  
  6.         System.out.println(t); 
    7.   
  
  
  
  7.         return t; 
    8.   
  
  
  
  8.     } 
    9.   
  
  
  
  9. } 
    10.

接口和抽象类都可以使用泛型

4 类型擦除

  • 创建泛型的实例时，jvm是会把具体类型擦除的;编译生成的字节码中不包含泛型中的类型参数，即ArrayList 和ArrayList 都擦除成了ArrayList，也就是被擦除成"原生类型"，这就是泛型擦除 
 
 
 
 
    
  
  
  
  
  1. public class MainTest { 
    2.   
  
  
  
  2.     public static void main(String[] args){ 
    3.   
  
  
  
  3.         List strArr  = new ArrayList<>(); 
    4.   
  
  
  
  4.         List intArr  = new ArrayList<>(); 
    5.   
  
  
  
  5.         Type strClazz = strArr.getClass(); 
    6.   
  
  
  
  6.         Type intClazz = intArr.getClass(); 
    7.   
  
  
  
  7.     } 
    8.   
  
  
  
  8. } 
    9.

  • 查看编译后的字节码文件是如何表示的: idea菜单 -> view -> show ByteCode
 
 
 
 
    
  
  
  
  
  1. public class MainTest { 
    2.   
  
  
  
  2.     T param; 
    3.   
  
  
  
  3.     public static void main(String[] args){ 
    4.   
  
  
  
  4.         MainTest test = new MainTest<>(); 
    5.   
  
  
  
  5.         test.setParam("siting"); 
    6.   
  
  
  
  6.     } 
    7.   
  
  
  
  7.     public T getParam() {  return param;   } 
    8.   
  
  
  
  8.     public void setParam(T param) {  this.param = param;  } 
    9.   
  
  
  
  9. } 
    10.   
  
  
  
  10. public class com/MainTest { 
    11.   
  
  
  
  11.   ...省略 
    12.   
  
  
  
  12.   public static main([Ljava/lang/String;)V 
    13.   
  
  
  
  13.    L0 
    14.   
  
  
  
  14.     LINENUMBER 7 L0 
    15.   
  
  
  
  15.     NEW com/MainTest 
    16.   
  
  
  
  16.     DUP 
    17.   
  
  
  
  17.     INVOKESPECIAL com/MainTest. ()V 
    18.   
  
  
  
  18.     ASTORE 1 
    19.   
  
  
  
  19.    L1 
    20.   
  
  
  
  20.     LINENUMBER 8 L1 
    21.   
  
  
  
  21.     ALOAD 1 
    22.   
  
  
  
  22.     LDC "siting"     // 调用类型擦除后的setParam(Object) 
    23.   
  
  
  
  23.     INVOKEVIRTUAL com/MainTest.setParam (Ljava/lang/Object;)V 
    24.   
  
  
  
  24.    L2 
    25.   
  
  
  
  25.    ...省略//getParam 的返回值是Object 
    26.   
  
  
  
  26.   public getParam()Ljava/lang/Object; 
    27.   
  
  
  
  27.    L0 
    28.   
  
  
  
  28.     LINENUMBER 10 L0 
    29.   
  
  
  
  29.     ALOAD 0 
    30.   
  
  
  
  30.     GETFIELD com/MainTest.param : Ljava/lang/Object; 
    31.   
  
  
  
  31.     ARETURN 
    32.   
  
  
  
  32.    ...省略//setParam 的入参是Object 
    33.   
  
  
  
  33.   public setParam(Ljava/lang/Object;)V 
    34.   
  
  
  
  34.    L0 
    35.   
  
  
  
  35.     LINENUMBER 11 L0 
    36.   
  
  
  
  36.     ALOAD 0 
    37.   
  
  
  
  37.     ALOAD 1 
    38.   
  
  
  
  38.     PUTFIELD com/MainTest.param : Ljava/lang/Object; 
    39.   
  
  
  
  39.     RETURN 
    40.   
  
  
  
  40.    ... 
    41.   
  
  
  
  41. } 
    42.

可以看出T(String)都被转换为Object类型，最初的初始化的String不见了

5 泛型的继承

  • 子类可以指定父类的泛型参数，可以是已知类(Integer、String等)，也可以用子类自己的泛型参数指定
  • 泛型被继承时，且指定父类泛型参数，则额外生成的ParameterizedType类型作为子类的父类;如果没有指定父类泛型参数，则直接继承原生类型
 
 
 
 
    
  
  
  
  
  1. public class MainTest { 
    2.   
  
  
  
  2.     T param; 
    3.   
  
  
  
  3.     static public class SubTest1 extends MainTest{} 
    4.   
  
  
  
  4.     static public class SubTest2 extends MainTest{} 
    5.   
  
  
  
  5.     //SubTest3继承的时原生类型 
    6.   
  
  
  
  6.     static public class SubTest3 extends MainTest{} 
    7.   
  
  
  
  7. } 
    8.

6 泛型变量TypeVariable

  • (先临时定义一个名称，Test 里的E为泛型参数);泛型变量TypeVariable：泛型的泛型参数就是TypeVariable;当父类使用子类的泛型参数指定自身的泛型参数时;或者泛型属性定义在泛型类A 中，并使用泛型类A 的泛型参数T时，其泛型参数都会被编译器定为泛型变量TypeVariable，而不是被擦除 
 
 
 
 
    
  
  
  
  
  1. public class MainTest { 
    2.   
  
  
  
  2.     List param; 
    3.   
  
  
  
  3.     public static void main(String[] args) throws Exception{ 
    4.   
  
  
  
  4.         Class clazz =  MainTest.class; 
    5.   
  
  
  
  5.         TypeVariable[] typeVariable = clazz.getTypeParameters(); 
    6.   
  
  
  
  6.         // 1 
    7.   
  
  
  
  7.         Field field = clazz.getDeclaredField("param"); 
    8.   
  
  
  
  8.         ParameterizedType arrayType = (ParameterizedType)field.getGenericType(); 
    9.   
  
  
  
  9.         // interface List 的泛型类型E被T,具体化，因此其被识别为 TypeVariable 
    10.   
  
  
  
  10.         TypeVariable variable1 = (TypeVariable)arrayType.getActualTypeArguments()[0]; 
    11.   
  
  
  
  11.         // 2 
    12.   
  
  
  
  12.         ParameterizedType type = (ParameterizedType)SubTest.class.getGenericSuperclass(); 
    13.   
  
  
  
  13.         TypeVariable variable2 = (TypeVariable)type.getActualTypeArguments()[0]; 
    14.   
  
  
  
  14.     } 
    15.   
  
  
  
  15.     static class SubTest extends MainTest{} 
    16.   
  
  
  
  16. } 
    17.

7 参数化类型ParameterizedType

 
 
 
 
    
  
  
  
  
  1. public interface ParameterizedType extends Type { 
    2.   
  
  
  
  2.     //获取实际参数，List里的String; 如果是List则是TypeVariable类型 
    3.   
  
  
  
  3.     Type[] getActualTypeArguments();  
    4.   
  
  
  
  4.     // 获取原始类型List -> List 
    5.   
  
  
  
  5.     Type getRawType();   
    6.   
  
  
  
  6.     Type getOwnerType(); 
    7.   
  
  
  
  7. } 
    8.
  • 需要注意的点，我们不能直接获取指定具体参数的泛型的类型，如Class clazz = List .class编译时不通过的;还有就是直接通过泛型类new创建的对象，其Class并非ParameterizedType类型，而是泛型本身的class，示例如下 
 
 
 
 
    
  
  
  
  
  1. public class MainTest { 
    2.   
  
  
  
  2.     public static void main(String[] args){ 
    3.   
  
  
  
  3.         MainTest str = new MainTest(); 
    4.   
  
  
  
  4.         Class variable = str.getClass(); 
    5.   
  
  
  
  5.         Type genType1 = variable.getGenericSuperclass(); 
    6.   
  
  
  
  6.     } 
    7.   
  
  
  
  7. } 
    8.

  • 被具体参数化的泛型才能被编译器识别为ParameterizedType类型，有三种方式获取ParameterizedType类型
 
 
 
 
    
  
  
  
  
  1. // 1 子类继承泛型时，指定具体参数（可以是String等已知类型,也可以是子类的泛型参数） 
    2.   
  
  
  
  2. // 2 获取在类内部定义的泛型属性，需指定具体泛型参数 
    3.   
  
  
  
  3. // 3 局部代码，可以通过泛型的匿名内部子类(需指定具体泛型参数)获取ParameterizedType类型 
    4.   
  
  
  
  4. public class MainTest { 
    5.   
  
  
  
  5.     List list; 
    6.   
  
  
  
  6.     public static void main(String[] args) throws NoSuchFieldException { 
    7.   
  
  
  
  7.         SubTest str = new SubTest<>(); 
    8.   
  
  
  
  8.         // 方式一 
    9.   
  
  
  
  9.         Class variable = str.getClass(); 
    10.   
  
  
  
  10.         // 父类是(521)ParameterizedType类型 
    11.   
  
  
  
  11.         ParameterizedType genType = (ParameterizedType)variable.getGenericSuperclass(); 
    12.   
  
  
  
  12.         // (521)ParameterizedType类型的原生类型是（479）class com.MainTest 
    13.   
  
  
  
  13.         Type clazz = genType.getRawType(); 
    14.   
  
  
  
  14.         //MainTest.class 的原生类型是 （479）class com.MainTest 
    15.   
  
  
  
  15.         Class rawClazz = MainTest.class; 
    16.   
  
  
  
  16.  
    17.   
  
  
  
  17.         //方式二，泛型属性 
    18.   
  
  
  
  18.         Field field = rawClazz.getDeclaredField("list"); 
    19.   
  
  
  
  19.         //属性list 类型是(546)ParameterizedType类型List 
    20.   
  
  
  
  20.         ParameterizedType fieldType = (ParameterizedType)field.getGenericType(); 
    21.   
  
  
  
  21.  
    22.   
  
  
  
  22.         // 方式三 
    23.   
  
  
  
  23.         MainTest sub3 = new MainTest(){}; 
    24.   
  
  
  
  24.         // clazz3是匿名子类 
    25.   
  
  
  
  25.         Class clazz3 =  sub3.getClass(); 
    26.   
  
  
  
  26.         //父类是(555)ParameterizedType类型 
    27.   
  
  
  
  27.         ParameterizedType genType3 = (ParameterizedType) clazz3.getGenericSuperclass(); 
    28.   
  
  
  
  28.         // (555)ParameterizedType类型的原生类型是（479）class com.MainTest 
    29.   
  
  
  
  29.         Type type3 = genType3.getRawType(); 
    30.   
  
  
  
  30.     } 
    31.   
  
  
  
  31.     public static class SubTest extends MainTest{ } 
    32.   
  
  
  
  32. } 
    33.

8 通配符(WildcardType)

无边界通配符：无界通配符 ? 可以适配任何引用类型:

  • 当方法参数需要传入一个泛型时，而且无法确定其类型时。直接使用无具体泛型变量的泛型，容易造成安全隐患;若在方法代码里进行类型转换，极容易出现ClassCastException错误
  • 那泛型变量用Object代替不就行了?但是泛型类+具体参数转变的ParameterizedType(参数化类型)是不存在继承关系;即Object是String的父类，但是List 和List 的类型是不同的两个ParameterizedType，不存在继承关系。于是有了类型通配符 ? 
 
 
 
 
    
  
  
  
  
  1. public static void print(List list){}  
    2.   
  
  
  
  2. ----->>> 
    3.   
  
  
  
  3. public static void print(List list){}  
    4.

  • 无界通配符可以匹配任意类型;但是在使用?时，不能给泛型类的变量设置值，因为我们不知道具体类型是什么;如果强行设置新值，后面的读容易出现ClassCastException错误。因此编译器限制了**通配符 ?**的泛型只能读不能写

上界限定通配符 < ? extends E>

  • 想接收一个List集合，它只能操作数字类型的元素【Float、Integer、Double、Byte等数字类型都行】，怎么做?可以使用List ，表明List里的元素都是Number的子类
    •   
  
  
  
      
   
   
   
   
    1. public static void print(List list) { 
      2.    
   
   
   
    2.         Number n = new Double("1.0"); 
      3.    
   
   
   
    3.         list.add(n); 
      4.    
   
   
   
    4.         Number tmp = list.get(0); 
      5.    
   
   
   
    5.     } 
      6.

  • 图片里可以看出，存在上界通配符，因为具体类型不确定，也是只能读不能写的

下界限定通配符 < ? super E>

 
 
 
 
    
  
  
  
  
  1. class Parent{ } 
    2.   
  
  
  
  2. class Child extends Parent{ } 
    3.   
  
  
  
  3. public class MainTest { 
    4.   
  
  
  
  4.     T param; 
    5.   
  
  
  
  5.     public static void main(String[] args){ 
    6.   
  
  
  
  6.         MainTest parent_m = new MainTest<>(); 
    7.   
  
  
  
  7.         parent_m.setParam(new Child()); 
    8.   
  
  
  
  8.         Object parent = parent_m.getParam(); 
    9.   
  
  
  
  9.     } 
    10.   
  
  
  
  10.     public T getParam() {  return param;  } 
    11.   
  
  
  
  11.     public void setParam(T param) {  this.param = param; } 
    12.   
  
  
  
  12. } 
    13.

  • 如果定义了通配符是谁的父类，则是下界限定通配符;此类通配符可读可写，转成任意父类都不会出现ClassCastException错误。
  • 个人猜想：难道是因为通配符和上界限定通配符的泛型 向下转型容易出现ClassCastException错误，而下界限定通配符向上转型不会出现ClassCastException错误，因此java规范限制前者编译出错，而后面编译通过?

9 泛型数组(GenericArrayType)

 
 
 
 
    
  
  
  
  
  1. public interface GenericArrayType extends Type { 
    2.   
  
  
  
  2.     //获得这个数组元素类型，即获得：A（A[]）或  T（T[]） 
    3.   
  
  
  
  3.     Type getGenericComponentType(); 
    4.   
  
  
  
  4. } 
    5.
  • GenericArrayType，泛型数组，描述的是ParameterizedType类型以及TypeVariable类型数组，即形如：Test [][]、T[]等，是GenericArrayType的子接口 
 
 
 
 
    
  
  
  
  
  1. public class MainTest { 
    2.   
  
  
  
  2.     T[] param; 
    3.   
  
  
  
  3.     public static void main(String[] args) throws Exception{ 
    4.   
  
  
  
  4.         Class clazz =  MainTest.class; 
    5.   
  
  
  
  5.         Field field = clazz.getDeclaredField("param"); 
    6.   
  
  
  
  6.         GenericArrayType arrayType = (GenericArrayType)field.getGenericType(); 
    7.   
  
  
  
  7.         TypeVariable variable = (TypeVariable) arrayType.getGenericComponentType(); 
    8.   
  
  
  
  8.     } 
    9.   
  
  
  
  9. } 
    10.

网站栏目：基础篇：深入解析Java泛型
当前地址：http://www.shufengxianlan.com/qtweb/news45/156695.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

品牌网站制作知识

分类信息网站

成都定制网站　　 　成都网站设计　　 　重庆服务器托管　　 　四川主机托管　　 　网站设计公司　　 　网络推广公司　　 　内江智速网站建设　　 　香港云虚拟主机　　 　网站设计　　 　川西大数据中心　　 　堡垒主机　　 　网站建设　　 　营销网站建设　　 　新网创想　　 　成都定制网站建设　　 　崇州做网站　　 　成都展柜制作　　 　产品包装设计　　 　成都手机网站报价　　 　网络口碑营销