Java Type class

---

Introduction to Type

Type is the common high-level interface for all types in the Java programming language. They include primitive types, parameterized types, array types, type variables, and primitive types.

The Type interface itself is a marker interface and does not provide any methods that need to be overridden.

Type classification

Type classification:

Type category name	TypeType	describe	example
primitive type	Class	Java classes, enumerations, arrays, annotations, all basic data types	String、Date、Integer、int、boolean 等
parameterized type	ParameterizedType	Parameterized types (generic types)	List<String>、Map<Integer,String>、List<T>、List<?>、List<? extends Number>、List<? super Number> 等
type variable	TypeVariable	Generic symbols (excluding wildcards)	T , K , V , E, etc.
wildcard type	WildcardType	wildcard	?、? extends Number、? super Number 等
generic array type	GenericArrayType	generic array	List<?>[]、List<T>[]、List<String>[]、List<? extends Number>[]、T[] 等

Get Type:

The Class, Field, and Method classes of JDK provide a series of related methods for obtaining types.

You can refer to the article: How to obtain generic type information in Java

1. Primitive type (Class)

The Type implementation class of the primitive type is Class. This type has nothing to do with generics, the other 4 types are all related to generics.

Primitive types mainly include: Java classes, enumerations, arrays, annotations, and all basic data types.

Example:

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[]：不是原始类型");
    }
}

output:

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

2. Parameterized Type (ParameterizedType)

The Type implementation class of parameterized type is ParameterizedType.

Parameterized types are generic types.

source code:

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

    Type getOwnerType();
}

method:

• getActualTypeArguments: Get the Type collection of actual type parameters
• getRawType: Get the Type of the class or interface that declares this type
• getOwnerType: If the class or interface of this type is declared as an inner class, this returns the Type of the outer class of the inner class (that is, the owner of the inner class)

Example:

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"));
    }
}

output:

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. Type variable (TypeVariable)

The Type implementation class of a type variable is TypeVariable.

Generic symbols (excluding wildcards) that type variables refer to immediately.
source code:

public interface TypeVariable<D extends GenericDeclaration> extends Type, AnnotatedElement {
    
    

    Type[] getBounds();

    D getGenericDeclaration();

    String getName();
    
    AnnotatedType[] getAnnotatedBounds();
}

method:

• getBounds: The upper boundary corresponding to the type variable. If no upper limit is specified, return Object, there can be multiple
• getGenericDeclaration: Get the Type of the class where the type variable is located.
• getName: Get the name of the type variable defined in the source code
• getAnnotatedBounds: get the upper limit array of annotation type

Example:

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());
        }
    }
}

output:

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

4. Wildcard Type (WildcardType)

The Type implementation class of the wildcard type is WildcardType.

source code:

public interface WildcardType extends Type {
    
    

    Type[] getUpperBounds();

    Type[] getLowerBounds();
}

method:

• getUpperBounds: the upper boundary of the generic expression (extends are used in the expression)
• getLowerBounds: the lower bound of the generic expression (using super in the expression)

Example:

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());
    }
}

output:

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

5. Generic Array Type (GenericArrayType)

The Type implementation class of the generic array type is GenericArrayType.

Note: Arrays of common types do not belong to generic array types (such as int[], Long[], String[]).

source code:

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

method:

• getGenericComponentType: returns the member type in the generic array

Example:

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());
    }
}

output:

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