Java Type类

旧城等待， 2024-03-27 16:56 55阅读 0赞

#### 文章目录 ####

*  Type简介
 *  Type分类
 *   *  1. 原始类型(Class)
     *  2. 参数化类型(ParameterizedType)
     *  3. 类型变量(TypeVariable)
     *  4. 通配符类型(WildcardType)
     *  5. 泛型数组类型(GenericArrayType)

--------------------

## Type简介 ##

Type是Java编程语言中所有类型的公共高级接口。它们包括原始类型、参数化类型、数组类型、类型变量和基本类型。

Type接口本身算是一个标记接口，不提供任何需要复写的方法。

## Type分类 ##

![在这里插入图片描述][0645fe0c17224455b72f28d66f3cff9b.png]

**Type分类：**

<table> 
 <thead> 
 <tr> 
 <th align="left">Type分类名称</th> 
 <th align="left">Type类型</th> 
 <th align="left">描述</th> 
 <th align="left">举例</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td align="left">原始类型</td> 
 <td align="left">Class</td> 
 <td align="left">Java类、枚举、数组、注解、所有基本数据类型</td> 
 <td align="left">String、Date、Integer、int、boolean 等</td> 
 </tr> 
 <tr> 
 <td align="left">参数化类型</td> 
 <td align="left">ParameterizedType</td> 
 <td align="left">参数化类型（泛型类型）</td> 
 <td align="left">List&lt;String&gt;、Map&lt;Integer,String&gt;、List&lt;T&gt;、List&lt;?&gt;、List&lt;? extends Number&gt;、List&lt;? super Number&gt; 等</td> 
 </tr> 
 <tr> 
 <td align="left">类型变量</td> 
 <td align="left">TypeVariable</td> 
 <td align="left">泛型符号（不包括通配符）</td> 
 <td align="left">T、K、V、E 等</td> 
 </tr> 
 <tr> 
 <td align="left">通配符类型</td> 
 <td align="left">WildcardType</td> 
 <td align="left">通配符</td> 
 <td align="left">?、? extends Number、? super Number 等</td> 
 </tr> 
 <tr> 
 <td align="left">泛型数组类型</td> 
 <td align="left">GenericArrayType</td> 
 <td align="left">泛型数组</td> 
 <td align="left">List&lt;?&gt;[]、List&lt;T&gt;[]、List&lt;String&gt;[]、List&lt;? extends Number&gt;[]、T[] 等</td> 
 </tr> 
 </tbody> 
</table>

**获取Type：**

JDK的Class、Field、Method类提供了一些列的获取类型的相关方法。

可参考文章：[Java中如何获取泛型类型信息][Java]

### 1. 原始类型(Class) ###

原始类型的Type实现类为Class。这个类型与泛型无关，其它4个类型都和泛型相关。

原始类型主要包括：Java类、枚举、数组、注解、所有基本数据类型。

**示例：**

public class TypeTest {
        
    
        private String string;
    
        private Integer integer;
    
        private long lon;
    
        private int[] intArr;
        
        public static void main(String[] args) throws Exception {
        
            System.out.println(TypeTest.class.getDeclaredField("string").getGenericType() instanceof Class ? "String：是原始类型" : "String：不是原始类型");
            System.out.println(TypeTest.class.getDeclaredField("integer").getGenericType() instanceof Class ? "Integer：是原始类型" : "Integer：不是原始类型");
            System.out.println(TypeTest.class.getDeclaredField("lon").getGenericType() instanceof Class ? "long：是原始类型" : "long：不是原始类型");
            System.out.println(TypeTest.class.getDeclaredField("intArr").getGenericType() instanceof Class ? "int[]：是原始类型" : "int[]：不是原始类型");
        }
    }

**输出：**

String：是原始类型
    Integer：是原始类型
    long：是原始类型
    int[]：是原始类型

### 2. 参数化类型(ParameterizedType) ###

参数化类型的Type实现类为ParameterizedType。

参数化类型也就是泛型类型。

**源码：**

