获取泛型的数据类型

╰+攻爆jí腚メ 2022-11-28 13:25 223阅读 0赞

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