reflection: Method/Field/MethodHandle/VarHandle demos, module and final-field rules (JEP 500 on JDK 26), JMH call-cost numbers, contract tests

Co-Authored-By: Claude Sonnet 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_017ic4b6NtPJHrkan4BXhCAM

README.md

@@ -26,6 +26,7 @@ article; each module's own README has that article's version table, quickstart,
 | [`cow`](cow/) | CopyOnWriteArrayList in Java: When It Wins (JMH) and When It Hurts |
 | [`sorting`](sorting/) | Java Comparator & Comparable: The Complete Guide |
 | [`annotation-processor`](annotation-processor/) | Custom Annotations and Annotation Processors in Java: Generate Code at Compile Time |
+| [`reflection`](reflection/) | Java Reflection and MethodHandles in 2026: How They Work and What They Cost |
 
 ## License
 

pom.xml

@@ -34,6 +34,7 @@
     <module>cow</module>
     <module>sorting</module>
     <module>annotation-processor</module>
+    <module>reflection</module>
   </modules>
 
   <properties>

reflection/README.md

@@ -0,0 +1,58 @@
+# reflection
+
+Companion code for the ankurm.com post *"Java Reflection and MethodHandles in 2026: How They Work
+and What They Cost."* One module in `java-core-examples`. Everything the post explains lives in
+the post itself (accordions per section); this module is the runnable evidence.
+
+## Versions this was built and tested against
+
+| Component | Version | Notes |
+|---|---|---|
+| JDK | 25.0.5+8 (Temurin, LTS) | All demos and the JMH run. |
+| JDK (comparison only) | 26.0.2.1+1 (Temurin) | Used for the JEP 500 final-field warning in `output/03`. |
+| JMH | 1.37 | 3 warmup + 5 measurement iterations, 2 forks. |
+| JUnit Jupiter | 5.11.0 | Contract tests - they fail if a documented behaviour changes. |
+| Maven | 3.9.11 | |
+| Hardware | 2 vCPU Intel Xeon @ 2.30 GHz VM | Shared sandbox: treat ns figures as relative, not absolute. |
+
+## Quickstart
+
+```bash
+export JAVA_HOME=/path/to/jdk-25
+mvn package                                   # compiles, runs the contract tests, builds the JMH jar
+java src/main/java/com/ankurm/reflection/QuickStart.java
+java -cp target/classes com.ankurm.reflection.ReflectionBasicsDemo
+java -cp target/classes com.ankurm.reflection.ModuleRulesDemo
+java --add-opens java.base/java.lang=ALL-UNNAMED -cp target/classes com.ankurm.reflection.ModuleRulesDemo
+java -cp target/classes com.ankurm.reflection.FinalFieldDemo
+java -cp target/classes com.ankurm.reflection.MethodHandlesDemo
+java -jar target/benchmarks.jar CallBenchmark
+```
+
+`scripts/run-all.sh` regenerates every file in `output/` (set `JDK26_HOME` to include the JDK 26 runs).
+
+## What's in here
+
+| File | What it shows |
+|---|---|
+| `Account.java` | The sample class: public API, private method, private/final fields, a throwing method. |
+| `QuickStart.java` | Self-contained: one call by `Method`, one by `MethodHandle`. Run with `java QuickStart.java`. |
+| `ReflectionBasicsDemo.java` | Inspect, construct, invoke; the five exceptions you will meet; extra stack frames. |
+| `ModuleRulesDemo.java` | `setAccessible` on your class vs. a JDK internal; `--add-opens`. |
+| `FinalFieldDemo.java` | Final instance / static / record fields; constant-inlining trap; JEP 500 on JDK 26. |
+| `MethodHandlesDemo.java` | `invokeExact` vs `invoke`, composition, lookup-time access checks, `VarHandle`. |
+| `CallBenchmark.java` | JMH: direct vs `Method` vs `MethodHandle` vs `Field` vs `VarHandle`, static-final vs instance field. |
+| `ReflectionContractTest.java` | Eight tests pinning the contracts the post states. |
+
+## Captured output
+
+| File | From |
+|---|---|
+| `output/01-basics.txt` | `ReflectionBasicsDemo` |
+| `output/02-module-rules.txt` | `ModuleRulesDemo`, without and with `--add-opens` |
+| `output/03-final-fields.txt` | `FinalFieldDemo` on JDK 25, JDK 26, and JDK 26 with `--illegal-final-field-mutation=deny` |
+| `output/04-method-handles.txt` | `MethodHandlesDemo` |
+| `output/05-call-benchmark.txt` | `CallBenchmark` (non-deterministic; relative ordering is the result) |
+| `output/06-quickstart.txt` | `QuickStart` |
+
+Identity-hash suffixes like `unnamed module @6b95977` change on every run.

reflection/output/01-basics.txt

