【小家Java】你真的了解Java泛型参数吗？细说java.lang.reflect.Type（ParameterizedType、TypeVariable、WildcardType...）（上）

public interface Type {
    default String getTypeName() {
        return toString();
    }
}

public interface GenericArrayType extends Type {
  //返回泛型数组中元素的Type类型，即List<String>[] 中的 List<String>
  Type getGenericComponentType();
}

public class GenericArrayTypeTest<T> {
    // 这里面有各种各样的数组：各有不同 方便看测试效果
    // 含有泛型数组的才是GenericArrayType
    public void testGenericArrayType(List<String>[] pTypeArray, T[] vTypeArray, List<String> list,
                                     List<? extends Number> wildcardList, String[] strings, GenericArrayTypeTest[] test) {
    }
    public static void main(String[] args) {
        Method[] declaredMethods = GenericArrayTypeTest.class.getDeclaredMethods();
        for (Method method : declaredMethods) {
            // main方法不用处理
            if (method.getName().startsWith("main")) {
                continue;
            }
            // 开始处理该方法===打印出此方法签名
            System.out.println("declare Method:" + method); //declare Method:public void com.fsx.maintest.GenericArrayTypeTest.testGenericArrayType(java.util.List[],java.lang.Object[],java.util.List,java.lang.String[],com.fsx.maintest.GenericArrayTypeTest[])
            // 该方法能获取到该方法所有的实际的参数化类型，比如本例中有五个参数，那数组长度就是5
            Type[] types = method.getGenericParameterTypes();
            // 分组打印出来
            for (Type type : types) {
                if (type instanceof ParameterizedType) {
                    ParameterizedType parameterizedType = (ParameterizedType) type;
                    System.out.println("ParameterizedType type :" + parameterizedType);
                }
                else if (type instanceof GenericArrayType) {
                    // 从结果
                    GenericArrayType genericArrayType = (GenericArrayType) type;
                    System.out.println("GenericArrayType type :" + genericArrayType);
                    Type genericComponentType = genericArrayType.getGenericComponentType();
                    System.out.println("genericComponentType:" + genericComponentType);
                }
                else if (type instanceof WildcardType) {
                    WildcardType wildcardType = (WildcardType) type;
                    System.out.println("WildcardType type :" + wildcardType);
                }
                else if (type instanceof TypeVariable) {
                    TypeVariable typeVariable = (TypeVariable) type;
                    System.out.println("TypeVariable type :" + typeVariable);
                }
                else {
                    Class clazz = (Class) type;
                    System.out.println("type :" + clazz);
                }
            }
        }
    }
}

declare Method:public void com.fsx.maintest.GenericArrayTypeTest.testGenericArrayType(java.util.List[],java.lang.Object[],java.util.List,java.util.List,java.lang.String[],com.fsx.maintest.GenericArrayTypeTest[])
GenericArrayType type :java.util.List<java.lang.String>[]
genericComponentType:java.util.List<java.lang.String>
GenericArrayType type :T[]
genericComponentType:T
ParameterizedType type :java.util.List<java.lang.String>
ParameterizedType type :java.util.List<? extends java.lang.Number>
type :class [Ljava.lang.String;
type :class [Lcom.fsx.maintest.GenericArrayTypeTest;

public interface ParameterizedType extends Type {
  //获取类型内部的参数化类型 比如Map<K,V>里面的K，V类型
  Type[] getActualTypeArguments();
  // 类的原始类型，一般都是Class
  Type getRawType();
  // 获取所有者类型（只有内部类才有所有者，比如Map.Entry他的所有者就是Map），若不是内部类，此处返回null
    Type getOwnerType();
}

public class ParameterizedTypeTest {
    private Map<String, ParameterizedTypeTest> map;
    private Set<String> set1;
    private Class<?> clz;
    private Holder<String> holder;
    private List<String> list;
    private ArrayList<String> arrayList; 
    private Map.Entry<String, String> entry;
    private String str;
    private Integer i;
    private Set set;
    private List aList;
    static class Holder<V> {
    }
    public static void main(String[] args) {
        Field f = null;
        try {
            // 拿到所有的字段
            Field[] fields = ParameterizedTypeTest.class.getDeclaredFields();
            for (int i = 0; i < fields.length; i++) {
                f = fields[i];
                if (f.getGenericType() instanceof ParameterizedType) {
                    ParameterizedType parameterizedType = (ParameterizedType) f.getGenericType();
                    System.out.println(f.getName() + "：");
                    System.out.println("\t ParameterizedType:" + Arrays.asList(parameterizedType.getActualTypeArguments()));
                    System.out.println("\t getRawType:" + parameterizedType.getRawType());
                    System.out.println("\t getOwnerType:" + parameterizedType.getOwnerType());
                }
                // 输出不是ParameterizedType 参数化类型的
                else {
                    System.out.println(f.getName() + ":is not ParameterizedType ");
                }
            }
        } catch (Exception e) {
        }
    }
}

map：
   ParameterizedType:[class java.lang.String, class com.fsx.maintest.ParameterizedTypeTest]
   getRawType:interface java.util.Map
   getOwnerType:null
set1：
   ParameterizedType:[class java.lang.String]
   getRawType:interface java.util.Set
   getOwnerType:null
clz：
   ParameterizedType:[?]
   getRawType:class java.lang.Class
   getOwnerType:null
holder：
   ParameterizedType:[class java.lang.String]
   getRawType:class com.fsx.maintest.ParameterizedTypeTest$Holder
   getOwnerType:class com.fsx.maintest.ParameterizedTypeTest
list：
   ParameterizedType:[class java.lang.String]
   getRawType:interface java.util.List
   getOwnerType:null
arrayList：
   ParameterizedType:[class java.lang.String]
   getRawType:class java.util.ArrayList
   getOwnerType:null
entry：
   ParameterizedType:[class java.lang.String, class java.lang.String]
   getRawType:interface java.util.Map$Entry
   getOwnerType:interface java.util.Map
str:is not ParameterizedType 
i:is not ParameterizedType 
set:is not ParameterizedType 
aList:is not ParameterizedType