Java反射：理解Class对象与实例对象的字段方法访问差异

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

// 定义一个简单的注解
@Retention(RetentionPolicy.RUNTIME)
@interface Publish {}

public class MyThing {

    @Publish
    public double value1 = 1.0; // 实例字段
    @Publish
    public static double value2 = 2.0; // 静态字段
    public static int value3 = 3;

    public static void method1() {
        System.out.println("One");
    }

    @Publish
    public static double method2(double value) { // 静态方法
        return value * value;
    }

    @Publish
    public int method3(double value) { // 实例方法
        return (int) Math.floor(value);
    }
}

public class ReflectionDemo {
    public static void main(String[] args) {
        // 场景1：对MyThing的实例进行反射
        Object instanceObj = new MyThing();
        System.out.println("--- 反射 MyThing 实例 ---");
        System.out.println("instanceObj.toString(): " + instanceObj.toString()); // 输出 MyThing@...
        System.out.println("instanceObj.getClass().getName(): " + instanceObj.getClass().getName()); // 输出 MyThing
        printFieldsAndMethods(instanceObj.getClass());

        System.out.println("\n--- 反射 Class 对象作为 Object 变量 ---");
        // 场景2：将MyThing.class赋值给Object变量，然后尝试反射
        Object classObjAsObject = MyThing.class;
        System.out.println("classObjAsObject.toString(): " + classObjAsObject.toString()); // 输出 class MyThing
        System.out.println("classObjAsObject.getClass().getName(): " + classObjAsObject.getClass().getName()); // 输出 java.lang.Class
        // 错误尝试：这里将无法获取MyThing的字段和方法
        System.out.println("尝试对 classObjAsObject.getClass() 进行反射:");
        printFieldsAndMethods(classObjAsObject.getClass());

        System.out.println("\n--- 直接对 MyThing.class 进行反射 ---");
        // 场景3：直接对MyThing.class进行反射
        System.out.println("MyThing.class.toString(): " + MyThing.class.toString()); // 输出 class MyThing
        System.out.println("MyThing.class.getName(): " + MyThing.class.getName()); // 输出 MyThing
        printFieldsAndMethods(MyThing.class);
    }

    private static void printFieldsAndMethods(Class<?> targetClass) {
        System.out.print("  字段:");
        for (Field f : targetClass.getDeclaredFields()) {
            if (f.isAnnotationPresent(Publish.class)) {
                System.out.print(" " + f.getName() + (Modifier.isStatic(f.getModifiers()) ? " (静态)" : " (实例)"));
            }
        }
        System.out.print("\n  方法:");
        for (Method m : targetClass.getDeclaredMethods()) {
            if (m.isAnnotationPresent(Publish.class)) {
                System.out.print(" " + m.getName() + (Modifier.isStatic(m.getModifiers()) ? " (静态)" : " (实例)"));
            }
        }
        System.out.println();
    }
}

--- 反射 MyThing 实例 ---
instanceObj.toString(): MyThing@6ff3c5b5
instanceObj.getClass().getName(): MyThing
  字段: value1 (实例) value2 (静态)
  方法: method2 (静态) method3 (实例)

--- 反射 Class 对象作为 Object 变量 ---
classObjAsObject.toString(): class MyThing
classObjAsObject.getClass().getName(): java.lang.Class
尝试对 classObjAsObject.getClass() 进行反射:
  字段:
  方法:

--- 直接对 MyThing.class 进行反射 ---
MyThing.class.toString(): class MyThing
MyThing.class.getName(): MyThing
  字段: value1 (实例) value2 (静态)
  方法: method2 (静态) method3 (实例)

public class ReflectionCorrectDemo {
    public static void main(String[] args) {
        // ... (MyThing 和 Publish 注解定义同上)

        System.out.println("\n--- 正确处理 Class 对象作为 Object 变量进行反射 ---");
        Object classObjAsObject = MyThing.class; // 此时 classObjAsObject 持有 MyThing.class

        // 正确做法：将 Object 变量转型为 Class<?>
        Class<?> actualClass = (Class<?>) classObjAsObject;
        System.out.println("转型后 actualClass.getName(): " + actualClass.getName()); // 输出 MyThing
        printFieldsAndMethods(actualClass);

        // 或者，从一开始就声明为 Class<?> 类型
        Class<?> directClass = MyThing.class;
        System.out.println("\n--- 直接声明为 Class<?> 进行反射 ---");
        System.out.println("directClass.getName(): " + directClass.getName()); // 输出 MyThing
        printFieldsAndMethods(directClass);
    }

    private static void printFieldsAndMethods(Class<?> targetClass) {
        // ... (printFieldsAndMethods 方法定义同上)
    }
}

--- 正确处理 Class 对象作为 Object 变量进行反射 ---
转型后 actualClass.getName(): MyThing
  字段: value1 (实例) value2 (静态)
  方法: method2 (静态) method3 (实例)

--- 直接声明为 Class<?> 进行反射 ---
directClass.getName(): MyThing
  字段: value1 (实例) value2 (静态)
  方法: method2 (静态) method3 (实例)

// ...
if (f.isAnnotationPresent(Publish.class)) {
    System.out.print(" " + f.getName() + (Modifier.isStatic(f.getModifiers()) ? " (静态)" : " (实例)"));
}
// ...