How Java Works: Compilation, Bytecode, JVM & JIT Explained

One of the most important things to understand as a Java beginner is what actually happens after you write a Java program. You write source code, but the computer does not normally execute that source code directly. Java uses a multi-step process involving the Java compiler, bytecode, the JVM, and the operating system.

Once this workflow becomes clear, many Java concepts that initially seem unrelated—such as JDK, JRE, JVM, bytecode, compilation, and JIT—start fitting together like pieces of the same puzzle.

The Big Picture

The basic Java execution process can be represented like this:

Java Source Code
       ↓
    Compiler
       ↓
 Java Bytecode
       ↓
      JVM
       ↓
JIT / Runtime Execution
       ↓
 Operating System
       ↓
    Hardware

The important point is that Java separates compilation from execution. The Java compiler converts source code into bytecode, and the JVM provides the environment that executes that bytecode.

Step 1: Write Java Source Code

The process begins when a developer writes Java source code in a file with the .java extension.

public class Main {

    public static void main(String[] args) {
        System.out.println("Hello, Java!");
    }
}

At this stage, the code is simply human-readable source code. The operating system cannot normally execute this Java source file directly as a native program.

Step 2: Compile the Source Code

The Java Development Kit provides the javac compiler. The compiler reads the Java source code and checks whether it follows Java's language rules.

javac Main.java

If the source code is valid, the compiler produces a .class file containing Java bytecode.

Main.java
   ↓
javac Main.java
   ↓
Main.class

If there are compilation errors, the compiler reports them and the class file is not successfully produced for that compilation.

What Is Bytecode?

Bytecode is an intermediate representation of a Java program. It is not the original Java source code, and it is not the same thing as native machine code generated specifically for one processor.

Bytecode is designed to be understood by the JVM. This intermediate layer is a major reason Java can provide strong portability across supported platforms.

Remember: .java contains source code, while .class normally contains compiled Java bytecode.

Step 3: Start the JVM

After compilation, you can run the Java program using the Java launcher.

java Main

This starts the Java runtime environment and loads the required class into the JVM.

The JVM is responsible for providing the execution environment in which Java bytecode can run. It manages important runtime activities such as class loading, memory management, bytecode execution, and garbage collection.

Step 4: Class Loading

Before a Java class can execute, the JVM needs to load it. The Class Loader subsystem is responsible for loading classes into the JVM when they are needed.

This does not simply mean copying a file into memory. The JVM performs a series of runtime steps to make the class available for execution.

Main.class
    ↓
Class Loader
    ↓
Class available inside JVM
    ↓
Runtime processing

The class-loading system is also important for Java's dynamic nature because classes can be loaded as an application requires them.

Step 5: Bytecode Verification

The JVM can verify loaded bytecode before execution. Verification helps ensure that the bytecode follows important structural and safety rules expected by the JVM.

This is one part of Java's managed execution model. The JVM does not simply trust every sequence of bytes as valid executable code.

Bytecode verification is only one part of Java's security model. A secure application still requires secure coding practices, correct authentication and authorization, safe dependencies, and proper system configuration.

Step 6: Memory Is Prepared

During execution, the JVM manages memory for the running application. Different areas of JVM memory have different responsibilities.

For example, the heap is commonly used for objects and arrays, while each thread has its own stack used for method calls and local variables.

JVM Memory
   |
   +-- Heap
   |     └── Objects and Arrays
   |
   +-- Stack
   |     └── Method Calls and Local Variables
   |
   +-- Other Runtime Areas
         └── Class and execution information

You will study JVM memory in much greater detail later. For now, remember that the JVM manages the runtime memory required by the application.

Step 7: JVM Executes Bytecode

Now the JVM begins executing the bytecode. A simplified explanation is that the JVM can interpret bytecode instructions and execute them through the runtime environment.

However, modern JVMs are much more sophisticated than a simple bytecode interpreter.

Step 8: JIT Compilation

Modern JVM implementations can use Just-In-Time (JIT) compilation to improve performance.

When the JVM identifies code that executes frequently, it can compile suitable portions into optimized native machine instructions while the application is running.

Bytecode
   ↓
JVM Execution
   ↓
Frequently executed code
   ↓
JIT Compiler
   ↓
Optimized Native Instructions
   ↓
CPU

This is an important reason modern Java applications can achieve strong performance despite using a virtual machine.

Important distinction: The Java compiler javac normally creates bytecode before execution. The JIT compiler works at runtime and can compile frequently executed bytecode into optimized native code.

Step 9: The CPU Executes Instructions

Eventually, the actual processor must execute machine instructions. The JVM acts as the runtime layer between Java bytecode and the underlying operating system and hardware.

This architecture gives Java a useful combination of portability and runtime optimization.

Java Code
   ↓