@@ -0,0 +1,32 @@
+$ java -cp target/classes com.ankurm.reflection.ReflectionBasicsDemo
+
+== 1. Inspect the class ==
+class: com.ankurm.reflection.Account
+  public long balance[]
+  public void deposit[long]
+  public String owner[]
+  private String secret[]
+  public String[] stack[]
+  public String toString[]
+  public static int twice[int]
+
+== 2. Create and call ==
+created: Account[alice, 50]
+after deposit(25): Account[alice, 75]
+
+== 3. The exceptions you will meet ==
+wrong name        -> NoSuchMethodException: com.ankurm.reflection.Account.nope()
+wrong arg type    -> IllegalArgumentException: argument type mismatch
+method threw      -> InvocationTargetException wrapping java.lang.IllegalArgumentException: over limit: 5000
+private, no opt-in -> IllegalAccessException: class com.ankurm.reflection.ReflectionBasicsDemo cannot access a member of class com.ankurm.reflection.Account with modifiers "private"
+after setAccessible(true): secret-of-alice
+
+== 4. What reflection adds to the stack ==
+direct call:
+  com.ankurm.reflection.Account.stack
+  com.ankurm.reflection.ReflectionBasicsDemo.main
+through Method.invoke:
+  com.ankurm.reflection.Account.stack
+  jdk.internal.reflect.DirectMethodHandleAccessor.invoke
+  java.lang.reflect.Method.invoke
+  com.ankurm.reflection.ReflectionBasicsDemo.main

reflection/output/02-module-rules.txt

@@ -0,0 +1,24 @@
+$ java -cp target/classes com.ankurm.reflection.ModuleRulesDemo
+
+== setAccessible on your own class ==
+Account.owner = carol
+
+== setAccessible on a JDK private field ==
+String lives in module : java.base
+we live in module      : unnamed module @6b95977 (unnamed=true)
+java.lang open to us   : false
+trySetAccessible       : false
+setAccessible threw    : InaccessibleObjectException
+  Unable to make field private final byte[] java.lang.String.value accessible: module java.base does not "opens java.lang" to unnamed module @6b95977
+
+$ java --add-opens java.base/java.lang=ALL-UNNAMED -cp target/classes com.ankurm.reflection.ModuleRulesDemo
+
+== setAccessible on your own class ==
+Account.owner = carol
+
+== setAccessible on a JDK private field ==
+String lives in module : java.base
+we live in module      : unnamed module @3764951d (unnamed=true)
+java.lang open to us   : true
+trySetAccessible       : true
+setAccessible worked, String.value is a byte[]

reflection/output/03-final-fields.txt

@@ -0,0 +1,47 @@
+$ java -cp target/classes com.ankurm.reflection.FinalFieldDemo   # JDK 25
+
+java.version = 25.0.5
+
+== 1. final instance field ==
+owner() now: mallory
+
+== 2. static final field ==
+IllegalAccessException: Can not set static final int field com.ankurm.reflection.Account.MAX_DEPOSIT to java.lang.Integer
+
+== 3. record component ==
+IllegalAccessException: Can not set final int field com.ankurm.reflection.FinalFieldDemo$Point.x to java.lang.Integer
+
+== 4. constant inlining: the write 'works' but the getter never notices ==
+Field.get -> 99
+max()     -> 5
+
+$ java -cp target/classes com.ankurm.reflection.FinalFieldDemo   # JDK 26
+
+java.version = 26.0.2.1
+
+== 1. final instance field ==
+WARNING: Final field owner in class com.ankurm.reflection.Account has been mutated reflectively by class com.ankurm.reflection.FinalFieldDemo in unnamed module @18b4aac2 (file:/tmp/work/java-core-examples/reflection/target/classes/)
+WARNING: Use --enable-final-field-mutation=ALL-UNNAMED to avoid a warning
+WARNING: Mutating final fields will be blocked in a future release unless final field mutation is enabled
+owner() now: mallory
+
+== 2. static final field ==
+IllegalAccessException: Can not set static final int field com.ankurm.reflection.Account.MAX_DEPOSIT to java.lang.Integer
+
+== 3. record component ==
+IllegalAccessException: Can not set final int field com.ankurm.reflection.FinalFieldDemo$Point.x to java.lang.Integer
+
+== 4. constant inlining: the write 'works' but the getter never notices ==
+Field.get -> 99
+max()     -> 5
+
+$ java --illegal-final-field-mutation=deny -cp target/classes com.ankurm.reflection.FinalFieldDemo   # JDK 26
+
+java.version = 26.0.2.1
+
+== 1. final instance field ==
+Exception in thread "main" java.lang.IllegalAccessException: class com.ankurm.reflection.FinalFieldDemo (in unnamed module @18b4aac2) cannot set final field com.ankurm.reflection.Account.owner (in unnamed module @18b4aac2), unnamed module @18b4aac2 is not allowed to mutate final fields
+	at java.base/java.lang.reflect.Field.preSetFinal(Field.java:1504)
+	at java.base/java.lang.reflect.Field.setFinal(Field.java:1447)
+	at java.base/java.lang.reflect.Field.set(Field.java:909)
+	at com.ankurm.reflection.FinalFieldDemo.main(FinalFieldDemo.java:30)

reflection/output/04-method-handles.txt

