JAVA 类型(Type)

Type

/*
 * Type is the common superinterface for all types in the Java
 * programming language. These include raw types, parameterized types,
 * array types, type variables and primitive types.
 */

Type 是java所有类型的通用高级父接口,可以描述以下类型:

  • row types(原始类型): 一般类、抽象类、接口、枚举 都属于该类型
  • parameterized types(参数化类型):List<String> 、Map<String,Integer>、Collection<E>
  • array types(数组):数组
  • type variables(类型变量): T a
  • primitive types(基本类型):java虽然是面向对象的,但是也包含了C中的基本类型。同样基本类型也有对应的Class,本质上来说也属于row types。 int -> int.class

在java.lang.reflect包下存在如下四个子接口:

  • ParameterizedType
  • GenericArrayType
  • TypeVariable
  • WildcardType

除此之外还存在一个实现类型 Class。

Type接口只有一个默认的方法 getTypeName,默认实现是调用toString 方法。

    /**
     * Returns a string describing this type, including information
     * about any type parameters.
     *
     * @implSpec The default implementation calls {@code toString}.
     *
     * @return a string describing this type
     * @since 1.8
     */
 default String getTypeName() {
        return toString();
 }

该方法返回一个描述类型参数的字符串。

反射和泛型

在java程序中存在两种类型,编译时类型和运行时类型。

  1. 如果在编译和运行时完全知道类型的具体信息,那么可以通过instanceof 进行判断,并进行类型的强转就可以了。
  2. 如果只有在运行时才知道具体的类型,那么只能通过反射来获取对象和类的真实信息。

对于一批就有类似功能并且实现方式也相似的类来说,获取到泛型的实际类型参数 进行批量处理这类请求是很好的选择。 如何获取到泛型参数的类型,就需要借助反射来完成

通过指定类对应的Class对象,程序可以获得该类里包括的所有Field。获取到Filed对象后,就可以获取到了Filed 的数据类型。

//获取Filed对象f的类型
Class<?> type = f.getType();

但是通过这种方式只对普通的类型有效,如果该Filed的类型包含泛型,该方式就不能精确的获取该Filed的泛型参数。
为了获取指定Filed的泛型类型,可以通过方法 getGenericType获取。

Type<?> type = f.getGenericType();

=============================================================

某些错误操作是无法获取到泛型实际类型参数信息的。

  • 获取带泛型的类的类型

    // 编译错误
    Class lstUClazz = List<User>.class
    
  • instanceof

    // 编译错误
    //Illegal generic type for instanceof
     if( list instanceof List<String>)
    
  • 获取局部变量泛型的类型

    List<String> listUser = new ArrayList<String>();
    Type genType = listUser.getClass().getGenericSuperclass();
    
    if (genType instanceof ParameterizedType) {
          ParameterizedType parameterizedType = (ParameterizedType) genType;
          Arrays.stream(parameterizedType.getActualTypeArguments()).forEach(type -> {
              if(type instanceof TypeVariable){
                  System.out.println("TypeVariable  " + type);
              }
          });
          System.out.println(parameterizedType.getRawType());
    }
    

    TypeVariable E
    class java.util.AbstractList

如果想要获取到实际类型参数,需要满足那些条件呢?

必须具有泛型定义,并且指定类型实参。比如 List接口就是带有泛型定义的类型,List<String> user 就是指明了类型实参,如果没有指明(List<T>)否则只能源码期 定义的类型变量(T,E)

存在以下三种方式可以获取到类型实参

  1. 通过继承方式,明确类型,然后获取泛型类

    
    
  2. 获取类属性的泛型类型(属性、方法参数)

    public class Test extends ClassA<String> { 
      private List<String> list; 
      /*** 
       * 获取List中的泛型 
       */
      public static void testList() throws NoSuchFieldException, SecurityException { 
        Type t = Test.class.getDeclaredField("list").getGenericType(); 
        if (ParameterizedType.class.isAssignableFrom(t.getClass())) { 
          for (Type t1 : ((ParameterizedType) t).getActualTypeArguments()) { 
            System.out.print(t1 + ","); 
          } 
          System.out.println(); 
        } 
      } 
    } 
    
  3. 获取局部变量的泛型的类型,本质就是继承

    List<User> listUser= new ArrayList<User>(){};
    Type genType = listUser.getClass().getGenericSuperclass();
    

