簡介
Type是Java 編程語言中所有類型的公共高級接口，和Object不同，Object是所有類的父類，即Object是Type的父類。
分類
原始類型(Class)：不僅僅包含我們平常所指的類，還包括枚舉、數組、注解等；
參數化類型(ParameterizedType)：就是我們平常所用到的泛型List、Map；
數組類型(GenericArrayType)：並不是我們工作中所使用的數組String[] 、byte[]，而是帶有泛型的數組，即T[] ；
基本類型(Class)：也就是我們所說的java的基本類型，即int,float,double等。
詳細分類
ParameterizedType
- 含義:
參數化類型，即泛型；例如：List、Map<K,V>等帶有參數化的對象; - 代碼：
/**
*
* ParameterizedType表示參數化類型，也就是泛型，例如List<T>、Set<T>等；
**/
private List<T> list=null;
private List<T> set=null;
@Test
public void test() throws NoSuchFieldException {
Field fieldList=ParameterizedTypeDemo.class.getDeclaredField("list");
Type typeList = fieldList.getGenericType();
//sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl
System.out.println("獲取的type類型 typeList-->"+typeList.getClass().getName());
Field fieldSet=ParameterizedTypeDemo.class.getDeclaredField("set");
Type typeSet = fieldSet.getGenericType();
//sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl
System.out.println("獲取的type類型 typeSet-->"+typeSet.getClass().getName());
}
private Map<String,Integer> map=null;
@Test
public void tset2() throws NoSuchFieldException {
Field declaredField = ParameterizedTypeDemo.class.getDeclaredField("map");
Type genericType = declaredField.getGenericType();
ParameterizedType parameterizedType=(ParameterizedType)genericType;
Type name1 = parameterizedType.getActualTypeArguments()[0];
//java.lang.String
System.out.println("ParameterizedType 獲取參數1泛型類全名-->"+name1.getTypeName());
Type name2 = parameterizedType.getActualTypeArguments()[1];
//java.lang.Integer
System.out.println("ParameterizedType 獲取參數2泛型類全名-->"+((Class)name2).getName());
Type rawType = parameterizedType.getRawType();
//interface java.util.Map
System.out.println("獲取聲明泛型的類或者接口---》"+rawType);
}
TypeVariable
- 含義:
類型變量，即泛型中的變量；例如：T、K、V等變量，可以表示任何類；在這需要強調的是，TypeVariable代表着泛型中的變量，而ParameterizedType則代表整個泛型； - 代碼：
private List<T> list;
/**
* 泛型的類型變量，指的是List<T>、Map<K,V>中的T，K，V等值，實際的Java類型是TypeVariableImpl
* （TypeVariable的子類）；此外，還可以對類型變量加上extend限定，這樣會有類型變量對應的上限；
*
**/
@Test
public void test() throws NoSuchFieldException {
Field list = TypeVariableDemo.class.getDeclaredField("list");
//獲取該屬性的實際類型
Type genericType = list.getGenericType();
ParameterizedType parameterizedType=(ParameterizedType)genericType;
//獲取泛型中的實際類型
Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
//sun.reflect.generics.reflectiveObjects.TypeVariableImpl
System.out.println("獲取泛型中的實際類型-->"+actualTypeArguments[0].getClass().getName());
}
@Test
public void test2() throws NoSuchFieldException {
new TypeVariableTwoDemo().test();
}
public class TypeVariableTwoDemo<T extends Number & Serializable & Comparable,K>{
private T t;
private K k;
public void test() throws NoSuchFieldException {
Field field = TypeVariableTwoDemo.class.getDeclaredField("t");
Type genericType = field.getGenericType();
TypeVariable typeVariable=(TypeVariable)genericType;
Type[] bounds = typeVariable.getBounds();
//class java.lang.Number
//interface java.io.Serializable
//interface java.lang.Comparable
Arrays.stream(bounds).forEach(s-> System.out.println("獲取類型變量的上界-->"+s));
Field field2 = TypeVariableTwoDemo.class.getDeclaredField("k");
Type genericType2 = field2.getGenericType();
TypeVariable typeVariable2=(TypeVariable)genericType2;
Type[] bounds2 = typeVariable2.getBounds();
//class java.lang.Object
Arrays.stream(bounds2).forEach(s-> System.out.println("獲取類型變量的上界-->"+s));
//class com.yxkj.other.modular.reflection.type.TypeVariableDemo$TypeVariableTwoDemo
System.out.println("獲取聲明該類型變量實體-->"+typeVariable2.getGenericDeclaration());
//K
System.out.println("獲取聲明該類型變量實體-->"+typeVariable2.getName());
}
}
GenericArrayType
- 含義:
泛型數組類型，用來描述ParameterizedType、TypeVariable類型的數組；即List[] 、T[]等； - 代碼：
private T[] t;
private List<String>[] listArray;
/**
* 泛型數組類型，例如List<String>[] 、T[]等；
*
**/
@Test
public void test() throws NoSuchFieldException {
Field t = GenericArraytypeDemo.class.getDeclaredField("t");
Type genericType = t.getGenericType();
//sun.reflect.generics.reflectiveObjects.GenericArrayTypeImpl
System.out.println("獲取Type的實際類型-->"+genericType.getClass().getName());
}
@Test
public void test2() throws NoSuchFieldException {
Field t = GenericArraytypeDemo.class.getDeclaredField("listArray");
Type genericType = t.getGenericType();
GenericArrayType genericType1 = (GenericArrayType) genericType;
Type genericComponentType = genericType1.getGenericComponentType();
//java.util.List<java.lang.String>
System.out.println("獲取listArray的實際類型-->"+genericComponentType);
}
Class
- 含義:
上三者不同，Class是Type的一個實現類，屬於原始類型，是Java反射的基礎，對Java類的抽象；
在程序運行期間，每一個類都對應一個Class對象，這個對象包含了類的修飾符、方法，屬性、構造等信息，所以我們可以對這個Class對象進行相應的操作，這就是Java的反射；
*代碼:
private ClassDemo classDemo;
/**
*
* 在Java中，每個.class文件在程序運行期間，都對應着一個Class對象，
* 這個對象保存有這個類的全部信息；因此，Class對象也稱之為Java反射的基礎
*
**/
@Test
public void test() throws NoSuchFieldException {
Field field = ClassDemo.class.getDeclaredField("classDemo");
Type genericType = field.getGenericType();
//class com.yxkj.other.modular.reflection.type.ClassDemo
System.out.println("獲取Type原始類型-->"+genericType);
}
WildcardType
- 含義:
泛型表達式（或者通配符表達式），即？ extend Number、？ super Integer這樣的表達式；WildcardType雖然是Type的子接口，但卻不是Java類型中的一種；
*代碼:
private List<? extends Number> listNum;
private List<? super String> listStr;
/**
*
* ？---通配符表達式，表示通配符泛型，但是WildcardType並不屬於Java-Type中的一鍾；
* 例如：List<? extends Number> 和 List<? super Integer>；
*
**/
@Test
public void test() throws NoSuchFieldException {
Field declaredField = WildcardTypeDemo.class.getDeclaredField("listNum");
Type genericType = declaredField.getGenericType();
ParameterizedType parameterizedType=(ParameterizedType)genericType;
//獲取泛型中的實際類型
Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
//class sun.reflect.generics.reflectiveObjects.WildcardTypeImpl
System.out.println("獲取泛型中的實際類型-->"+actualTypeArguments[0].getClass());
WildcardType wildcardType= (WildcardType)actualTypeArguments[0];
Type[] upperBounds = wildcardType.getUpperBounds();
System.out.println("獲取泛型變量的上邊界-->"+upperBounds[0]);
Field declaredFieldlowerBounds = WildcardTypeDemo.class.getDeclaredField("listStr");
Type genericTypelowerBounds = declaredFieldlowerBounds.getGenericType();
ParameterizedType parameterizedTypelowerBounds=(ParameterizedType)genericTypelowerBounds;
//獲取泛型中的實際類型
Type[] actualTypeArgumentslowerBounds = parameterizedTypelowerBounds.getActualTypeArguments();
WildcardType wildcardTypelowerBounds= (WildcardType)actualTypeArgumentslowerBounds[0];
Type[] lowerBounds = wildcardTypelowerBounds.getLowerBounds();
System.out.println("獲取泛型變量的下邊界-->"+lowerBounds[0]);
}