@@ -0,0 +1,31 @@
+$ java -cp target/classes com.ankurm.reflection.MethodHandlesDemo
+
+== 1. Look up once, call many times ==
+twice(21)        = 42
+balance()        = 50
+handle type      = (Account)long
+
+== 2. invokeExact is exact; invoke adapts ==
+invokeExact, wrong return type -> WrongMethodTypeException
+  handle's method type (Account)long but found (Account)Object
+invoke (boxing)  = 50 (Long)
+
+== 3. Handles compose ==
+bindTo(acct)     = 50
+after deposit10  = Account[erin, 60]
+balance as text  = "60"
+
+== 4. Access is checked when you look up, not when you call ==
+findVirtual(private) -> IllegalAccessException
+  no such method: com.ankurm.reflection.Account.secret()String/invokeVirtual
+privateLookupIn      -> secret-of-erin
+privateLookupIn(String) -> IllegalAccessException
+  module java.base does not open java.lang to unnamed module @135fbaa4
+
+== 5. VarHandle: typed, atomic field access ==
+get              = 60
+CAS(60 -> 100)   = true, balance now 100
+CAS(60 -> 200)   = false, balance now 100
+getAndAdd(5)     = was 100, now 105
+set on final field -> UnsupportedOperationException
+array element CAS-able: counts[1] = 7

reflection/output/05-call-benchmark.txt

@@ -0,0 +1,15 @@
+$ java -jar target/benchmarks.jar CallBenchmark
+
+openjdk version "25.0.5" 2026-10-20 LTS
+
+Benchmark                                             Mode  Cnt   Score   Error  Units
+CallBenchmark.direct                                  avgt   10   0.516 ± 0.069  ns/op
+CallBenchmark.field_get                               avgt   10   0.899 ± 0.051  ns/op
+CallBenchmark.methodHandle_instanceField_invokeExact  avgt   10   2.600 ± 0.145  ns/op
+CallBenchmark.methodHandle_staticFinal_invokeBoxing   avgt   10   2.690 ± 0.262  ns/op
+CallBenchmark.methodHandle_staticFinal_invokeExact    avgt   10   0.476 ± 0.038  ns/op
+CallBenchmark.reflection_instanceFieldMethod          avgt   10   6.476 ± 1.952  ns/op
+CallBenchmark.reflection_lookupEveryCall              avgt   10  21.525 ± 1.756  ns/op
+CallBenchmark.reflection_staticFinalMethod            avgt   10   1.208 ± 0.152  ns/op
+CallBenchmark.varHandle_staticFinal_get               avgt   10   0.519 ± 0.076  ns/op
+

reflection/output/06-quickstart.txt

@@ -0,0 +1,4 @@
+$ java src/main/java/com/ankurm/reflection/QuickStart.java
+
+reflection   : Hello, Ankur
+MethodHandle : Hello, Ankur

reflection/pom.xml

@@ -0,0 +1,83 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+
+  <parent>
+    <groupId>com.ankurm</groupId>
+    <artifactId>java-core-examples</artifactId>
+    <version>1.0</version>
+  </parent>
+
+  <artifactId>reflection</artifactId>
+  <name>reflection</name>
+  <description>Java reflection, MethodHandles and VarHandles: access rules, module encapsulation, final-field mutation, and JMH call-cost numbers.</description>
+
+  <properties>
+    <jmh.version>1.37</jmh.version>
+  </properties>
+
+  <dependencies>
+    <dependency>
+      <groupId>org.openjdk.jmh</groupId>
+      <artifactId>jmh-core</artifactId>
+      <version>${jmh.version}</version>
+    </dependency>
+    <dependency>
+      <groupId>org.openjdk.jmh</groupId>
+      <artifactId>jmh-generator-annprocess</artifactId>
+      <version>${jmh.version}</version>
+    </dependency>
+    <dependency>
+      <groupId>org.junit.jupiter</groupId>
+      <artifactId>junit-jupiter</artifactId>
+      <version>5.11.0</version>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+
+  <build>
+    <finalName>benchmarks</finalName>
+    <plugins>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <version>3.13.0</version>
+        <configuration>
+          <release>25</release>
+          <annotationProcessorPaths>
+            <path>
+              <groupId>org.openjdk.jmh</groupId>
+              <artifactId>jmh-generator-annprocess</artifactId>
+              <version>${jmh.version}</version>
+            </path>
+          </annotationProcessorPaths>
+        </configuration>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-surefire-plugin</artifactId>
+        <version>3.2.5</version>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-shade-plugin</artifactId>
+        <version>3.5.1</version>
+        <executions>
+          <execution>
+            <phase>package</phase>
+            <goals><goal>shade</goal></goals>
+            <configuration>
+              <transformers>
+                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
+                  <mainClass>org.openjdk.jmh.Main</mainClass>
+                </transformer>
+              </transformers>
+            </configuration>
+          </execution>
+        </executions>
+      </plugin>
+    </plugins>
+  </build>
+</project>

reflection/scripts/run-all.sh

