Understanding Java Bytecode Structure, Class Loading, and Method Invocation

Java source files (.java) are compiled into bytecode (.class) which the ClassLoader loads into the JVM. A class file contains a magic number, version numbers, a constant pool, access flags, this_class, super_class, interfaces, fields, methods, and attributes that describe the class structure.

The article introduces the basic class file layout, referencing the official JVM specification (https://docs.oracle.com/javase/specs/jvms/se11/html/jvms-4.html) and shows a diagram of the structure.

Key components are described:

magic : 0xCAFEBABE identifies a class file.

major_version and minor_version : indicate the JDK version used for compilation.

constant_pool_count and constant_pool : store literals, class names, field names, etc.

access_flags : define class or interface modifiers.

this_class and super_class : indexes into the constant pool.

interfaces_count and interfaces : list of directly implemented interfaces.

fields_count and fields : describe declared fields.

methods_count and methods : describe declared methods.

attributes_count and attributes : additional metadata such as SourceFile .

To explore bytecode without manual binary comparison, the article recommends the asmtools utility (https://wiki.openjdk.java.net/display/CodeTools/asmtools). A compiled JAR is provided, and the command:

java -jar asmtools-7.0.jar jdec LambdaDemo.class

produces a readable JCOD representation that matches the class file structure.

For runtime inspection, the article introduces the JDK 9+ debugging tool jhsdb . By attaching to a Java process with jhsdb hsdb , developers can browse loaded classes, view method tables, and examine memory layouts via the Class Browser and Inspector views.

Method invocation in Java uses five bytecode instructions:

invokestatic – static methods.

invokevirtual – most instance methods.

invokeinterface – interface methods.

invokespecial – private methods, constructors, super calls.

invokedynamic – dynamic call sites (e.g., lambdas).

Examples show how a sample class InvokeDemo compiles to bytecode, highlighting the use of invokevirtual versus invokeinterface when calling interface methods.

The article explains the dynamic binding process of invokevirtual , including method lookup, access checks, and possible exceptions ( IllegalAccessError , AbstractMethodError ), contrasted with static binding performed by invokestatic and invokespecial .

It then covers invokedynamic , showing how lambda expressions compile to this instruction and rely on a BootstrapMethods attribute that references a call site created by LambdaMetafactory . The underlying mechanism uses MethodHandle objects.

An example using MethodHandle demonstrates dynamic method invocation on unrelated classes ( Bike , Animal , Man ) by looking up a virtual method named sound at runtime.

Finally, the article summarizes that understanding the class file format, using tools like asmtools and jhsdb , and mastering the different invocation instructions are essential for deep JVM performance tuning and debugging.