主题 05类加载与反射

05.1这道题在问什么

05.2三个阶段：加载、链接、初始化

「类加载」这个词被用得很泛，严格说它包含三个阶段，其中只有最后一个阶段会执行你的代码：

这个区别有一个非常实用的推论：ClassLoader.loadClass() 只做到「加载」， Class.forName() 做到「初始化」。实测：

--- 先试 ClassLoader.loadClass ---
  loadClass 拿到: ClassDemo$Target，上面有没有静态块输出？   <-- 没有
--- 再试 Class.forName ---
  [Target] 静态代码块执行了
  forName 拿到: ClassDemo$Target
--- forName 但不初始化 ---
  initialize=false: ClassDemo$Target，静态块没再执行
  两个引用是同一个 Class 吗: true / true

三个方法拿到的是同一个 Class 对象，但只有中间那个触发了静态块。 这就是为什么 JDBC 时代要写 Class.forName("com.mysql.cj.jdbc.Driver")—— 它要的不是「加载驱动类」，而是触发驱动类静态块里的注册逻辑：

static {
    DriverManager.registerDriver(new Driver());   // 注册发生在静态块里
}

还有一条容易被追问的：什么时候会触发初始化？只有五种，其余都不会：

05.3双亲委派：它到底在防什么

先说现象。JDK 17 的类加载器只剩三层，实测每个类的归属：

java.lang.String                  -> null（启动类加载器）
javax.crypto.Cipher               -> null（启动类加载器）
ClassDemo                         -> jdk.internal.loader.ClassLoaders$AppClassLoader
java.sql.DriverManager            -> ClassLoaders$PlatformClassLoader
当前线程上下文类加载器: jdk.internal.loader.ClassLoaders$AppClassLoader
app 的父加载器: ClassLoaders$PlatformClassLoader
app 的父的父:   null

null 不是「没有加载器」，是启动类加载器——它由 C++ 实现， 在 Java 里拿不到引用，所以返回 null。app → platform → null 这条链就是双亲委派的路由表。

流程一句话：收到加载请求，先甩给父加载器；父加载器也甩给它的父；顶到最上面还找不到， 才一层层往下自己找。它防的是两件事：

第一条实测比想象的更彻底。写一个 package java.lang; 的 String 类去编译：

probe\java\lang\String.java:1: 错误: 程序包已存在于另一个模块中: java.base
package java.lang;
^
--- 运行 ---
错误: 找不到 java.lang.String 的主方法          <-- 加载的是 JDK 自己的 String

两层拦截：编译期javac 就报「包已存在于 java.base 模块」，运行期即使硬塞进去， java.lang.String 这个请求在双亲委派的第一跳就被启动类加载器接走了，你的类根本没机会。 所以这道题的答案要分层：
① JDK 8 及以前——ClassLoader.preDefineClass 里一句 if (name.startsWith("java.")) throw new SecurityException("Prohibited package name: java.lang") 硬拦；
② JDK 9 及以后——模块系统在编译期就挡了，连 class 文件都产不出来。
双亲委派是「约定」，包名检查/模块系统才是「硬拦」——这个区别在面试里很加分。

什么时候会打破它

三种典型场景，从上到下越来越常见：

第 1 条的代码长这样（DriverManager 源码）：

ServiceLoader<Driver> loadedDrivers = ServiceLoader.load(Driver.class);
// 内部用的是 Thread.currentThread().getContextClassLoader()
// 而不是 DriverManager.class.getClassLoader()

05.4同一个类，两个 Class 对象

「类加载器是类的命名空间」这句话，只有跑一次才信。写一个故意破坏双亲委派的加载器 （先自己 findClass，找不到才委派），用它把同一个 class 文件加载两次：

默认加载器 : class ClassDemo$Target @ 925858445
l1 加载    : class ClassDemo$Target @ 1480010240
l2 加载    : class ClassDemo$Target @ 81628611
c1 == c2 ? false
c2 == c3 ? false
c1 的加载器: jdk.internal.loader.ClassLoaders$AppClassLoader@4e25154f
c2 的加载器: ClassDemo$MyLoader@28a418fc