public interface ParameterizedType extends Type {
        
        
        Type[] getActualTypeArguments();
        
        Type getRawType();
    
        Type getOwnerType();
    }

**方法：**

*  getActualTypeArguments：获取实际类型参数的Type集合
 *  getRawType：获取声明此类型的类或接口的Type
 *  getOwnerType：如果声明此类型的类或接口为内部类，这返回的是该内部类的外部类的Type（也就是该内部类的拥有者）

**示例：**

public class TypeTest<T> {
 
 
 private Map<Integer,String> map;
 
 private List<String> list1;
 
 private List<T> list2;
 
 private List<?> list3;
 
 private List<? extends Number> list4;
 
 public static void main(String[] args) throws Exception {
 
 System.out.println(TypeTest.class.getDeclaredField("map").getGenericType() instanceof ParameterizedType ? "Map<Integer,String>：是参数化类型" : "Map<Integer,String>：不是参数化类型");
 System.out.println(TypeTest.class.getDeclaredField("list1").getGenericType() instanceof ParameterizedType ? "List<String>：是参数化类型" : "List<String>：不是参数化类型");
 System.out.println(TypeTest.class.getDeclaredField("list2").getGenericType() instanceof ParameterizedType ? "List<T>：是参数化类型" : "List<T>：不是参数化类型");
 System.out.println(TypeTest.class.getDeclaredField("list3").getGenericType() instanceof ParameterizedType ? "List<?>：是参数化类型" : "List<?>：不是参数化类型");
 System.out.println(TypeTest.class.getDeclaredField("list4").getGenericType() instanceof ParameterizedType ? "List<? extends Number>：是参数化类型" : "List<? extends Number>：不是参数化类型");
 
 System.out.println("-----------------------------------------------------------");
 
 ParameterizedType parameterizedType = (ParameterizedType) TypeTest.class.getDeclaredField("map").getGenericType();
 for (Type actualTypeArgument : parameterizedType.getActualTypeArguments()) {
 
 System.out.println("getActualTypeArguments 方法返回值有：" + actualTypeArgument.getTypeName());
 }
 System.out.println("getRawType 方法返回值：" + parameterizedType.getRawType().getTypeName());
 System.out.println("getOwnerType 方法返回值：" + (parameterizedType.getOwnerType() != null ? parameterizedType.getOwnerType().getTypeName() : "null"));
 }
 }

**输出：**

Map<Integer,String>：是参数化类型
 List<String>：是参数化类型
 List<T>：是参数化类型
 List<?>：是参数化类型
 List<? extends Number>：是参数化类型
 -----------------------------------------------------------
 getActualTypeArguments 方法返回值有：java.lang.Integer
 getActualTypeArguments 方法返回值有：java.lang.String
 getRawType 方法返回值：java.util.Map
 getOwnerType 方法返回值：null

### 3. 类型变量(TypeVariable) ###

类型变量的Type实现类为TypeVariable。

类型变量急速指的泛型符号（不包括通配符）。  
**源码：**

public interface TypeVariable<D extends GenericDeclaration> extends Type, AnnotatedElement {
 
 
 Type[] getBounds();
 
 D getGenericDeclaration();
 
 String getName();
 
 AnnotatedType[] getAnnotatedBounds();
 }

**方法：**

*  getBounds：类型变量对应的上边界。如果没有指定上限，返回Object，可以有多个
 *  getGenericDeclaration：获取类型变量所在类的Type。
 *  getName：获取类型变量在源码中定义的名称
 *  getAnnotatedBounds：获取注解类型的上限数组

**示例：**

public class TypeTest<T> {
 
 
 private List<T> list2;
 
 private List<?> list3;
 
 private List<? extends Number> list4;
 