获取泛型类型

1. Class

class 中存在两个两个获取泛型的信息的方法。一个用于获取接口上的泛型信息一个用于获取父类上的注解信息

public Type getGenericInterfaces();

public Type getGenericSuperclass ();
public class EventHandlerProcessor {

    /**
     * 判断是否可以处理该请求
     * @param eventHandler
     * @return
     */
    public boolean canApply(EventHandler eventHandler){
        Type[] genericInterface =  eventHandler.getClass().getGenericInterfaces();
        for(Type type : genericInterface){
            if(type instanceof ParameterizedType){
                ParameterizedType parameterizedType  = (ParameterizedType) type;
                Type eventType = parameterizedType.getActualTypeArguments()[0];
                if(Event.class.isAssignableFrom((Class<?>) eventType)){
                 return true;
                }
            }
        }
        return false;
    }

    /**
     * 具体处理逻辑
     * @param eventHandler
     */
    public void process(EventHandler eventHandler){

    }
}

定义事件

public interface Event {
    public String getName();
    public String getCategory();
}


public class NameModifyEvent implements Event {

    @Override
    public String getName() {
        return "名称修改";
    }

    @Override
    public String getCategory() {
        return "MODIFY";
    }
}

自定义Event 处理

public interface EventHandler<T> {
    /**
     * 事件处理方法
     */
    public void handler(T event);
}

public class ModifyEventHandler implements EventHandler<Event> {
    @Override
    public void handler(Event event) {
        System.out.println("修改事件");
    }
}
2.ParameterizedType 参数化类型

ParameterizedType 表示参数化类型。上面说过,java引入了“参数化类型”的概念,java的参数化类型被称为泛型(Generic)。所以说对于所有的泛型(使用了 <>) 对应的Type都是ParameterizedType 。

List<String> str = new ArrayList<>;
Class<E> cls = null;

ParameterizedType 具有以下三个方法:
在这里插入图片描述

  1. Type[] getActualTypeArguments();
    传入实际的类型参数(类型实参),因为可能会存在多个类型形参,所以返回一个数组(比如:Map<String,Object>)。
  2. Type getRawType();
    返回一个类型对象,该类型对象表示声明该类型的类或接口。简单的说就是 <> 前面的类型。
  3. Type getOwnerType();
    返回一个类型对象,该对象表示该类型所属的类型,不存在则返回null。比如: Map.Entry<String,Integer>的所属类型就是Map 。
public class ParameterizedTypeTest {
	// 属性
    private List list;
    private List<?> commonList;
    private List<String> stringList;
    private Map map;
    private Map<String,Object> stringObjectMap;
    private List<Map<String,Object>> mapList;

    public static void main(String[] args) throws NoSuchFieldException {
        ParameterizedTypeTest obj = new ParameterizedTypeTest();
        Class cls = obj.getClass();

        Field[] fields = cls.getDeclaredFields();
        for (Field field :fields){
            System.out.println("属性名:\t"+field.getName());
            System.out.println("class类型\t" +field.getType().getClass());
            Type genericType = field.getGenericType();
            System.out.println("泛型类型:\t" +genericType.getClass());
            System.out.println("泛型类型名称:\t" +genericType.getTypeName());
            parseParameterizedType(genericType);
            System.out.println("========================================================\n");
        }
    }
	
	// 泛型解析
   private static void parseParameterizedType(Type genericType){
   		// 如果是一个泛型对象
        if(ParameterizedType.class.isInstance(genericType)){
            System.out.println("\t\t\t----------泛型类型参数-------\t\t\t");
            ParameterizedType parameterizedType = (ParameterizedType) genericType;
            //获取泛型的实际类型(不带<>的类型)
            System.out.println("rowType:\t\t\t\t" +parameterizedType.getRawType());
            System.out.println("ownerType:\t\t\t\t"+ parameterizedType.getOwnerType());
            
			//获取类型实参
            Type[] actualTypes = parameterizedType.getActualTypeArguments();

            for (Type type: actualTypes){
                System.out.println("class类型:\t"+type.getClass());
                System.out.println("类型名称:\t "+type.getTypeName());
                parseParameterizedType(type);
            }
        }
    }
}

输出结果如下:

属性名:	list
class类型	class java.lang.Class
泛型类型:	class java.lang.Class
泛型类型名称:	java.util.List
========================================================