三个对象、三个哈希、互不相等。同一个 .class 文件，被加载了三次，就是三个不同的类。 再往下走一步，看它有多致命：

c2 造出来的对象，能不能塞进 c1 的变量？
  ClassCastException: class ClassDemo$Target cannot be cast to
                     class ClassDemo$Target
  (ClassDemo$Target is in unnamed module of loader ClassDemo$MyLoader @28a418fc;
   ClassDemo$Target is in unnamed module of loader 'app')

报错信息里两个类名一模一样，但 JVM 认为它们是两个类型。因为 JVM 判断「是不是同一个类」的条件是：

类的全限定名 + 加载它的 ClassLoader 实例   （两者都相同才算同一个类）

05.5反射到底慢多少

先说结论：慢，但没有传说中那么慢。预热 3 轮后测 1000 万次：

直接调用          :   0.23 ns/次
反射 invoke       :   4.23 ns/次  (18.7 倍)
反射+setAccessible:   2.77 ns/次  (12.2 倍)
MethodHandle      :   1.80 ns/次  (8.0 倍)

四个数字要分两层读：

• 倍数很吓人（18.7 倍），但绝对值只差 4 纳秒。 一次 Redis 往返是 0.5 毫秒 = 50 万纳秒，反射那 4 纳秒连零头都不算。
• setAccessible(true) 能提速 34%（4.23 → 2.77）。 因为它跳过了每次调用都要做的访问权限检查——这也是为什么框架创建 Method 对象后第一件事就是 setAccessible(true)。

MethodHandle 最快（1.80ns），因为它在第一次调用后会被 JIT 当成普通的虚方法调用内联掉， 和直接调用同一个量级。这也是 JDK 7 引入它的目的：给「动态调用」一个能被 JIT 优化的入口。

05.6反射能碰到什么，碰不到什么

「反射能打破封装」这句话在 JDK 17 上只对了一半。四组实测：

--- 1. 自己的类（nestmate）---
不 setAccessible 直接读 Target.value: 42
不 setAccessible 直接改: 99
  原因：ClassDemo 和 Target 在同一个 nest 里，私有成员互相可见
--- 2. JDK 自己的类 ---
setAccessible(String.value) -> java.lang.reflect.InaccessibleObjectException
--- 3. static final 常量 ---
改 CONST -> java.lang.IllegalAccessException:
  Can not set static final int field ClassDemo$Target.CONST to (int)123
--- 4. 私有方法 ---
调私有方法: 私有方法被调用了

逐条解释，每一条都能当面试答案：

第 2 条的完整报错（一个字没改）：

Unable to make field private final byte[] java.lang.String.value accessible:
module java.base does not "opens java.lang" to unnamed module @63961c42

要绕过它，启动参数加一行就行——这本身就说明模块系统是「封装」不是「安全」：

java --add-opens java.base/java.lang=ALL-UNNAMED -cp . ClassDemo access
  -> String.value = [B@816f27d        （拿到了 byte[]）

05.7框架为什么离不开反射

把这一章的知识落到一个具体问题上：Spring 启动时，凭什么根据一个字符串 "com.example.UserService" 就把对象造出来、把依赖注入好？

// 简化后的三步，和本章三节一一对应
Class<?> clazz = Class.forName("com.example.UserService");  // 05.2 加载+初始化
Object bean = clazz.getDeclaredConstructor().newInstance();  // 05.5 反射创建
for (Field f : clazz.getDeclaredFields()) {                  // 05.6 反射注入
    if (f.isAnnotationPresent(Autowired.class)) {
        f.setAccessible(true);
        f.set(bean, getBean(f.getType()));
    }
}

三个细节全都能对上本章的实测：

• Class.forName 而不是 loadClass——因为要触发静态块， 很多类在静态块里注册自己；
• setAccessible(true)——这就是 05.5 里那 34% 的性能来源， 也是能注入私有字段的前提；
• 缓存 Method/Constructor——因为 getDeclaredMethod 本身比 invoke 还贵。

05.8速记卡与自查

动手清单与自查表