@@ -0,0 +1,45 @@
+#!/usr/bin/env bash
+# Regenerates every file in output/. Needs JDK 25 as JAVA_HOME; JDK26_HOME (optional) adds the
+# JEP 500 comparison run. JMH takes a few minutes.
+set -euo pipefail
+cd "$(dirname "$0")/.."
+
+mvn -q package
+
+# env -u keeps the sandbox's JAVA_TOOL_OPTIONS banner out of committed output.
+J() { env -u JAVA_TOOL_OPTIONS "$JAVA_HOME/bin/java" "$@"; }
+
+echo "--- 01: basics ---"
+{ echo '$ java -cp target/classes com.ankurm.reflection.ReflectionBasicsDemo'; echo
+  J -cp target/classes com.ankurm.reflection.ReflectionBasicsDemo 2>&1; } > output/01-basics.txt
+
+echo "--- 02: module rules ---"
+{ echo '$ java -cp target/classes com.ankurm.reflection.ModuleRulesDemo'; echo
+  J -cp target/classes com.ankurm.reflection.ModuleRulesDemo 2>&1
+  echo; echo '$ java --add-opens java.base/java.lang=ALL-UNNAMED -cp target/classes com.ankurm.reflection.ModuleRulesDemo'; echo
+  J --add-opens java.base/java.lang=ALL-UNNAMED -cp target/classes com.ankurm.reflection.ModuleRulesDemo 2>&1; } > output/02-module-rules.txt
+
+echo "--- 03: final fields (JDK 25, and JDK 26 if JDK26_HOME is set) ---"
+{ echo '$ java -cp target/classes com.ankurm.reflection.FinalFieldDemo   # JDK 25'; echo
+  J -cp target/classes com.ankurm.reflection.FinalFieldDemo 2>&1
+  if [ -n "${JDK26_HOME:-}" ]; then
+    echo; echo '$ java -cp target/classes com.ankurm.reflection.FinalFieldDemo   # JDK 26'; echo
+    env -u JAVA_TOOL_OPTIONS "$JDK26_HOME/bin/java" -cp target/classes com.ankurm.reflection.FinalFieldDemo 2>&1
+    echo; echo '$ java --illegal-final-field-mutation=deny -cp target/classes com.ankurm.reflection.FinalFieldDemo   # JDK 26'; echo
+    env -u JAVA_TOOL_OPTIONS "$JDK26_HOME/bin/java" --illegal-final-field-mutation=deny -cp target/classes com.ankurm.reflection.FinalFieldDemo 2>&1 || true
+  fi; } > output/03-final-fields.txt
+
+echo "--- 04: method handles ---"
+{ echo '$ java -cp target/classes com.ankurm.reflection.MethodHandlesDemo'; echo
+  J -cp target/classes com.ankurm.reflection.MethodHandlesDemo 2>&1; } > output/04-method-handles.txt
+
+echo "--- 05: JMH call cost (a few minutes) ---"
+J -jar target/benchmarks.jar CallBenchmark -rf text -rff /tmp/jmh-reflection.txt > /tmp/jmh-reflection.log 2>&1
+{ echo '$ java -jar target/benchmarks.jar CallBenchmark'; echo
+  J -version 2>&1 | head -1
+  echo; grep -A20 '^Benchmark ' /tmp/jmh-reflection.log | grep -v 'Benchmark result is saved'; } > output/05-call-benchmark.txt
+
+echo "--- 06: single-file quick start ---"
+{ echo '$ java src/main/java/com/ankurm/reflection/QuickStart.java'; echo
+  J src/main/java/com/ankurm/reflection/QuickStart.java 2>&1; } > output/06-quickstart.txt
+echo done

reflection/src/main/java/com/ankurm/reflection/Account.java

@@ -0,0 +1,60 @@
+package com.ankurm.reflection;
+
+/**
+ * The one class every demo in this module pokes at. It has a public API, a private method,
+ * a private mutable field, a private final field, a static constant and a method that throws -
+ * everything reflection has an opinion about.
+ */
+public class Account {
+    public static final int MAX_DEPOSIT = 1_000;
+
+    private final String owner;
+    private long balance;
+
+    public Account(String owner, long balance) {
+        this.owner = owner;
+        this.balance = balance;
+    }
+
+    public Account() {
+        this("nobody", 0);
+    }
+
+    public String owner() {
+        return owner;
+    }
+
+    public long balance() {
+        return balance;
+    }
+
+    public void deposit(long amount) {
+        if (amount > MAX_DEPOSIT) {
+            throw new IllegalArgumentException("over limit: " + amount);
+        }
+        balance += amount;
+    }
+
+    private String secret() {
+        return "secret-of-" + owner;
+    }
+
+    public static int twice(int x) {
+        return x * 2;
+    }
+
+    /** Returns the stack as seen from inside this method - used to show what reflection adds. */
+    public String[] stack() {
+        StackTraceElement[] st = new Throwable().getStackTrace();
+        String[] out = new String[Math.min(st.length, 6)];
+        for (int i = 0; i < out.length; i++) {
+            out[i] = st[i].getClassName() + "." + st[i].getMethodName();
+        }
+        return out;
+    }
+
+    @Override
+    public String toString() {
+        return "Account[" + owner + ", " + balance + "]";
+    }
+}

reflection/src/main/java/com/ankurm/reflection/CallBenchmark.java