属性名:	commonList
class类型	class java.lang.Class
泛型类型:	class sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl
泛型类型名称:	java.util.List<?>
			----------泛型类型参数-------			
rowType:				interface java.util.List
ownerType:				null
class类型:	class sun.reflect.generics.reflectiveObjects.WildcardTypeImpl
类型名称:	 ?
========================================================

属性名:	stringList
class类型	class java.lang.Class
泛型类型:	class sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl
泛型类型名称:	java.util.List<java.lang.String>
			----------泛型类型参数-------			
rowType:				interface java.util.List
ownerType:				null
class类型:	class java.lang.Class
类型名称:	 java.lang.String
========================================================

属性名:	map
class类型	class java.lang.Class
泛型类型:	class java.lang.Class
泛型类型名称:	java.util.Map
========================================================

属性名:	stringObjectMap
class类型	class java.lang.Class
泛型类型:	class sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl
泛型类型名称:	java.util.Map<java.lang.String, java.lang.Object>
			----------泛型类型参数-------			
rowType:				interface java.util.Map
ownerType:				null
class类型:	class java.lang.Class
类型名称:	 java.lang.String
class类型:	class java.lang.Class
类型名称:	 java.lang.Object
========================================================

属性名:	mapList
class类型	class java.lang.Class
泛型类型:	class sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl
泛型类型名称:	java.util.List<java.util.Map<java.lang.String, java.lang.Object>>
			----------泛型类型参数-------			
rowType:				interface java.util.List
ownerType:				null
class类型:	class sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl
类型名称:	 java.util.Map<java.lang.String, java.lang.Object>
			----------泛型类型参数-------			
rowType:				interface java.util.Map
ownerType:				null
class类型:	class java.lang.Class
类型名称:	 java.lang.String
class类型:	class java.lang.Class
类型名称:	 java.lang.Object
========================================================

从上面的demo可以总结出以下点:

  1. 不带类型参数的泛型,其 filed.getGenericType 方法返回结果就是 Class类型(Class 是Type的实现类)。

  2. 带有泛型参数的类型(使用了 <>), filed.getGenericType 返回类型一定是 ParameterizedType (实现类ParameterizedTypeImpl)

  3. 调用方法 getActualTypeArguments(),每次只返回脱去最外层<>的类型。
    比如上面的代码:List<Map<String,Object>>,第一次调用返回 Map<String,Object>,第二次调用返回 包含key,value类型的数组。

  4. getActualTypeArguments方法返回一个Type 数组,此时根据不同的泛型定义会返回不同的实现类。

    使用泛型定义的类型,第一次调用 getActualTypeArguments 方法会有以下对应关系

    List<String> // Class
    List<T> // TypeVariableImpl
    List<?> // WildcardTypeImpl
    List<Map<String,Object>> //ParameterizedTypeImpl
    Map<String,Integer> // Class,Class
    Map<String,?> // Class , WildcardTypeImpl
    
3. TypeVariable 类型变量类型

泛型信息在编译时会被转换为一个特定的类型, 而TypeVariable就是用来反映在JVM编译该泛型前的信息。

TypeVariable 是所有类型变量(类型形参)的父接口。

类型变量是指定义类型时指定的形如 E,T,K,V等 类型形参。比如: List<T>, Map<String,T> ,T[], <T ? extends xx>

TypeVariable 具有以下四个方法(getAnnotatedBounds 是 JDK1.8新增的):
在这里插入图片描述

  1. getName
    返回在源码中该类型变量的名称。
  2. getBounds
    获取类型变量的上界。 如果没有明确的指定上界,默认为Object。 比如:<T extends Number> 形参T的上界为 Number,List<T>上界为Object。
    返回数组是因为,类型形参可以设定多个上界(至多一个父类上限,多个接口上限)
  3. getGenericDeclaration
    返回GenericDeclaration对象,该对象表示声明此类型变量的泛型声明。
  4. getAnnotatedBounds
GenericDeclaration

用于声明类型变量的所有实体的公共接口。
在这里插入图片描述
在java.lang 包下 GenericDeclaration存在如下3个实现类:

  1. Class
  2. Method
  3. Constructor(其中Method、Constructor 是通过接口Executable实现GenericDeclaration)。

换句话说只能在类(接口)、方法和构造器定义时声明类型变量(形参)。

