class 是反射的根:JVM 每加载一个类型(类、接口、数组、基本类型、void),就配一个唯一的 class 对象,作为方法区/元空间里类型元数据在 Java 侧的句柄。
拿字段、拿方法、造实例,一切反射操作都从它出发;「是不是同一个类」的判定标准也是它——同名 + 同一个定义类加载器,才是同一个 class 对象,`==` 直接可比。

// 基于本地 JDK 源码 (D:/1ForCode/JAVA_Source, java.base, JDK 25), java.lang.Class
public final class Class<T> implements java.io.Serializable,
                              GenericDeclaration,   // 类自己也能声明类型参数 <T>，所以和 Method/Constructor 同属泛型声明体系
                              Type,
                              AnnotatedElement,     // getAnnotation 一族的入口
                              TypeDescriptor.OfField<Class<?>>,
                              Constable {           // Class 可作为常量进常量池（condy/ldc）
    // ...

    /*
     * Private constructor. Only the Java Virtual Machine creates Class objects.
     * This constructor is not used and prevents the default constructor being
     * generated.
     */
    private Class(ClassLoader loader, Class<?> arrayComponentType, char mods, ProtectionDomain pd, boolean isPrim) {
        // Initialize final field for classLoader.  The initialization value of non-null
        // prevents future JIT optimizations from assuming this final field is null.
        // The following assignments are done directly by the VM without calling this constructor.
        classLoader = loader;               // 这个构造器一次都不会真的被调用：VM 创建 Class 时绕过它直接填字段，它只是防止编译器生成默认构造器
        componentType = arrayComponentType;
        modifiers = mods;
        protectionDomain = pd;
        primitive = isPrim;
    }
    // ...

    // Initialized in JVM not by private constructor
    // This field is filtered from reflection access, i.e. getDeclaredField
    // will throw NoSuchFieldException
    private final ClassLoader classLoader;      // 定义类加载器（见 [ClassLoader](/articles/sourcecode/java/jvm/classloader)）；被反射过滤，getDeclaredField("classLoader") 会 NoSuchFieldException
    // ...
    private final transient char modifiers;  // Set by the VM      // 修饰符位掩码，16 位够用所以存 char
    private final transient boolean primitive;  // Set by the VM if the Class is a primitive type.
    // ...
    private transient final Class<?> componentType;     // 数组类型才非空，"是不是数组"就看它
    // ...

    @IntrinsicCandidate
    public native boolean isInstance(Object obj);       // instanceof 的动态版：类型运行期才确定时用它。JIT intrinsic，热路径会内联成和 instanceof 一样的机器码

    @IntrinsicCandidate
    public native boolean isAssignableFrom(Class<?> cls);   // 判两个 Class 的父子关系；isInstance 判对象和 Class 的关系，方向别记反：A.isAssignableFrom(B) = B 能赋给 A

    public boolean isInterface() {
        return Modifier.isInterface(modifiers);     // 老 JDK 这三个判断都是 native；现在 VM 提前把元数据灌进 final 字段，纯 Java 读取，省掉 JNI 往返且可被 JIT 常量折叠
    }

    public boolean isArray() {
        return componentType != null;
    }

    public boolean isPrimitive() {
        return primitive;
    }
    // ...

    @SuppressWarnings("unchecked")
    @IntrinsicCandidate
    public T cast(Object obj) {
        if (obj != null && !isInstance(obj))
            throw new ClassCastException(cannotCastMsg(obj));
        return (T) obj;     // 擦除后这个强转本身什么都不查，安全性全靠上一行的 isInstance；null 直接放行，与语言层强转语义一致
    }
}