 public static void main(String[] args) throws Exception {
 
 System.out.println(((ParameterizedType)TypeTest.class.getDeclaredField("list2").getGenericType()).getActualTypeArguments()[0] instanceof TypeVariable ? "T：是类型变量" : "T：不是类型变量");
 System.out.println(((ParameterizedType)TypeTest.class.getDeclaredField("list3").getGenericType()).getActualTypeArguments()[0] instanceof TypeVariable ? "?：是类型变量" : "?：不是类型变量");
 System.out.println(((ParameterizedType)TypeTest.class.getDeclaredField("list4").getGenericType()).getActualTypeArguments()[0] instanceof TypeVariable ? "? extends Number：是类型变量" : "? extends Number：不是类型变量");
 
 System.out.println("---------------------------------------------------------------");
 
 TypeVariable typeVariable = (TypeVariable)((ParameterizedType) TypeTest.class.getDeclaredField("list2").getGenericType()).getActualTypeArguments()[0];
 for (Type bound : typeVariable.getBounds()) {
 
 System.out.println("getBounds 方法返回值有：" + bound.getTypeName());
 }
 System.out.println("getGenericDeclaration 方法返回值：" + typeVariable.getGenericDeclaration());
 System.out.println("getName 方法返回值：" + typeVariable.getName());
 for (AnnotatedType annotatedType : typeVariable.getAnnotatedBounds()) {
 
 System.out.println("getAnnotatedBounds 方法返回值有：" + annotatedType.getType().getTypeName());
 }
 }
 }

**输出：**

T：是类型变量
    ?：不是类型变量
    ? extends Number：不是类型变量
    ---------------------------------------------------------------
    getBounds 方法返回值有：java.lang.Object
    getGenericDeclaration 方法返回值：class com.joker.test.generic.TypeTest
    getName 方法返回值：T
    getAnnotatedBounds 方法返回值有：java.lang.Object

### 4. 通配符类型(WildcardType) ###

通配符类型的Type实现类为WildcardType。

**源码：**

public interface WildcardType extends Type {
        
    
        Type[] getUpperBounds();
    
        Type[] getLowerBounds();
    }

**方法：**

*  getUpperBounds：泛型表达式的上边界（表达式中使用extends）
 *  getLowerBounds：泛型表达式的下边界（表达式中使用super）

**示例：**

public class TypeTest<T> {
 
 
 private List<T> list2;
 
 private List<?> list3;
 
 private List<? extends Number> list4;
 
 private List<? super Number> list5;
 
 public static void main(String[] args) throws Exception {
 
 System.out.println(((ParameterizedType)TypeTest.class.getDeclaredField("list2").getGenericType()).getActualTypeArguments()[0] instanceof WildcardType ? "T：是通配符类型" : "T：不是通配符类型");
 System.out.println(((ParameterizedType)TypeTest.class.getDeclaredField("list3").getGenericType()).getActualTypeArguments()[0] instanceof WildcardType ? "?：是通配符类型" : "?：不是通配符类型");
 System.out.println(((ParameterizedType)TypeTest.class.getDeclaredField("list4").getGenericType()).getActualTypeArguments()[0] instanceof WildcardType ? "? extends Number：是通配符类型" : "? extends Number：不是通配符类型");
 System.out.println(((ParameterizedType)TypeTest.class.getDeclaredField("list5").getGenericType()).getActualTypeArguments()[0] instanceof WildcardType ? "? super Number：是通配符类型" : "? super Number：不是通配符类型");
 
 System.out.println("-----------------------------------------------");
 
 WildcardType wildcardType1 = (WildcardType)((ParameterizedType) TypeTest.class.getDeclaredField("list4").getGenericType()).getActualTypeArguments()[0];
 System.out.println("List<? extends Number> 上边界："+wildcardType1.getUpperBounds()[0].getTypeName());
 
 WildcardType wildcardType2 = (WildcardType)((ParameterizedType) TypeTest.class.getDeclaredField("list5").getGenericType()).getActualTypeArguments()[0];
 System.out.println("List<? super Number> 上边界："+wildcardType2.getUpperBounds()[0].getTypeName());
 System.out.println("List<? super Number> 下边界："+wildcardType2.getLowerBounds()[0].getTypeName());
 }
 }

**输出：**