该接口只有一个方法
在这里插入图片描述

public class TypeVariableTest<T> {
    private List list2 = null; //普通引用类型 Class
    private List<T> list = null;//带有类型形参的 泛型
    private Map<String, T> map = null;//带有类型实参和形参的泛型

    public static void main(String[] args) {
        TypeVariableTest<String> obj = new TypeVariableTest<>();
        Class cls = obj.getClass();

        Field[] fields = cls.getDeclaredFields();
        for (Field field :fields){
            System.out.println("属性名:\t"+field.getName());
            System.out.println("class类型\t" +field.getType().getClass());
            Type genericType = field.getGenericType();
            System.out.println("泛型类型:\t" +genericType.getClass());
            System.out.println("泛型类型名称:\t" +genericType.getTypeName());
            parseType(genericType);
            System.out.println("========================================================\n");
        }
    }

    private static void parseType(Type genericType) {
        if (ParameterizedType.class.isInstance(genericType)) {
            System.out.println("\t\t\t----------ParameterizedType-------\t\t\t");
            ParameterizedType parameterizedType = (ParameterizedType) genericType;
            System.out.println("rowType:\t\t\t\t" + parameterizedType.getRawType());
            System.out.println("ownerType:\t\t\t\t" + parameterizedType.getOwnerType());
            Type[] actualTypes = parameterizedType.getActualTypeArguments();

            for (Type type : actualTypes) {
                System.out.println("class类型:\t" + type.getClass());
                System.out.println("类型名称:\t " + type.getTypeName());
                parseType(type);
            }
        } else if (WildcardType.class.isInstance(genericType)) {
            System.out.println("\t\t\t----------WildcardType-------\t\t\t");
            WildcardType wildcardType = (WildcardType) genericType;
            System.out.println("上界:\t\t\t" + Arrays.toString(wildcardType.getUpperBounds()));
            System.out.println("下界:\t\t\t" + Arrays.toString(wildcardType.getLowerBounds()));
        }else if(TypeVariable.class.isInstance(genericType)){
            System.out.println("\t\t\t----------TypeVariable-------\t\t\t");
            TypeVariable typeVariable = (TypeVariable) genericType;
            System.out.println("类型变量名称:\t\t\t"+typeVariable.getName());
            System.out.println("类型上界:\t\t\t"+Arrays.toString(typeVariable.getBounds()));
            System.out.println("类型定义:\t\t\t"+typeVariable.getGenericDeclaration());
        }
    }
}

输出结果:

属性名:	list2
class类型	class java.lang.Class
泛型类型:	class java.lang.Class
泛型类型名称:	java.util.List
========================================================

属性名:	list
class类型	class java.lang.Class
泛型类型:	class sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl
泛型类型名称:	java.util.List<T>
			----------ParameterizedType-------			
rowType:				interface java.util.List
ownerType:				null
class类型:	class sun.reflect.generics.reflectiveObjects.TypeVariableImpl
类型名称:	 T
			----------TypeVariable-------			
类型变量名称:			T
类型上界:			[class java.lang.Object]
类型定义:			class com.example.netty.TypeVariableTest
========================================================

属性名:	map
class类型	class java.lang.Class
泛型类型:	class sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl
泛型类型名称:	java.util.Map<java.lang.String, T>
			----------ParameterizedType-------			
rowType:				interface java.util.Map
ownerType:				null
class类型:	class java.lang.Class
类型名称:	 java.lang.String
class类型:	class sun.reflect.generics.reflectiveObjects.TypeVariableImpl
类型名称:	 T
			----------TypeVariable-------			
类型变量名称:			T
类型上界:			[class java.lang.Object]
类型定义:			class com.example.netty.TypeVariableTest
========================================================

该类型实参是在声明类时指定的所以方法getGenericDeclaration返回的 类型是Class。

4.GenericArrayType 泛型数组类型

当数组定义使用类型变量或者参数化类型,那么此Type类型就为GenericArrayType。

该接口只有一个方法:
在这里插入图片描述

当需要描述的类型是泛型类的数组时,比如比如List[],Map[],type会用GenericArrayType接口作为Type的实现。

  1. getGenericComponentType() 获取数组元素的Type类型。
public class GenericArrayTypeTest<T>{
    private List[] lists;//普通数组
    private List<String>[] strList; //参数化类型数组
    private T[]  ts;// 类型变量数组
    private T[][] tArrays;//类型变量二维数组
    
