Retrofit完全解析(三)：Type<基础详解>

初识Type

Type

Type四大子接口

ParameterizedType (

Collection<String>

)(参数话类型)

类注解：参数化类型在第一次由反射方法需要时创建，当参数化类型p被创建时，p实例化的通用类型声明被解析，并且递归地创建p的所有类型参数。 重复创建参数化类型不起作用。实现此接口的类的实例必须实现equals（）方法，等同于任何两个实例共享同一通用类型声明并具有相等类型参数。

Collection<String>

方法

Collection<String>

Map<String, String> map

O<T>.I<S>

O<T>

public class ParameterizedTypeTest {
Map<String, String> map;
public static void main(String[] args) throws Exception {
Field f = TestType.class.getDeclaredField("map");
System.out.println(f.getGenericType());                               // java.util.Map<java.lang.String, java.lang.String>
System.out.println(f.getGenericType() instanceof ParameterizedType);  // true
ParameterizedType pType = (ParameterizedType) f.getGenericType();
System.out.println(pType.getRawType());                               // interface java.util.Map
for (Type type : pType.getActualTypeArguments()) {
System.out.println(type);                                         // 打印两遍: class java.lang.String
}
System.out.println(pType.getOwnerType());                             // null
}
}

public static void main(String[] args) throws Exception {
Method method = new Test().getClass().getMethod("applyMethod",Map.Entry.class);
Type[] types = method.getGenericParameterTypes();
ParameterizedType pType = (ParameterizedType)types[0];
System.out.println(pType.getOwnerType());//打印结果是interface java.util.Map

}

public static <T,U> void applyMethod(Map.Entry<T,U> mapEntry){

}

TypeVariable (

<T>

)(类型变量)

public interface TypeVariable<D extends GenericDeclaration> extends Type ｛...｝

方法

public class TestType <K extends Comparable & Serializable, V> {
K key;
V value;
public static void main(String[] args) throws Exception {
// 获取字段的类型
Field fk = TestType.class.getDeclaredField("key");
Field fv = TestType.class.getDeclaredField("value");
Assert.that(fk.getGenericType() instanceof TypeVariable, "必须为TypeVariable类型");
Assert.that(fv.getGenericType() instanceof TypeVariable, "必须为TypeVariable类型");
TypeVariable keyType = (TypeVariable)fk.getGenericType();
TypeVariable valueType = (TypeVariable)fv.getGenericType();
// getName 方法
System.out.println(keyType.getName());                 // K
System.out.println(valueType.getName());               // V
// getGenericDeclaration 方法
System.out.println(keyType.getGenericDeclaration());   // class com.test.TestType
System.out.println(valueType.getGenericDeclaration()); // class com.test.TestType
// getBounds 方法
System.out.println("K 的上界:");                        // 有两个
for (Type type : keyType.getBounds()) {                // interface java.lang.Comparable
System.out.println(type);                          // interface java.io.Serializable
}
System.out.println("V 的上界:");                        // 没明确声明上界的, 默认上界是 Object
for (Type type : valueType.getBounds()) {              // class java.lang.Object
System.out.println(type);
}
}
}

GenericArrayType(通用数组类型)

方法

public static void main(String[] args) {
new GenericArrayTypeTest();
Method method = Test.class.getDeclaredMethods()[0];
Type[] types = method.getGenericParameterTypes();
for (Type type : types) {
if (type instanceof GenericArrayType) {
GenericArrayType arrayType = (GenericArrayType) type;
System.out.println(type.getTypeName());
Type anyType = arrayType.getGenericComponentType();
printType(anyType);
}
}
}

public static void printType(Type type){
String printStr = "";
if (type instanceof GenericArrayType) {
printStr  = "GenericArrayType";
}else if(type instanceof ParameterizedType){
printStr = "ParameterizedType";
}else if(type instanceof TypeVariable){
printStr = "TypeVariable";
}else if(type instanceof WildcardType){
printStr = "WildcardType";
}else if(type instanceof Class){
printStr = "Class";
}else{
printStr = "UnKnown";
}
System.out.println(type.getTypeName() +" :::: "+ printStr);
}

class Test<T>{
// List<String>[] pTypeArr > getGenericComponentType > java.util.List<java.lang.String> 为 ParameterizedType
// T[] vTypeArr > getGenericComponentType > T 为 TypeVariable
public void show(List<String>[] pTypeArr,T[] vTypeArr,List<String> list,String[] strings,int[] ints){}
}

WildcardType(通配符类型)

方法

public class TestType {
private List<? extends Number> a;  // // a没有下界, 取下界会抛出ArrayIndexOutOfBoundsException
private List<? super String> b;
public static void main(String[] args) throws Exception {
Field fieldA = TestType.class.getDeclaredField("a");
Field fieldB = TestType.class.getDeclaredField("b");
// 先拿到范型类型
Assert.that(fieldA.getGenericType() instanceof ParameterizedType, "");
Assert.that(fieldB.getGenericType() instanceof ParameterizedType, "");
ParameterizedType pTypeA = (ParameterizedType) fieldA.getGenericType();
ParameterizedType pTypeB = (ParameterizedType) fieldB.getGenericType();
// 再从范型里拿到通配符类型
Assert.that(pTypeA.getActualTypeArguments()[0] instanceof WildcardType, "");
Assert.that(pTypeB.getActualTypeArguments()[0] instanceof WildcardType, "");
WildcardType wTypeA = (WildcardType) pTypeA.getActualTypeArguments()[0];
WildcardType wTypeB = (WildcardType) pTypeB.getActualTypeArguments()[0];
// 方法测试
System.out.println(wTypeA.getUpperBounds()[0]);   // class java.lang.Number
System.out.println(wTypeB.getLowerBounds()[0]);   // class java.lang.String
// 看看通配符类型到底是什么, 打印结果为: ? extends java.lang.Number
System.out.println(wTypeA);
}
}

总结

List<String>、List<T>

Class<T>[]、Class<?>[]

class Test<T>{
// List<String> 为 ParameterizedType

// T 为 TypeVariable

// Class<T>[] 为 GenericArrayType
// Class<?>[] 为 GenericArrayType  ==> ? 为 WildcardType

// List<String>[] pTypeArr > getGenericComponentType > java.util.List<java.lang.String> 为 ParameterizedType
// T[] vTypeArr > getGenericComponentType > T 为 TypeVariable

// ? 为 WildcardType
// Class[]、List[]、int[]、String[]、Class、List、String、int 为 Class

// Type要么是四大Type 要么为Class

public void show(List[] pTypeArr,T[] vTypeArr,List<String> list,String[] strings,Class[] cls,int[] ints,Set<?> set,T t){}
}