@@ -0,0 +1,110 @@
+package com.ankurm.reflection;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+import java.lang.invoke.VarHandle;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.concurrent.TimeUnit;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Fork;
+import org.openjdk.jmh.annotations.Measurement;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.Warmup;
+
+/**
+ * What does one call cost? Every variant reads Account.balance(). The two things being tested
+ * are the API and - crucially - whether the JIT can see the handle/Method as a constant
+ * (static final) or has to treat it as an unknown (instance field).
+ */
+@State(Scope.Benchmark)
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.NANOSECONDS)
+@Warmup(iterations = 3, time = 1)
+@Measurement(iterations = 5, time = 1)
+@Fork(2)
+public class CallBenchmark {
+
+    static final Method S_METHOD;
+    static final MethodHandle S_HANDLE;
+    static final Field S_FIELD;
+    static final VarHandle S_VARHANDLE;
+
+    static {
+        try {
+            S_METHOD = Account.class.getMethod("balance");
+            S_HANDLE = MethodHandles.lookup().findVirtual(Account.class, "balance",
+                    MethodType.methodType(long.class));
+            S_FIELD = Account.class.getDeclaredField("balance");
+            S_FIELD.setAccessible(true);
+            S_VARHANDLE = MethodHandles.privateLookupIn(Account.class, MethodHandles.lookup())
+                    .findVarHandle(Account.class, "balance", long.class);
+        } catch (ReflectiveOperationException e) {
+            throw new ExceptionInInitializerError(e);
+        }
+    }
+
+    Account acct = new Account("bench", 42);
+    Method method;
+    MethodHandle handle;
+
+    @Setup
+    public void setup() throws Exception {
+        method = Account.class.getMethod("balance");
+        handle = MethodHandles.lookup().findVirtual(Account.class, "balance",
+                MethodType.methodType(long.class));
+    }
+
+    /** What code generation produces: an ordinary call. */
+    @Benchmark
+    public long direct() {
+        return acct.balance();
+    }
+
+    @Benchmark
+    public Object reflection_staticFinalMethod() throws Exception {
+        return S_METHOD.invoke(acct);
+    }
+
+    @Benchmark
+    public Object reflection_instanceFieldMethod() throws Exception {
+        return method.invoke(acct);
+    }
+
+    /** The classic mistake: look the Method up again on every call. */
+    @Benchmark
+    public Object reflection_lookupEveryCall() throws Exception {
+        return Account.class.getMethod("balance").invoke(acct);
+    }
+
+    @Benchmark
+    public long methodHandle_staticFinal_invokeExact() throws Throwable {
+        return (long) S_HANDLE.invokeExact(acct);
+    }
+
+    @Benchmark
+    public long methodHandle_instanceField_invokeExact() throws Throwable {
+        return (long) handle.invokeExact(acct);
+    }
+
+    @Benchmark
+    public Object methodHandle_staticFinal_invokeBoxing() throws Throwable {
+        return S_HANDLE.invoke(acct);
+    }
+
+    @Benchmark
+    public Object field_get() throws Exception {
+        return S_FIELD.get(acct);
+    }
+
+    @Benchmark
+    public long varHandle_staticFinal_get() {
+        return (long) S_VARHANDLE.get(acct);
+    }
+}

reflection/src/main/java/com/ankurm/reflection/FinalFieldDemo.java

@@ -0,0 +1,63 @@
+package com.ankurm.reflection;
+
+import java.lang.reflect.Field;
+
+/**
+ * Section 4: what happens when reflection tries to change a final field. Run it on JDK 25 and
+ * JDK 26 and compare - JEP 500 (JDK 26) adds a warning for the instance-field case.
+ */
+public class FinalFieldDemo {
+
+    record Point(int x, int y) {}
+
+    /** The initializer is a compile-time constant, so javac copies 5 into every read of max. */
+    static class Limit {
+        private final int max = 5;
+
+        int max() {
+            return max;
+        }
+    }
+
+    public static void main(String[] args) throws Exception {
+        System.out.println("java.version = " + System.getProperty("java.version"));
+
+        System.out.println();
+        System.out.println("== 1. final instance field ==");
+        Account acct = new Account("dave", 0);
+        Field owner = Account.class.getDeclaredField("owner");
+        owner.setAccessible(true);
+        owner.set(acct, "mallory");
+        System.out.println("owner() now: " + acct.owner());
+
+        System.out.println();
+        System.out.println("== 2. static final field ==");
+        Field max = Account.class.getField("MAX_DEPOSIT");
+        max.setAccessible(true);
+        try {
+            max.set(null, 5);
+        } catch (IllegalAccessException e) {
+            System.out.println(e.getClass().getSimpleName() + ": " + e.getMessage());
+        }
+
+        System.out.println();
+        System.out.println("== 3. record component ==");
+        Point p = new Point(1, 2);
+        Field x = Point.class.getDeclaredField("x");
+        x.setAccessible(true);
+        try {
+            x.set(p, 99);
+        } catch (IllegalAccessException e) {
+            System.out.println(e.getClass().getSimpleName() + ": " + e.getMessage());
+        }
+
+        System.out.println();
+        System.out.println("== 4. constant inlining: the write 'works' but the getter never notices ==");
+        Limit limit = new Limit();
+        Field f = Limit.class.getDeclaredField("max");
+        f.setAccessible(true);
+        f.set(limit, 99);
+        System.out.println("Field.get -> " + f.get(limit));
+        System.out.println("max()     -> " + limit.max());
+    }
+}