    public static void main(String[] args) {
        GenericArrayTypeTest obj = new GenericArrayTypeTest();
        Class cls = obj.getClass();

        Field[] fields = cls.getDeclaredFields();
        for (Field field :fields){
            System.out.println("属性名:\t"+field.getName());
            System.out.println("class类型\t" +field.getType().getClass());
            Type genericType = field.getGenericType();
            System.out.println("泛型类型:\t" +genericType.getClass());
            System.out.println("泛型类型名称:\t" +genericType.getTypeName());
            parseType(genericType);
            System.out.println("========================================================\n");
        }
    }

    private static void parseType(Type genericType){
        if(ParameterizedType.class.isInstance(genericType)){
            System.out.println("\t\t\t----------ParameterizedType-------\t\t\t");
            ParameterizedType parameterizedType = (ParameterizedType) genericType;
            System.out.println("rowType:\t\t\t\t" +parameterizedType.getRawType());
            System.out.println("ownerType:\t\t\t\t"+ parameterizedType.getOwnerType());
            Type[] actualTypes = parameterizedType.getActualTypeArguments();

            for (Type type: actualTypes){
                System.out.println("class类型:\t"+type.getClass());
                System.out.println("类型名称:\t "+type.getTypeName());
                parseType(type);
            }
        }else if(TypeVariable.class.isInstance(genericType)){
            System.out.println("\t\t\t----------TypeVariable-------\t\t\t");
            TypeVariable typeVariable = (TypeVariable) genericType;
            System.out.println("类型变量名称:\t\t\t"+typeVariable.getName());
            System.out.println("类型上界:\t\t\t"+ Arrays.toString(typeVariable.getBounds()));
            System.out.println("类型定义:\t\t\t"+typeVariable.getGenericDeclaration());
        }else if(GenericArrayType.class.isInstance(genericType)){
            System.out.println("\t\t\t----------GenericArrayType-------\t\t\t");
            GenericArrayType genericArrayType = (GenericArrayType) genericType;
            Type type = genericArrayType.getGenericComponentType();
            System.out.println(type.getClass());
            System.out.println(type);
            parseType(type);
        }
    }
}

输出结果:

属性名:	lists
class类型	class java.lang.Class
泛型类型:	class java.lang.Class
泛型类型名称:	java.util.List[]
========================================================

属性名:	strList
class类型	class java.lang.Class
泛型类型:	class sun.reflect.generics.reflectiveObjects.GenericArrayTypeImpl
泛型类型名称:	java.util.List<java.lang.String>[]
			----------GenericArrayType-------			
class sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl
java.util.List<java.lang.String>
			----------ParameterizedType-------			
rowType:				interface java.util.List
ownerType:				null
class类型:	class java.lang.Class
类型名称:	 java.lang.String
========================================================

属性名:	ts
class类型	class java.lang.Class
泛型类型:	class sun.reflect.generics.reflectiveObjects.GenericArrayTypeImpl
泛型类型名称:	T[]
			----------GenericArrayType-------			
class sun.reflect.generics.reflectiveObjects.TypeVariableImpl
T
			----------TypeVariable-------			
类型变量名称:			T
类型上界:			[class java.lang.Object]
类型定义:			class com.example.netty.GenericArrayTypeTest
========================================================

属性名:	tArrays
class类型	class java.lang.Class
泛型类型:	class sun.reflect.generics.reflectiveObjects.GenericArrayTypeImpl
泛型类型名称:	T[][]
			----------GenericArrayType-------			
class sun.reflect.generics.reflectiveObjects.GenericArrayTypeImpl
T[]
			----------GenericArrayType-------			
class sun.reflect.generics.reflectiveObjects.TypeVariableImpl
T
			----------TypeVariable-------			
类型变量名称:			T
类型上界:			[class java.lang.Object]
类型定义:			class com.example.netty.GenericArrayTypeTest
========================================================

从上面的结果可以看出:参数化类型和 类型变量数组返回的类型才是GenericArrayTypeImpl。调用getGenericType方法普通的数组对象返回Type 同样是 Class类型。

和方法getActualTypeArguments类似的是 getGenericComponentType方法每次只会脱去最外层的[].

5.WildcardType 通配符类型

