Java反射：动态获取并打印方法名称及其返回值

public class FooClass {
    String barMethod() {
        return "baz";
    }
}

// 调用并打印返回值
System.out.println(new FooClass().barMethod()); // 输出: baz

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class MethodInfoPrinter {

    /**
     * 打印指定实例上指定方法的名称及其返回值。
     * 适用于无参的实例方法。
     *
     * @param instance 要调用方法的对象实例。
     * @param methodName 要调用的方法名称。
     */
    public static void printMethodAndValue(Object instance, String methodName) {
        if (instance == null) {
            System.err.println("错误：实例对象不能为null。");
            return;
        }

        Class<?> clazz = instance.getClass();
        try {
            // 1. 获取Method对象：假设方法是无参数的
            // 如果方法有参数，需要使用 getDeclaredMethod(methodName, paramType1.class, paramType2.class...)
            Method method = clazz.getDeclaredMethod(methodName);

            // 2. 如果方法是私有的，需要设置可访问性
            if (!method.isAccessible()) {
                method.setAccessible(true);
            }

            // 3. 调用方法并获取返回值
            Object returnValue = method.invoke(instance);

            // 4. 打印结果
            System.out.println(method.getName() + " = " + returnValue);

        } catch (NoSuchMethodException e) {
            System.err.println("错误：在类 " + clazz.getName() + " 中未找到方法 " + methodName + "。请检查方法名或参数类型。");
        } catch (IllegalAccessException e) {
            System.err.println("错误：无法访问方法 " + methodName + "。请检查方法的可访问性修饰符或setAccessible(true)。");
        } catch (InvocationTargetException e) {
            // 捕获方法内部抛出的异常
            System.err.println("错误：方法 " + methodName + " 执行时抛出异常：" + e.getCause().getMessage());
        } catch (Exception e) {
            System.err.println("发生未知错误：" + e.getMessage());
        }
    }

    /**
     * 打印指定类上指定静态方法的名称及其返回值。
     * 适用于无参的静态方法。
     *
     * @param clazz 要调用静态方法的Class对象。
     * @param methodName 要调用的静态方法名称。
     */
    public static void printStaticMethodAndValue(Class<?> clazz, String methodName) {
        if (clazz == null) {
            System.err.println("错误：Class对象不能为null。");
            return;
        }

        try {
            Method method = clazz.getDeclaredMethod(methodName);

            if (!java.lang.reflect.Modifier.isStatic(method.getModifiers())) {
                System.err.println("错误：方法 " + methodName + " 不是静态方法。请使用 printMethodAndValue 方法。");
                return;
            }

            if (!method.isAccessible()) {
                method.setAccessible(true);
            }

            // 对于静态方法，invoke的第一个参数为null
            Object returnValue = method.invoke(null);
            System.out.println(method.getName() + " = " + returnValue);

        } catch (NoSuchMethodException e) {
            System.err.println("错误：在类 " + clazz.getName() + " 中未找到静态方法 " + methodName + "。");
        } catch (IllegalAccessException e) {
            System.err.println("错误：无法访问静态方法 " + methodName + "。");
        } catch (InvocationTargetException e) {
            System.err.println("错误：静态方法 " + methodName + " 执行时抛出异常：" + e.getCause().getMessage());
        } catch (Exception e) {
            System.err.println("发生未知错误：" + e.getMessage());
        }
    }

    // 示例用法
    public static void main(String[] args) {
        // 定义一个示例类
        class FooClass {
            String barMethod() {
                return "baz";
            }

            private String privateMethod() {
                return "private result";
            }

            static String staticFooMethod() {
                return "static baz";
            }

            String methodWithArgs(int value) {
                return "Value: " + value;
            }
        }

        FooClass foo = new FooClass();

        // 1. 打印实例方法（无参）
        System.out.println("--- 实例方法 (无参) ---");
        MethodInfoPrinter.printMethodAndValue(foo, "barMethod");
        MethodInfoPrinter.printMethodAndValue(foo, "privateMethod"); // 即使是私有方法，也可以通过setAccessible(true)访问

        // 2. 打印静态方法（无参）
        System.out.println("\n--- 静态方法 (无参) ---");
        MethodInfoPrinter.printStaticMethodAndValue(FooClass.class, "staticFooMethod");

        // 3. 尝试打印不存在的方法
        System.out.println("\n--- 尝试打印不存在的方法 ---");
        MethodInfoPrinter.printMethodAndValue(foo, "nonExistentMethod");

        // 4. 尝试打印带参数的方法 (需要更复杂的反射处理)
        System.out.println("\n--- 尝试打印带参数的方法 (简易处理) ---");
        // 对于带参数的方法，getDeclaredMethod需要参数类型，invoke需要参数值
        try {
            Method methodWithArgs = FooClass.class.getDeclaredMethod("methodWithArgs", int.class);
            Object result = methodWithArgs.invoke(foo, 123);
            System.out.println(methodWithArgs.getName() + " = " + result);
        } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
            System.err.println("调用带参数方法失败: " + e.getMessage());
        }
    }
}

--- 实例方法 (无参) ---
barMethod = baz
privateMethod = private result

--- 静态方法 (无参) ---
staticFooMethod = static baz

--- 尝试打印不存在的方法 ---
错误：在类 MethodInfoPrinter$1FooClass 中未找到方法 nonExistentMethod。请检查方法名或参数类型。

--- 尝试打印带参数的方法 (简易处理) ---
methodWithArgs = Value: 123

Method method = clazz.getDeclaredMethod("methodWithArgs", int.class); // 指定参数类型为 int.class
Object returnValue = method.invoke(instance, 123); // 传入参数值 123