反射工具类

1、将反射获取的list转换成对应类型list
2、打印类的所有方法

import android.util.Log;

import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Parameter;
import java.util.ArrayList;
import java.util.List;

public class ReflectionUtils {
    /**
     * 将反射获取的原始 List 转换为指定类型的 List
     * @param rawList 反射获取的原始 List
     * @param elementType 目标元素类型的 Class 对象
     * @param <T> 泛型类型
     * @return 类型安全的 List
     * @throws ClassCastException 如果元素类型不匹配
     */
    @SuppressWarnings("unchecked")
    public static <T> List<T> convertToList(List<?> rawList, Class<T> elementType) {
        List<T> result = new ArrayList<>(rawList.size());
        for (Object element : rawList) {
            // 验证元素类型
            if (element != null && !elementType.isInstance(element)) {
                throw new ClassCastException("Element type mismatch: expected "
                        + elementType.getName() + ", but found " + element.getClass().getName());
            }
            // 安全转换（null 元素会被保留）
            result.add((T) element);
        }
        return result;
    }



    public static void printMethodParams(){
        Class<?> clazz = null;
        try {
            clazz = Class.forName("com.xxx.Example");
            Log.d("", "printMethodParams: ===== 类中的方法及其参数 =====");
            // 获取所有公共方法（包括从父类继承的）
            Method[] methods = clazz.getMethods();
            for (Method method : methods) {
                printMethodParams(method);
            }
            Log.d("", "printMethodParams: ===== 类自身声明的方法及其参数 =====");
            // 获取类自身声明的所有方法（不包括父类）
            Method[] declaredMethods = clazz.getDeclaredMethods();
            for (Method method : declaredMethods) {
                printMethodParams(method);
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public static  void printMethodsInfo() {
        try {
            Class<?> clazz = Class.forName("com.xxx.Example");
            Log.d("", "printMethodsInfo: ===== 类中的方法及其参数 =====");
            // 获取所有公共方法（包括从父类继承的）
            Method[] methods = clazz.getMethods();
            printMethodsInfo(methods);
            Log.d("", "printMethodsInfo: ===== 类自身声明的方法及其参数 =====");
            // 获取类自身声明的所有方法（不包括父类）
            Method[] declaredMethods = clazz.getDeclaredMethods();
            printMethodsInfo(declaredMethods);
        } catch (Exception e) {

        }
    }

    private static void printMethodsInfo(Method[] methods) {
        for (Method method : methods) {
            StringBuilder builder = new StringBuilder();
            // 获取方法修饰符（public, private, static等）
            String modifiers = Modifier.toString(method.getModifiers());
            if (!modifiers.isEmpty()) {
                modifiers += " ";
            }

            // 获取返回值类型
            Class<?> returnType = method.getReturnType();
            String returnTypeName = returnType.getSimpleName();

            // 获取方法名
            String methodName = method.getName();

            // 获取参数列表
            Class<?>[] parameterTypes = method.getParameterTypes();
            StringBuilder paramsBuilder = new StringBuilder();
            paramsBuilder.append("(");

            for (int i = 0; i < parameterTypes.length; i++) {
                String paramTypeName = parameterTypes[i].getSimpleName();
                paramsBuilder.append(paramTypeName);
                if (i < parameterTypes.length - 1) {
                    paramsBuilder.append(", ");
                }
            }
            paramsBuilder.append(")");

            // 输出方法信息
            Log.d("", "printMethodParams: "+modifiers + returnTypeName + " " + methodName + paramsBuilder);
        }
    }

    private static void printMethodParams(Method method) {
        // 方法名
        String methodName = method.getName();
        StringBuilder builder = new StringBuilder();
        builder.append(methodName + "(");

        // 获取参数列表
        Parameter[] parameters = method.getParameters();
        for (int i = 0; i < parameters.length; i++) {
            Parameter param = parameters[i];
            String paramType = param.getType().getSimpleName();
            String paramName = param.getName(); // Java 8+ 需要-parameters编译选项

            builder.append(paramType + " " + paramName);
            if (i < parameters.length - 1) {
                builder.append(", ");
            }
        }
        builder.append(")");
        Log.d("", "printMethodParams: "+builder.toString());
    }


}