获取泛型的数据类型

 public static void main(String[] args) {
//        Type type=getGenericType(AE_C11.class, TestInterface.class,0);
        Type type=getGenericType(TextField.class, HasValueAndElement.class,1);
        System.out.println(type);
    }

    public static Type getGenericType(Class<?> clazz, Class<?> interest, int index) {
        //判断该类是否实现了HasVaue接口
        if (clazz == null || clazz == Object.class || interest == null || !interest.isAssignableFrom(clazz)) {
            return null;
        }

        //获取实现的接口
        Class<?>[] interfaces = clazz.getInterfaces();
        //判断长度，如果为空，则该类没有实现的接口
        int i=0;
        if (interfaces.length!=0) {
            for (Class<?> inter : interfaces) {
                //循环判断实现的接口是否实现了interest接口
                Type type=getIntfaceGenericType(clazz,inter,interest,index,i);
                if (type!=null){
                    return type;
                }
                i++;
            }
        }


        //获取实现的接口，判断该接口
//        Type[] types = clazz.getGenericInterfaces();

        //获取继承的父类，判断该父类
        Type type=clazz.getGenericSuperclass();
        try {
            ParameterizedType supclassType= (ParameterizedType) type;
            return supclassType.getActualTypeArguments()[index];
        }catch (Exception e){
            //该类的父类不符合条件,对父类进行操作
            return getGenericType(clazz.getSuperclass(),interest,index);
        }
    }

    public static Type getIntfaceGenericType(Class<?> old,Class<?> clazz, Class<?> interest, int index,int i){
        //判断该接口是否继承了interest
        if (clazz==interest){
            Type[] types=old.getGenericInterfaces();
            System.out.println(types[i]);
            ParameterizedType para1= (ParameterizedType) types[i];
            return para1.getActualTypeArguments()[index];
//            for(Type type:types){
//                ParameterizedType para= (ParameterizedType) type;
//                return para.getActualTypeArguments()[index];
//            }
        }
        if (interest.isAssignableFrom(clazz)) {
            //判断该接口是否具备第index个泛型
            Type[] types=clazz.getGenericInterfaces();
            for (Type type:types){
                try {
                    System.out.println((Class<?>)type);
                    if (interest.isAssignableFrom((Class<?>)type)){
                        ParameterizedType parameterizedType = (ParameterizedType) type;
                        Type actualTypeArgument = parameterizedType.getActualTypeArguments()[index];
                        return actualTypeArgument;
                    }
                }catch (ClassCastException e){
                    //获取该接口继承的接口并进行判断
                    Class<?>[] interfaces = clazz.getInterfaces();
                    int j=0;
                    for (Class<?> in:interfaces){
                        Type intfaceGenericType = getIntfaceGenericType(clazz, in, interest, index, j);
                        if (intfaceGenericType!=null){
                            return intfaceGenericType;
                        }
                        j++;
                    }
                }
            }
        }
        return null;
    }