T：不是通配符类型
 ?：是通配符类型
 ? extends Number：是通配符类型
 ? super Number：是通配符类型
 -----------------------------------------------
 List<? extends Number> 上边界：java.lang.Number
 List<? super Number> 上边界：java.lang.Object
 List<? super Number> 下边界：java.lang.Number

### 5. 泛型数组类型(GenericArrayType) ###

泛型数组类型的Type实现类为GenericArrayType。

注意：普通类型的数组不属于泛型数组类型（如int\[\]、Long\[\]、String\[\]）。

**源码：**

public interface GenericArrayType extends Type {
        
       	
        Type getGenericComponentType();
    }

**方法：**

*  getGenericComponentType：返回泛型数组中成员类型

**示例：**

public class TypeTest<T> {
 
 
 private String[] list;
 
 private List<String>[] list1;
 
 private List<T>[] list2;
 
 private List<?>[] list3;
 
 private List<? extends Number>[] list4;
 
 private T[] list5;
 
 public static void main(String[] args) throws Exception {
 
 System.out.println(TypeTest.class.getDeclaredField("list").getGenericType() instanceof GenericArrayType ? "String[]：是泛型数组类型" : "String[]：不是泛型数组类型");
 System.out.println(TypeTest.class.getDeclaredField("list1").getGenericType() instanceof GenericArrayType ? "List<String>[]：是泛型数组类型" : "List<String>[]：不是泛型数组类型");
 System.out.println(TypeTest.class.getDeclaredField("list2").getGenericType() instanceof GenericArrayType ? "List<T>[]：是泛型数组类型" : "List<T>[]：不是泛型数组类型");
 System.out.println(TypeTest.class.getDeclaredField("list3").getGenericType() instanceof GenericArrayType ? "List<?>[]：是泛型数组类型" : "List<?>[]：不是泛型数组类型");
 System.out.println(TypeTest.class.getDeclaredField("list4").getGenericType() instanceof GenericArrayType ? "List<? extends Number>[]：是泛型数组类型" : "List<? extends Number>[]：不是泛型数组类型");
 System.out.println(TypeTest.class.getDeclaredField("list5").getGenericType() instanceof GenericArrayType ? "T[]：是泛型数组类型" : "T[]：不是泛型数组类型");
 
 System.out.println("------------------------------------------------------");
 
 System.out.println("List<String>[] 数组成员类型："+((GenericArrayType) TypeTest.class.getDeclaredField("list1").getGenericType()).getGenericComponentType().getTypeName());
 System.out.println("List<T>[] 数组成员类型："+((GenericArrayType) TypeTest.class.getDeclaredField("list2").getGenericType()).getGenericComponentType().getTypeName());
 System.out.println("List<?>[] 数组成员类型："+((GenericArrayType) TypeTest.class.getDeclaredField("list3").getGenericType()).getGenericComponentType().getTypeName());
 System.out.println("List<? extends Number>[] 数组成员类型："+((GenericArrayType) TypeTest.class.getDeclaredField("list4").getGenericType()).getGenericComponentType().getTypeName());
 System.out.println("T[] 数组成员类型："+((GenericArrayType) TypeTest.class.getDeclaredField("list5").getGenericType()).getGenericComponentType().getTypeName());
 }
 }

**输出：**

String[]：不是泛型数组类型
 List<String>[]：是泛型数组类型
 List<T>[]：是泛型数组类型
 List<?>[]：是泛型数组类型
 List<? extends Number>[]：是泛型数组类型
 T[]：是泛型数组类型
 ------------------------------------------------------
 List<String>[] 数组成员类型：java.util.List<java.lang.String>
 List<T>[] 数组成员类型：java.util.List<T>
 List<?>[] 数组成员类型：java.util.List<?>
 List<? extends Number>[] 数组成员类型：java.util.List<? extends java.lang.Number>
 T[] 数组成员类型：T

[0645fe0c17224455b72f28d66f3cff9b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/f6a9c0d439c343daaacf61623c563ccf.png
[Java]: https://blog.csdn.net/JokerLJG/article/details/129041452