How Java code runs: source → bytecode → JVM

What happens to ₹20 × 3?

How does a Java program run?

Words you'll meet in this lesson

The journey at a glance

The stages, and the different ways to run Java

Inside javac: four compile phases

Inside the JVM: load, link, initialise, execute

Four ways to run Java code

Follow the chai bill through every stage

1. Write the source

   public class Main {
       public static void main(String[] args) {
           int price = 20;
           int cups = 3;
           int total = price * cups;
           System.out.println("Total: Rs " + total);
       }
   }

   Total: Rs 60
   On disk this is just characters. Nothing has been checked yet.

2. Compile it

   javac Main.java

   javac runs its four phases: tokens → syntax tree → type and name checks → bytecode. Silence means success, and Main.class (861 bytes with JDK 21) appears.

3. Look at the bytecode

   javap -c Main

   public static void main(java.lang.String[]); Code: 0: bipush 20 2: istore_1 3: iconst_3 4: istore_2 5: iload_1 6: iload_2 7: imul 8: istore_3 9: getstatic #7 // Field java/lang/System.out 12: iload_3 13: invokedynamic #13 // makeConcatWithConstants 18: invokevirtual #17 // Method java/io/PrintStream.println 21: return
   Each line is one instruction. bipush 20 pushes 20 onto the operand stack, istore_1 stores it in local variable slot 1 (price), imul multiplies the top two values. The numbers on the left are byte offsets. javap also shows a Main() constructor that javac added for you.

4. Run it

   java Main

   Total: Rs 60
   The JVM starts and loads hundreds of core classes (about 540 for this program on JDK 21) before Main itself. You can watch them with java -Xlog:class+load Main. Then Main is linked, initialised and main is interpreted.

5. Hot code gets compiled

   Our chai bill runs once, so it is simply interpreted. But if a method runs thousands of times, as in a server handling requests, the JIT steps in.

   HotSpot uses tiered compilation: a quick compiler (C1) compiles warm methods first, and an optimising compiler (C2) recompiles the hottest ones with deeper optimisations. You can watch it with java -XX:+PrintCompilation Main.

From keyboard to CPU: both views

Step through each stage. Left: what Riya sees. Right: what javac and the JVM are doing.

Compile-time errors vs run-time errors

Where this pipeline matters at work

Knowing what happens between javac and the CPU helps you build, deploy and speed up real systems.

Watch it with an example: the JIT warms up a busy method

A billing server calls gst(price) again and again. Watch the JVM start by interpreting it, then compile it to machine code once it becomes “hot”.

Examples are simplified to show where each stage fits. Real setups vary by company.

Experiment with the pipeline

The chai bill from the story, with notes. Then try the challenges, which show compile-time vs run-time errors, lazy class initialisation and JIT warm-up.

public class Main {
    public static void main(String[] args) {
        int price = 20;
        int cups = 3;
        int total = price * cups;
        System.out.println("Total: Rs " + total);
    }
}

• int price = 20;Bytecode bipush 20, istore_1: push 20, store it in local slot 1.
• int total = price * cups;iload_1, iload_2, imul, istore_3: load both, multiply, store the result in slot 3.
• "Total: Rs " + totalSince Java 9, javac compiles string joining to invokedynamic, letting the JVM choose the fastest way at run time.
• System.out.println(…)getstatic fetches System.out, then invokevirtual calls println.

The chai bill, one bytecode instruction at a time

This tracer goes one level deeper than before. For each source line, the note shows the bytecode the JVM executes, and the stack shows the method's local variable slots.

Worked examples: real problems, solved and traced in memory

Your .java file is compiled to bytecode once, and the JVM runs it statement by statement. In these three programs, watch the order: each line runs only after the one before it, and every method call gets its own frame on the stack.

140 chai × 12, 60 samosa × 15, cost 1100

Income: Rs 2580
Profit: Rs 1480

prices 500 and 1200

Bag: Rs 590
Shoes: Rs 1416

37.5 °C

37.5 C = 99.5 F

Check yourself

Quick revision

Interview and viva questions

Practice problems

Programs whose results depend on the order statements run in. Trace each one in your head before running it. The last three are business tasks.

(none)

Step 1
Step 2
Step 3

public class Main {
    public static void main(String[] args) {
        System.out.println("Step 1");
        System.out.println("Step 2");
        System.out.println("Step 3");
    }
}

10

30

public class Main {
    public static void main(String[] args) {
        int points = 10;
        points = points + 5;
        points = points * 2;
        System.out.println(points);
    }
}

12, 8

Area: 96 sq ft

public class Main {
    public static void main(String[] args) {
        int length = 12;
        int width = 8;
        System.out.println("Area: " + length * width + " sq ft");
    }
}

6, 9

36
81

public class Main {
    static int square(int n) {
        return n * n;
    }

    public static void main(String[] args) {
        System.out.println(square(6));
        System.out.println(square(9));
    }
}

(none)

14
20

public class Main {
    public static void main(String[] args) {
        System.out.println(2 + 3 * 4);
        System.out.println((2 + 3) * 4);
    }
}

360 km, 15 km/l, Rs 105/l

Litres: 24.0
Cost: Rs 2520.0

public class Main {
    public static void main(String[] args) {
        double litres = 360 / 15.0;
        double cost = litres * 105;
        System.out.println("Litres: " + litres);
        System.out.println("Cost: Rs " + cost);
    }
}

25000, 8, 2

Interest: Rs 4000

public class Main {
    public static void main(String[] args) {
        int p = 25000, r = 8, t = 2;
        System.out.println("Interest: Rs " + p * r * t / 100);
    }
}

54 students

Total: Rs 67500
Per student: Rs 1250

public class Main {
    static int total(int students) {
        return 48600 + students * 350;
    }

    public static void main(String[] args) {
        int t = total(54);
        System.out.println("Total: Rs " + t);
        System.out.println("Per student: Rs " + t / 54);
    }
}

Real-world scenario questions (asked in company interviews)

Real problems where knowing the compile → load → run pipeline makes the difference. Decide your answer first, then open the model answer.