Bytecode
   ↓
JVM
   ↓
Native Instructions
   ↓
CPU

What Happens When main() Runs?

For a traditional standalone Java application, the Java launcher identifies the application's entry point and invokes the appropriate main() method.

public static void main(String[] args) {
    System.out.println("Hello, Java!");
}

The JVM executes the statements inside the method according to Java's execution rules. In this example, the output operation sends the text to the standard output stream, which normally appears in the console.

Complete Java Execution Flow

Stage	What Happens	Main Component
1. Write	Developer creates Java source code.	Developer / Editor
2. Compile	Source code is checked and converted into bytecode.	javac Compiler
3. Load	Required classes are loaded into the JVM.	Class Loader
4. Verify	Loaded bytecode is checked according to JVM rules.	JVM
5. Execute	Bytecode is executed by the runtime.	JVM
6. Optimize	Frequently executed code can be optimized and compiled.	JIT Compiler
7. Run	Native instructions are executed by the processor.	CPU

Where Does the JDK Fit?

The JDK, or Java Development Kit, is the development environment used to create Java applications. It includes tools such as the Java compiler and the Java launcher, along with the Java runtime components needed for development.

A simple mental model is:

JDK
 |
 +-- javac
 |     └── Compiles Java source
 |
 +-- java
 |     └── Launches Java applications
 |
 +-- Java Runtime
       └── Provides runtime components

The exact contents and packaging details can vary between Java distributions and versions, but the key idea remains: the JDK is what developers use to build Java software.

Compilation vs Execution

One of the most important distinctions in Java is the difference between compilation and execution.

Compilation	Execution
Converts source code into bytecode.	Runs the bytecode.
Normally performed before the application starts.	Occurs when the application is running.
Uses the Java compiler.	Uses the JVM.
Produces class files.	Produces the application's runtime behavior.

Keeping these two stages separate will help you understand many compiler errors, runtime errors, class-loading problems, and JVM concepts later in your Java journey.

What If There Is a Compilation Error?

Suppose you write:

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello Java")
    }
}

The semicolon is missing after the println() statement. The compiler detects the syntax problem and reports an error.

This is a compile-time problem. The program must be successfully compiled before the resulting class can be executed normally.

What If There Is a Runtime Error?

A program can compile successfully and still encounter a problem while running.

public class Main {
    public static void main(String[] args) {
        int result = 10 / 0;
        System.out.println(result);
    }
}

The syntax is valid, so the compiler can compile the program. However, attempting to divide an integer by zero causes an exception during execution.

This demonstrates an important difference: successful compilation does not guarantee successful execution.

Why Is Java Platform Independent?

Java's platform independence comes from the separation between bytecode and the platform-specific JVM implementation.

The same Java bytecode can be used on different operating systems when compatible JVM implementations are available.

                 Java Source
                      ↓
                   Bytecode
                      ↓
          +-----------+-----------+
          ↓           ↓           ↓
       JVM/Windows  JVM/Linux   JVM/macOS
          ↓           ↓           ↓
       Platform    Platform    Platform

The JVM implementation handles the differences between the underlying platforms while presenting a consistent runtime environment to the Java application.

Common Beginner Mistakes

• Thinking Java source code runs directly on the operating system.
• Thinking bytecode and machine code are the same thing.
• Confusing the javac compiler with the JVM.
• Thinking the JIT compiler creates the original .class file. The standard Java compiler creates the class file; JIT compilation happens during runtime.
• Assuming successful compilation means the application cannot fail at runtime.
• Thinking the JVM is exactly the same software on every operating system. JVM implementations are platform-specific while providing a common execution model.

Learning Checkpoint

Close your editor for a moment and explain the complete journey of a Java program from memory: .java → compiler → .class bytecode → JVM → runtime execution → CPU.

If you can explain what happens at each stage, you have understood one of the most important foundations of the Java platform.

Interview Insight

A very common interview question is: "How does Java work?" A strong answer should explain that Java source code is compiled by javac into bytecode stored in class files. The JVM then loads, verifies, and executes that bytecode. Modern JVMs can use JIT compilation to optimize frequently executed code into native machine instructions.

Interview-ready answer: Java achieves portability by compiling source code into platform-independent bytecode and executing that bytecode through a platform-specific JVM. The JVM handles runtime services and can use JIT compilation to improve performance.

Final Summary

Java works through a carefully designed sequence of compilation and runtime execution. Developers write source code in a .java file, the Java compiler converts it into bytecode stored in a .class file, and the JVM loads, verifies, and executes that bytecode. During execution, the JVM manages runtime resources and can use JIT compilation to optimize frequently executed code into native instructions. This separation between Java source code, bytecode, the JVM, and the underlying platform is the foundation of Java's portability, flexibility, and runtime performance.