JDK vs JRE vs JVM: How Java Code Runs

"Why is Java platform-independent?" is very often the first Java interview question, and "What is the difference between the JDK, JRE and JVM?" is usually the second. This article gives you precise answers to both.

The interview-ready answer

Java is a high-level, class-based, object-oriented language. It is platform independent because of its "write once, run anywhere" design: the compiler (javac) does not produce machine code for one specific operating system. It produces bytecode in .class files, and any machine with a Java Virtual Machine (JVM) can run that bytecode.

So: Java (the language and its bytecode) is platform independent. The JVM is platform dependent, because each operating system and CPU needs its own JVM build.

From source code to a running program

  Hello.java  --(javac)-->  Hello.class  --(JVM on Windows, Linux or macOS)-->  machine code
   (source)                  (bytecode)       class loader, verifier, interpreter + JIT

1. Compile: javac Hello.java turns source code into bytecode (Hello.class).
2. Load and verify: the JVM's class loader loads the bytecode, and the bytecode verifier checks that it is safe (valid types, no illegal jumps, no stack corruption).
3. Execute: the JVM first interprets the bytecode. For code that runs often (the "hot spots") the JIT (just-in-time) compiler produces optimized native machine code and keeps it for later calls. That is why Java is far faster than a purely interpreted language.

javac Hello.java          # compile: produces Hello.class
java Hello                # run the compiled class
java Hello.java           # shortcut since Java 11: compile in memory and run a single source file
javap -c Hello            # disassemble the bytecode to see what javac produced

JDK vs JRE vs JVM

A simple way to remember it: JDK contains JRE, and JRE contains JVM.

In practice you install a JDK. Oracle stopped publishing a separate JRE from Java 11 (some vendors still offer JRE packages), and the jlink tool can build a small custom runtime containing only the modules your application needs. "JVM" is a specification with several implementations: HotSpot is the default, and OpenJ9 and GraalVM are alternatives.

Seeing the platform dependence

The same compiled class prints different operating-system and JVM lines on different machines, while your code never changed.

The main method, word by word

Every part of that signature has a reason:

• : the JVM must be able to call it from outside the class.
• : the JVM calls it before any object exists, so it cannot belong to an instance.
• : it returns nothing to the JVM.
• : the command-line arguments.

Java 25 relaxes this for beginners (instance methods and compact source files), but interviews still use the classic form.

Java versions you should know

Java releases a new version every six months, and some are marked LTS (long-term support) because companies stay on them for years. The LTS versions are 8, 11, 17, 21 and 25. Java 8 introduced lambdas and streams, and many codebases still run on it. Records arrived in Java 16 and sealed classes in Java 17, Java 21 made virtual threads final, and Java 25 is the newest LTS. The examples in this collection are written for Java 21 and run on later versions.

Common wrong answers

• "Both Java and the JVM are platform independent." Only Java (the bytecode) is. A Windows JVM will not run on Linux.
• "Java is 100% object-oriented." The eight primitive types (, , and so on) are not objects.
• "The JDK and JRE are the same." The JDK adds the compiler and development tools.

Follow-up questions

• If bytecode is interpreted, why is Java not slow? Because of the JIT compiler: hot code is compiled to native instructions at run time.
• Is C or C++ platform independent? No. Their compilers produce native machine code for one operating system and CPU, so you must recompile for each target.
• What does the class loader do? It finds and loads files into memory when they are first needed, following a parent-first delegation model.

Practise

1. Run the example above and compare the output with a friend on a different operating system.
2. Compile a small class with , then run on it and find your method in the bytecode.
3. Take the Fundamentals, Strings and OOP quiz after you finish the next two articles.