reflection/src/main/java/com/ankurm/reflection/MethodHandlesDemo.java

@@ -0,0 +1,95 @@
+package com.ankurm.reflection;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+import java.lang.invoke.VarHandle;
+import java.lang.invoke.WrongMethodTypeException;
+
+/** Sections 5-6: MethodHandles and VarHandles - same jobs as reflection, checked at lookup time. */
+public class MethodHandlesDemo {
+
+    public static void main(String[] args) throws Throwable {
+        MethodHandles.Lookup lookup = MethodHandles.lookup();
+        Account acct = new Account("erin", 50);
+
+        System.out.println("== 1. Look up once, call many times ==");
+        MethodHandle twice = lookup.findStatic(Account.class, "twice",
+                MethodType.methodType(int.class, int.class));
+        int r = (int) twice.invokeExact(21);
+        System.out.println("twice(21)        = " + r);
+
+        MethodHandle balance = lookup.findVirtual(Account.class, "balance",
+                MethodType.methodType(long.class));
+        long b = (long) balance.invokeExact(acct);
+        System.out.println("balance()        = " + b);
+        System.out.println("handle type      = " + balance.type());
+
+        System.out.println();
+        System.out.println("== 2. invokeExact is exact; invoke adapts ==");
+        try {
+            Object o = (Object) balance.invokeExact(acct);
+            System.out.println(o);
+        } catch (WrongMethodTypeException e) {
+            System.out.println("invokeExact, wrong return type -> " + e.getClass().getSimpleName());
+            System.out.println("  " + e.getMessage());
+        }
+        Object boxed = balance.invoke(acct);
+        System.out.println("invoke (boxing)  = " + boxed + " (" + boxed.getClass().getSimpleName() + ")");
+
+        System.out.println();
+        System.out.println("== 3. Handles compose ==");
+        MethodHandle bound = balance.bindTo(acct);
+        System.out.println("bindTo(acct)     = " + (long) bound.invokeExact());
+        MethodHandle deposit = lookup.findVirtual(Account.class, "deposit",
+                MethodType.methodType(void.class, long.class));
+        MethodHandle deposit10 = MethodHandles.insertArguments(deposit, 1, 10L);
+        deposit10.invokeExact(acct);
+        System.out.println("after deposit10  = " + acct);
+        MethodHandle asText = MethodHandles.filterReturnValue(balance,
+                lookup.findStatic(String.class, "valueOf", MethodType.methodType(String.class, long.class)));
+        String text = (String) asText.invokeExact(acct);
+        System.out.println("balance as text  = \"" + text + "\"");
+
+        System.out.println();
+        System.out.println("== 4. Access is checked when you look up, not when you call ==");
+        try {
+            lookup.findVirtual(Account.class, "secret", MethodType.methodType(String.class));
+        } catch (IllegalAccessException e) {
+            System.out.println("findVirtual(private) -> " + e.getClass().getSimpleName());
+            System.out.println("  " + e.getMessage());
+        }
+        MethodHandles.Lookup priv = MethodHandles.privateLookupIn(Account.class, lookup);
+        MethodHandle secret = priv.findVirtual(Account.class, "secret", MethodType.methodType(String.class));
+        System.out.println("privateLookupIn      -> " + (String) secret.invokeExact(acct));
+        try {
+            MethodHandles.privateLookupIn(String.class, lookup);
+        } catch (IllegalAccessException e) {
+            System.out.println("privateLookupIn(String) -> " + e.getClass().getSimpleName());
+            System.out.println("  " + e.getMessage());
+        }
+
+        System.out.println();
+        System.out.println("== 5. VarHandle: typed, atomic field access ==");
+        VarHandle vh = priv.findVarHandle(Account.class, "balance", long.class);
+        System.out.println("get              = " + (long) vh.get(acct));
+        boolean won = vh.compareAndSet(acct, 60L, 100L);
+        System.out.println("CAS(60 -> 100)   = " + won + ", balance now " + acct.balance());
+        boolean lost = vh.compareAndSet(acct, 60L, 200L);
+        System.out.println("CAS(60 -> 200)   = " + lost + ", balance now " + acct.balance());
+        long prev = (long) vh.getAndAdd(acct, 5L);
+        System.out.println("getAndAdd(5)     = was " + prev + ", now " + acct.balance());
+
+        VarHandle ownerVh = priv.findVarHandle(Account.class, "owner", String.class);
+        try {
+            ownerVh.set(acct, "mallory");
+        } catch (UnsupportedOperationException e) {
+            System.out.println("set on final field -> " + e.getClass().getSimpleName());
+        }
+
+        VarHandle arr = MethodHandles.arrayElementVarHandle(int[].class);
+        int[] counts = new int[3];
+        arr.getAndAdd(counts, 1, 7);
+        System.out.println("array element CAS-able: counts[1] = " + counts[1]);
+    }
+}

reflection/src/main/java/com/ankurm/reflection/ModuleRulesDemo.java

