How Java runs: interview questions & scenarios

Model answer

They're nested: JDK ⊃ JRE ⊃ JVM. The JVM executes bytecode: class loading, verification, the interpreter, the JIT compilers and the garbage collector. The JRE is the JVM plus the standard class library (java.base, java.sql and so on): enough to run a program. The JDK adds the tools to build and diagnose: javac, jar, jshell, jlink, jcmd, jfr. Since Java 11 there's no separate JRE download; you install a JDK or build a trimmed runtime with jlink.

Model answer

Both, at two different times. javac compiles source to bytecode ahead of time. At runtime the JVM starts by interpreting that bytecode and profiling it; methods that get hot are compiled to native machine code by the JIT. HotSpot uses tiered compilation (default since Java 8): tier 0 is the interpreter, tier 3 is C1 with profiling (after roughly 200 invocations), tier 4 is C2 with aggressive optimisation (after roughly 5,000).

Model answer

public class Q {
    public static void main(String[] args) {
        System.out.println("start");
        System.out.println(Settings.MAX);
        System.out.println(Settings.BOXED);
    }
}

class Settings {
    static final int MAX = 100;
    static final Integer BOXED = 7;
    static { System.out.println("Settings init"); }
}

It prints start, 100, Settings init, 7. MAX is a compile-time constant (a static final primitive or String initialized with a constant expression), so javac copies 100 into Q's bytecode and Settings isn't touched. BOXED is an Integer, which is never a constant variable, so reading it is a real getstatic that triggers initialization: <clinit> runs the static block first, then the value prints.

Model answer

The launcher looks up main by name and descriptor and calls it. public so it's reachable from outside the class, static because no instance exists at startup, void because the exit status comes from System.exit (or 0 on normal completion, 1 after an uncaught exception), and String[] args for command-line arguments. Drop static and the class still compiles; on Java 21 java prints Error: Main method is not static in class X and exits with 1.

Model answer

public class Shutdown {
    public static void main(String[] args) {
        Runtime.getRuntime().addShutdownHook(new Thread(() -> System.out.println("C")));
        try {
            System.out.println("A");
            System.exit(0);
        } finally {
            System.out.println("B");
        }
    }
}

It prints A then C, and the status is 0. System.exit starts the shutdown sequence and never returns, so the finally block never runs. Shutdown hooks do run. Remove the System.exit call and you'd see A, B, C: hooks also run on a normal exit.

Model answer

Three built-in loaders: bootstrap (native, loads java.base, shows up as null), platform (Java 9+, loads modules like java.sql) and application (class path and module path). They use parent-first delegation: a loader asks its parent before searching itself. A request for java.lang.String always reaches the bootstrap loader, which finds the real one. Since Java 9 it's stricter: the java.lang package belongs to the java.base module, so javac rejects your file with package exists in another module: java.base.

Model answer

Every class file stores a major version: 52 for Java 8, 61 for Java 17, 65 for Java 21. A JVM refuses a newer one: class file version 65.0, this version of the Java Runtime only recognizes class file versions up to 61.0 means Java 21 bytecode on a Java 17 runtime. Fix it by upgrading the runtime, or by compiling with javac --release 17 (or setting the release in Maven/Gradle).

Model answer

In order: the magic number 0xCAFEBABE, minor and major version, the constant pool, access flags, this class, super class, interfaces, fields, methods (with their Code attributes holding bytecode) and attributes such as SourceFile. The constant pool is a symbol table: UTF-8 strings, class names, NameAndType pairs and field/method references. Bytecode refers to it by index, like invokevirtual #15, so a call names its target symbolically (java/io/PrintStream.println:(Ljava/lang/String;)V) and the JVM resolves it to a real reference at runtime.

Model answer

ClassNotFoundException is a checked exception from explicit loading by name, such as Class.forName("com.acme.Driver") or loader.loadClass(...), when no loader can find it. NoClassDefFoundError is an error thrown when the JVM implicitly needs a class that was present at compile time but can't be provided at runtime. One common cause isn't a missing file at all: if a static initializer throws, the first access gets ExceptionInInitializerError, and every later access gets NoClassDefFoundError: Could not initialize class X.

public class Broken {
    public static void main(String[] args) {
        for (int i = 0; i < 2; i++) {
            try {
                System.out.println(Cfg.VALUE);
            } catch (Throwable t) {
                System.out.println(t);
            }
        }
    }
}

class Cfg {
    static int VALUE = Integer.parseInt("not a number");
}

This prints java.lang.ExceptionInInitializerError, then java.lang.NoClassDefFoundError: Could not initialize class Cfg.

Model answer

That's JVM warm-up. Classes load and initialize lazily on the first requests, code runs in the interpreter, and C1 and C2 compile hot paths only after thousands of calls, so early latency can be several times the steady state. Options, in the order I'd try them: send warm-up traffic before the readiness probe passes; use a CDS/AppCDS archive to cut class loading time; on JDK 24+ use the AOT cache (JEP 483) from a training run; make sure the container has enough CPU at startup for the JIT compiler threads; and, if startup dominates everything, consider a GraalVM native image, accepting lower peak throughput.

Model answer

public class Sum {
    public static void main(String[] args) {
        if (args.length == 0) {
            System.err.println("usage: java Sum <int>...");
            System.exit(2);
        }
        long total = 0;
        for (String arg : args) {
            try {
                total += Integer.parseInt(arg.trim());
            } catch (NumberFormatException e) {
                System.err.println("not an integer: " + arg);
                System.exit(2);
            }
        }
        System.out.println(total);
    }
}

java Sum.java 1 2 3 prints 6 and exits 0; java Sum.java 1 x prints the error to standard error and exits 2. Usage and errors go to System.err so scripts can pipe the real output cleanly. A long accumulator avoids overflow when summing many int values.

Model answer

Yes since Java 25, where JEP 512 (Compact Source Files and Instance Main Methods) is final. A file can contain only void main() { ... }; the compiler wraps it in an implicitly declared final class, and the launcher creates an instance and calls main. It was a preview in Java 21 (JEP 445, "unnamed classes"), 22, 23 and 24, so on Java 21 it needs --enable-preview (for example java --enable-preview --source 21 Hi.java). Java 25 also adds java.lang.IO for IO.println, and compact files automatically import the public classes of java.base.