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

// 示例类
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) {
        // 场景一：通过类的实例进行反射
        Object instanceObj = new MyThing();
        System.out.println("--- 实例对象反射 ---");
        printAnnotatedMembers(instanceObj.getClass());

        // 场景二：将Class对象赋值给Object变量后进行反射 (错误方式)
        Object classAsObject = MyThing.class;
        System.out.println("\n--- Class对象作为Object变量反射 (错误方式) ---");
        // 此时 classAsObject.getClass() 得到的是 java.lang.Class.class
        printAnnotatedMembers(classAsObject.getClass());

        // 场景三：直接使用Class对象进行反射
        System.out.println("\n--- 直接使用Class对象反射 ---");
        printAnnotatedMembers(MyThing.class);

        // 场景四：将Class对象赋值给Object变量后进行反射 (正确方式)
        System.out.println("\n--- Class对象作为Object变量反射 (正确方式) ---");
        // 必须强制转换为 Class<?> 类型
        if (classAsObject instanceof Class) {
            printAnnotatedMembers((Class<?>) classAsObject);
        }
    }

    private static void printAnnotatedMembers(Class<?> targetClass) {
        System.out.println("目标类: " + targetClass.getName());

        System.out.print("  字段:");
        for (Field f : targetClass.getDeclaredFields()) {
            if (f.isAnnotationPresent(Publish.class)) {
                System.out.print(" " + f.getName() + (Modifier.isStatic(f.getModifiers()) ? " (static)" : ""));
            }
        }
        System.out.println();

        System.out.print("  方法:");
        for (Method m : targetClass.getDeclaredMethods()) {
            if (m.isAnnotationPresent(Publish.class)) {
                System.out.print(" " + m.getName() + (Modifier.isStatic(m.getModifiers()) ? " (static)" : ""));
            }
        }
        System.out.println();
    }
}

--- 实例对象反射 ---
目标类: MyThing
  字段: value1 value2 (static)
  方法: method2 (static) method3

--- Class对象作为Object变量反射 (错误方式) ---
目标类: java.lang.Class
  字段:
  方法:

--- 直接使用Class对象反射 ---
目标类: MyThing
  字段: value1 value2 (static)
  方法: method2 (static) method3

--- Class对象作为Object变量反射 (正确方式) ---
目标类: MyThing
  字段: value1 value2 (static)
  方法: method2 (static) method3

Object obj = MyThing.class;
System.out.println("obj.toString()          = " + obj.toString());
System.out.println("MyThing.class.toString()= " + MyThing.class.toString());
System.out.println("obj.getClass().getName()= " + obj.getClass().getName());

obj.toString()          = class MyThing
MyThing.class.toString()= class MyThing
obj.getClass().getName()= java.lang.Class

Object potentialClassObj = MyThing.class; // 或者 Class<?> potentialClassObj = MyThing.class;

// 确保是Class对象，然后进行类型转换
if (potentialClassObj instanceof Class) {
    Class<?> targetClass = (Class<?>) potentialClassObj;
    Field[] fields = targetClass.getDeclaredFields();
    Method[] methods = targetClass.getDeclaredMethods();
    // ... 对 fields 和 methods 进行处理
} else {
    // 处理 potentialClassObj 并非 Class 对象的情况
    System.err.println("Error: The object is not a Class instance.");
}

Class<?> targetClass = MyThing.class;
Field[] fields = targetClass.getDeclaredFields();
Method[] methods = targetClass.getDeclaredMethods();
// ...

for (Field field : targetClass.getDeclaredFields()) {
    if (Modifier.isStatic(field.getModifiers())) {
        System.out.println("静态字段: " + field.getName());
    } else {
        System.out.println("实例字段: " + field.getName());
    }
}

for (Method method : targetClass.getDeclaredMethods()) {
    if (Modifier.isStatic(method.getModifiers())) {
        System.out.println("静态方法: " + method.getName());
    } else {
        System.out.println("实例方法: " + method.getName());
    }
}