当泛型中存在通配符时(?, ? extends xx,? super xxx),此时类型为WildcardType(实现类WildcardTypeImpl
该接口只有如下两个方法,用于获取泛型的上界和下界
在这里插入图片描述

  1. getUpperBounds(extends)。 获取类型通配符的上界 如果没有明确指定,那么上界为Object
  2. getLowerBounds(supper) 。 获取类型通配符的下界,如果没有明确指定下界那么下界为null,返回空数组。
public class WildcardTypeTest{
    private List<?> commonList;
    private List<? extends Number> superList;
    private List<? super Integer> lowerList;

    public static void main(String[] args) {
        WildcardTypeTest obj = new WildcardTypeTest();
        Class cls = obj.getClass();

        Field[] fields = cls.getDeclaredFields();
        for (Field field :fields){
            System.out.println("属性名:\t"+field.getName());
            System.out.println("class类型\t" +field.getType().getClass());
            Type genericType = field.getGenericType();
            System.out.println("泛型类型:\t" +genericType.getClass());
            System.out.println("泛型类型名称:\t" +genericType.getTypeName());
            parseType(genericType);
            System.out.println("========================================================\n");
        }
    }

   private static void parseType(Type genericType){
        if(ParameterizedType.class.isInstance(genericType)){
            System.out.println("\t\t\t----------ParameterizedType-------\t\t\t");
            ParameterizedType parameterizedType = (ParameterizedType) genericType;
            System.out.println("rowType:\t\t\t\t" +parameterizedType.getRawType());
            System.out.println("ownerType:\t\t\t\t"+ parameterizedType.getOwnerType());
            Type[] actualTypes = parameterizedType.getActualTypeArguments();

            for (Type type: actualTypes){
                System.out.println("class类型:\t"+type.getClass());
                System.out.println("类型名称:\t "+type.getTypeName());
                parseType(type);
            }
        }else if(WildcardType.class.isInstance(genericType)){
            System.out.println("\t\t\t----------WildcardType-------\t\t\t");
            WildcardType wildcardType = (WildcardType) genericType;
            System.out.println("上界:\t\t\t"+ Arrays.toString(wildcardType.getUpperBounds()));
            System.out.println("下界:\t\t\t"+Arrays.toString(wildcardType.getLowerBounds()));
        }
    }
}

输出结果:

属性名:	commonList
class类型	class java.lang.Class
泛型类型:	class sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl
泛型类型名称:	java.util.List<?>
			----------ParameterizedType-------			
rowType:				interface java.util.List
ownerType:				null
class类型:	class sun.reflect.generics.reflectiveObjects.WildcardTypeImpl
类型名称:	 ?
			----------WildcardType-------			
上界:			[class java.lang.Object]
下界:			[]
========================================================

属性名:	superList
class类型	class java.lang.Class
泛型类型:	class sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl
泛型类型名称:	java.util.List<? extends java.lang.Number>
			----------ParameterizedType-------			
rowType:				interface java.util.List
ownerType:				null
class类型:	class sun.reflect.generics.reflectiveObjects.WildcardTypeImpl
类型名称:	 ? extends java.lang.Number
			----------WildcardType-------			
上界:			[class java.lang.Number]
下界:			[]
========================================================

属性名:	lowerList
class类型	class java.lang.Class
泛型类型:	class sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl
泛型类型名称:	java.util.List<? super java.lang.Integer>
			----------ParameterizedType-------			
rowType:				interface java.util.List
ownerType:				null
class类型:	class sun.reflect.generics.reflectiveObjects.WildcardTypeImpl
类型名称:	 ? super java.lang.Integer
			----------WildcardType-------			
上界:			[class java.lang.Object]
下界:			[class java.lang.Integer]
========================================================
小结

Type 是所有类型的通用父接口,其中带有泛型的元素
在这里插入图片描述

Type的实现类

  • 在java.lang.reflect包下存在如下四个子接口:
    • ParameterizedType (所有的泛型 <>
    • GenericArrayType (泛型数组,数组元素是 parameterized typetype variable)
    • TypeVariable (类型变量)
    • WildcardType(有统配的泛型 ?)
  • Class

参考文献:

  1. 疯狂java讲义
  2. Java 获取泛型的类型实例详解
相关推荐
©️2020 CSDN 皮肤主题: 游动-白 设计师:白松林 返回首页