@@ -0,0 +1,37 @@
+package com.ankurm.reflection;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.InaccessibleObjectException;
+
+/**
+ * Section 3: setAccessible is not a master key. Your own classes are open to you; the JDK's
+ * internals are not unless the command line says so (--add-opens).
+ */
+public class ModuleRulesDemo {
+
+    public static void main(String[] args) throws Exception {
+        System.out.println("== setAccessible on your own class ==");
+        Field owner = Account.class.getDeclaredField("owner");
+        owner.setAccessible(true);
+        System.out.println("Account.owner = " + owner.get(new Account("carol", 1)));
+
+        System.out.println();
+        System.out.println("== setAccessible on a JDK private field ==");
+        Module javaBase = String.class.getModule();
+        Module me = ModuleRulesDemo.class.getModule();
+        System.out.println("String lives in module : " + javaBase.getName());
+        System.out.println("we live in module      : " + me + " (unnamed=" + !me.isNamed() + ")");
+        System.out.println("java.lang open to us   : " + javaBase.isOpen("java.lang", me));
+
+        Field value = String.class.getDeclaredField("value");
+        System.out.println("trySetAccessible       : " + value.trySetAccessible());
+        try {
+            value.setAccessible(true);
+            Object bytes = value.get("abc");
+            System.out.println("setAccessible worked, String.value is a " + bytes.getClass().getSimpleName());
+        } catch (InaccessibleObjectException e) {
+            System.out.println("setAccessible threw    : " + e.getClass().getSimpleName());
+            System.out.println("  " + e.getMessage());
+        }
+    }
+}

reflection/src/main/java/com/ankurm/reflection/QuickStart.java

@@ -0,0 +1,31 @@
+package com.ankurm.reflection;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+import java.lang.reflect.Method;
+
+/**
+ * The smallest useful tour: one class, called by reflection and by a MethodHandle.
+ * Self-contained - run it with:  java QuickStart.java
+ */
+public class QuickStart {
+
+    public static class Greeter {
+        public String greet(String name) {
+            return "Hello, " + name;
+        }
+    }
+
+    public static void main(String[] args) throws Throwable {
+        Greeter g = new Greeter();
+
+        Method m = Greeter.class.getMethod("greet", String.class);
+        System.out.println("reflection   : " + m.invoke(g, "Ankur"));
+
+        MethodHandle h = MethodHandles.lookup().findVirtual(Greeter.class, "greet",
+                MethodType.methodType(String.class, String.class));
+        String s = (String) h.invokeExact(g, "Ankur");
+        System.out.println("MethodHandle : " + s);
+    }
+}

reflection/src/main/java/com/ankurm/reflection/ReflectionBasicsDemo.java

@@ -0,0 +1,72 @@
+package com.ankurm.reflection;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.Arrays;
+import java.util.Comparator;
+
+/** Section 1-2 of the post: inspect a class, call things, and see the exceptions you will meet. */
+public class ReflectionBasicsDemo {
+
+    public static void main(String[] args) throws Exception {
+        Class<?> c = Account.class;
+
+        System.out.println("== 1. Inspect the class ==");
+        System.out.println("class: " + c.getName());
+        Method[] methods = c.getDeclaredMethods();
+        Arrays.sort(methods, Comparator.comparing(Method::getName));
+        for (Method m : methods) {
+            System.out.println("  " + Modifier.toString(m.getModifiers()) + " "
+                    + m.getReturnType().getSimpleName() + " " + m.getName()
+                    + Arrays.toString(m.getParameterTypes()));
+        }
+
+        System.out.println();
+        System.out.println("== 2. Create and call ==");
+        Constructor<?> ctor = c.getConstructor(String.class, long.class);
+        Object account = ctor.newInstance("alice", 50L);
+        System.out.println("created: " + account);
+
+        Method deposit = c.getMethod("deposit", long.class);
+        deposit.invoke(account, 25L);
+        System.out.println("after deposit(25): " + account);
+
+        System.out.println();
+        System.out.println("== 3. The exceptions you will meet ==");
+        try {
+            c.getMethod("nope");
+        } catch (NoSuchMethodException e) {
+            System.out.println("wrong name        -> " + e.getClass().getSimpleName() + ": " + e.getMessage());
+        }
+        try {
+            deposit.invoke(account, "twenty");
+        } catch (IllegalArgumentException e) {
+            System.out.println("wrong arg type    -> " + e.getClass().getSimpleName() + ": " + e.getMessage());
+        }
+        try {
+            deposit.invoke(account, 5_000L);
+        } catch (InvocationTargetException e) {
+            System.out.println("method threw      -> " + e.getClass().getSimpleName()
+                    + " wrapping " + e.getCause());
+        }
+
+        Method secret = c.getDeclaredMethod("secret");
+        try {
+            secret.invoke(account);
+        } catch (IllegalAccessException e) {
+            System.out.println("private, no opt-in -> " + e.getClass().getSimpleName() + ": " + e.getMessage());
+        }
+        secret.setAccessible(true);
+        System.out.println("after setAccessible(true): " + secret.invoke(account));
+
+        System.out.println();
+        System.out.println("== 4. What reflection adds to the stack ==");
+        Account a = new Account("bob", 0);
+        System.out.println("direct call:");
+        for (String f : a.stack()) System.out.println("  " + f);
+        System.out.println("through Method.invoke:");
+        for (String f : (String[]) c.getMethod("stack").invoke(a)) System.out.println("  " + f);
+    }
+}