// 基于本地 JDK 源码 (D:/1ForCode/JAVA_Source, java.base, JDK 25), java.lang.Class
    @CallerSensitive        // 返回结果取决于"谁在调我"（用调用者的类加载器），这种方法不能被随便包一层转发，否则 caller 就变了
    public static Class<?> forName(String className)
                throws ClassNotFoundException {
        Class<?> caller = Reflection.getCallerClass();      // VM 直接读栈帧拿调用者的 Class
        return forName(className, caller);
    }

    // Caller-sensitive adapter method for reflective invocation
    @CallerSensitiveAdapter
    private static Class<?> forName(String className, Class<?> caller)
            throws ClassNotFoundException {
        ClassLoader loader = (caller == null) ? ClassLoader.getSystemClassLoader()
                                              : ClassLoader.getClassLoader(caller);    // caller==null 只在 JNI 线程直接调进来时发生，栈上没有 Java 帧，兜底用系统加载器
        return forName0(className, true, loader, caller);   // initialize=true：加载+链接+初始化一条龙
    }
    // ...

    public static Class<?> forName(String name, boolean initialize, ClassLoader loader)
        throws ClassNotFoundException
    {
        return forName0(name, initialize, loader, null);    // 三参版可以只加载不初始化：框架扫描类信息时传 false，避免扫一遍就把所有 static 块跑了
    }

    /** Called after security check for system loader access checks have been made. */
    private static native Class<?> forName0(String name, boolean initialize,
                                            ClassLoader loader,
                                            Class<?> caller)
        throws ClassNotFoundException;      // 真正干活的在 VM：查系统字典，没有就委托 loader 加载

    // ...

    @CallerSensitive
    @Deprecated(since="9")      // 废弃不是因为慢，是异常语义脏：构造器抛的受检异常会被它原样扔出来，绕过编译期检查
    public T newInstance()
        throws InstantiationException, IllegalAccessException
    {
        // Constructor lookup
        Constructor<T> tmpConstructor = cachedConstructor;
        if (tmpConstructor == null) {
            // ...
            try {
                Class<?>[] empty = {};
                final Constructor<T> c = getReflectionFactory().copyConstructor(
                    getConstructor0(empty, Member.DECLARED));
                // Disable accessibility checks on the constructor
                // access check is done with the true caller
                c.setAccessible(true);
                cachedConstructor = tmpConstructor = c;     // 无参构造器缓存在 Class 对象上，重复调用不再查找
            } catch (NoSuchMethodException e) {
                throw (InstantiationException)
                    new InstantiationException(getName()).initCause(e);
            }
        }

        try {
            Class<?> caller = Reflection.getCallerClass();
            return getReflectionFactory().newInstance(tmpConstructor, null, caller);
        } catch (InvocationTargetException e) {
            Unsafe.getUnsafe().throwException(e.getTargetException());     // 用 Unsafe 把受检异常伪装成非受检抛出——这一行就是它被废弃的原因；替代写法 getDeclaredConstructor().newInstance() 会老实包成 InvocationTargetException
            // Not reached
            return null;
        }
    }

// 基于本地 JDK 源码 (D:/1ForCode/JAVA_Source, java.base, JDK 25), java.lang.Class
    public Method[] getMethods() {
        return copyMethods(privateGetPublicMethods());      // 本类+父类+接口的所有 public 方法
    }
    // ...
    public Method[] getDeclaredMethods() {
        return copyMethods(privateGetDeclaredMethods(false));   // 只有本类声明的，含 private，不含继承。记忆：带 Declared = 本类声明含私有不含继承
    }
    // ...
    public Method getMethod(String name, Class<?>... parameterTypes)
            throws NoSuchMethodException {
        Objects.requireNonNull(name);
        Method method = getMethod0(name, parameterTypes);
        if (method == null) {
            throw new NoSuchMethodException(methodToString(name, parameterTypes));
        }
        return getReflectionFactory().copyMethod(method);   // 对外永远给副本，root Method 绝不外泄
    }
    // ...

    // Reflection data caches various derived names and reflective members. Cached
    // values may be invalidated when JVM TI RedefineClasses() is called
    private static class ReflectionData<T> {
        volatile Field[] declaredFields;
        volatile Field[] publicFields;
        volatile Method[] declaredMethods;
        volatile Method[] publicMethods;
        volatile Constructor<T>[] declaredConstructors;
        volatile Constructor<T>[] publicConstructors;
        // Intermediate results for getFields and getMethods
        volatile Field[] declaredPublicFields;
        volatile Method[] declaredPublicMethods;
        volatile Class<?>[] interfaces;
        // ...
        // Value of classRedefinedCount when we created this ReflectionData instance
        final int redefinedCount;       // 版本戳：类被热替换后靠它识别缓存过期

        ReflectionData(int redefinedCount) {
            this.redefinedCount = redefinedCount;
        }
    }

    private transient volatile SoftReference<ReflectionData<T>> reflectionData;    // 软引用：内存紧张时整套反射缓存可被 GC 回收，反正能从 VM 重建

    // Incremented by the VM on each call to JVM TI RedefineClasses()
    // that redefines this class or a superclass.
    private transient volatile int classRedefinedCount;

    // Lazily create and cache ReflectionData
    private ReflectionData<T> reflectionData() {
        SoftReference<ReflectionData<T>> reflectionData = this.reflectionData;
        int classRedefinedCount = this.classRedefinedCount;
        ReflectionData<T> rd;
        if (reflectionData != null &&
            (rd = reflectionData.get()) != null &&
            rd.redefinedCount == classRedefinedCount) {     // 命中还要对版本号：热替换过就当没缓存，防止拿到旧类的方法列表
            return rd;
        }
        // else no SoftReference or cleared SoftReference or stale ReflectionData
        // -> create and replace new instance
        return newReflectionData(reflectionData, classRedefinedCount);      // 内部 CAS 安装新缓存，竞争失败就用赢家的，全程无锁
    }
    // ...

    // Returns an array of "root" methods. These Method objects must NOT
    // be propagated to the outside world, but must instead be copied
    // via ReflectionFactory.copyMethod.
    private Method[] privateGetDeclaredMethods(boolean publicOnly) {
        Method[] res;
        ReflectionData<T> rd = reflectionData();
        res = publicOnly ? rd.declaredPublicMethods : rd.declaredMethods;
        if (res != null) return res;
        // No cached value available; request value from VM
        res = Reflection.filterMethods(this, getDeclaredMethods0(publicOnly));  // 真正进 VM 掏元数据的一次 native 调用；filter 把 classLoader 这类敏感成员藏掉
        if (publicOnly) {
            rd.declaredPublicMethods = res;
        } else {
            rd.declaredMethods = res;
        }
        return res;
    }
    // ...

    private Method[] privateGetPublicMethods() {
        Method[] res;
        ReflectionData<T> rd = reflectionData();
        res = rd.publicMethods;
        if (res != null) return res;

        // No cached value available; compute value recursively.
        // Start by fetching public declared methods...
        PublicMethods pms = new PublicMethods();
        for (Method m : privateGetDeclaredMethods(/* publicOnly */ true)) {
            pms.merge(m);       // merge 按签名去重并保留更具体的：子类覆写压过父类，类方法压过接口默认方法
        }
        // ...then recur over superclass methods...
        Class<?> sc = getSuperclass();
        if (sc != null) {
            for (Method m : sc.privateGetPublicMethods()) {
                pms.merge(m);
            }
        }
        // ...and finally over direct superinterfaces.
        for (Class<?> intf : getInterfaces(/* cloneArray */ false)) {
            for (Method m : intf.privateGetPublicMethods()) {
                // static interface methods are not inherited
                if (!Modifier.isStatic(m.getModifiers())) {     // 接口 static 方法不参与继承，语言规则在反射里的镜像
                    pms.merge(m);
                }
            }
        }

        res = pms.toArray();
        rd.publicMethods = res;     // 合并结果也缓存，getMethods 的递归代价只付一次
        return res;
    }
    // ...

    private static Method[] copyMethods(Method[] arg) {
        Method[] out = new Method[arg.length];
        ReflectionFactory fact = getReflectionFactory();
        for (int i = 0; i < arg.length; i++) {
            out[i] = fact.copyMethod(arg[i]);   // 每次调用都整批复制：你对返回值 setAccessible(true) 只污染自己那份
        }
        return out;
    }

    private native Field[]       getDeclaredFields0(boolean publicOnly);
    private native Method[]      getDeclaredMethods0(boolean publicOnly);       // 元数据真身在 VM 的 InstanceKlass 里，Java 侧所有数组都只是缓存+包装
    private native Constructor<T>[] getDeclaredConstructors0(boolean publicOnly);