reflection/src/test/java/com/ankurm/reflection/ReflectionContractTest.java

@@ -0,0 +1,101 @@
+package com.ankurm.reflection;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+import java.lang.invoke.VarHandle;
+import java.lang.invoke.WrongMethodTypeException;
+import java.lang.reflect.Field;
+import java.lang.reflect.InaccessibleObjectException;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import org.junit.jupiter.api.Test;
+
+/** Pins the contracts the post claims. If one stops being true on a new JDK, the build fails. */
+class ReflectionContractTest {
+
+    @Test
+    void methodInvokeWrapsTheRealExceptionInInvocationTargetException() throws Exception {
+        Method deposit = Account.class.getMethod("deposit", long.class);
+        InvocationTargetException e = assertThrows(InvocationTargetException.class,
+                () -> deposit.invoke(new Account(), 5_000L));
+        assertEquals(IllegalArgumentException.class, e.getCause().getClass());
+    }
+
+    @Test
+    void privateMethodNeedsSetAccessibleEvenInTheSamePackage() throws Exception {
+        Method secret = Account.class.getDeclaredMethod("secret");
+        assertThrows(IllegalAccessException.class, () -> secret.invoke(new Account("x", 0)));
+        secret.setAccessible(true);
+        assertEquals("secret-of-x", secret.invoke(new Account("x", 0)));
+    }
+
+    @Test
+    void jdkInternalsAreClosedWithoutAddOpens() throws Exception {
+        Field value = String.class.getDeclaredField("value");
+        assertFalse(value.trySetAccessible());
+        assertThrows(InaccessibleObjectException.class, () -> value.setAccessible(true));
+    }
+
+    @Test
+    void staticFinalAndRecordFieldsCannotBeSetEvenAfterSetAccessible() throws Exception {
+        Field max = Account.class.getField("MAX_DEPOSIT");
+        max.setAccessible(true);
+        assertThrows(IllegalAccessException.class, () -> max.set(null, 5));
+
+        Field x = FinalFieldDemo.Point.class.getDeclaredField("x");
+        x.setAccessible(true);
+        assertThrows(IllegalAccessException.class, () -> x.set(new FinalFieldDemo.Point(1, 2), 9));
+    }
+
+    @Test
+    void invokeExactRejectsAMismatchedReturnTypeButInvokeAdapts() throws Throwable {
+        MethodHandle balance = MethodHandles.lookup().findVirtual(Account.class, "balance",
+                MethodType.methodType(long.class));
+        Account a = new Account("a", 7);
+        assertEquals(7L, (long) balance.invokeExact(a));
+        assertThrows(WrongMethodTypeException.class, () -> {
+            Object o = (Object) balance.invokeExact(a);
+        });
+        assertEquals(7L, balance.invoke(a));
+    }
+
+    @Test
+    void methodHandleAccessIsCheckedAtLookupTime() throws Throwable {
+        MethodHandles.Lookup lookup = MethodHandles.lookup();
+        assertThrows(IllegalAccessException.class, () -> lookup.findVirtual(Account.class, "secret",
+                MethodType.methodType(String.class)));
+        MethodHandle secret = MethodHandles.privateLookupIn(Account.class, lookup)
+                .findVirtual(Account.class, "secret", MethodType.methodType(String.class));
+        assertEquals("secret-of-nobody", (String) secret.invokeExact(new Account()));
+    }
+
+    @Test
+    void varHandleOnFinalFieldIsReadOnlyAndCasWorksOnPlainField() throws Throwable {
+        MethodHandles.Lookup priv = MethodHandles.privateLookupIn(Account.class, MethodHandles.lookup());
+        VarHandle owner = priv.findVarHandle(Account.class, "owner", String.class);
+        assertThrows(UnsupportedOperationException.class, () -> owner.set(new Account(), "x"));
+
+        VarHandle bal = priv.findVarHandle(Account.class, "balance", long.class);
+        Account a = new Account("a", 60);
+        assertTrue(bal.compareAndSet(a, 60L, 100L));
+        assertFalse(bal.compareAndSet(a, 60L, 200L));
+        assertEquals(100L, a.balance());
+    }
+
+    @Test
+    void reflectionAddsFramesToTheStack() throws Exception {
+        Account a = new Account();
+        String[] direct = a.stack();
+        String[] viaReflection = (String[]) Account.class.getMethod("stack").invoke(a);
+        // Frame 0 is Account.stack. Frame 1 is the caller: the test directly, an accessor via reflection.
+        assertEquals(ReflectionContractTest.class.getName() + ".reflectionAddsFramesToTheStack", direct[1]);
+        assertEquals("jdk.internal.reflect.DirectMethodHandleAccessor.invoke", viaReflection[1]);
+        assertEquals("java.lang.reflect.Method.invoke", viaReflection[2]);
+    }
+}