Java Introduction: JVM, Compilation, and Hello World

🎯 Learning Objectives

• Explain how Java achieves platform independence via the JVM
• Trace the full compilation and execution pipeline of a Java program
• Write, compile, and run a basic Java program from the command line
• Understand the structure of the main method and its role
• Distinguish between JDK, JRE, and JVM components

📋 Prerequisites

• BSCS1002 — Python Programming: You already know what a programming language is and have written at least one "Hello World" program. Java differs in being compiled (not interpreted) and statically typed (types checked at compile-time, not runtime).
• BSCS1001 — Computational Thinking: Familiarity with what a program, algorithm, and computer execution mean.

1. The "Why" — What Problem Does Java Solve?

1.1 Intuition: Write Once, Run Anywhere

1.2 The Problem Java Solves

• Compile separate executables for each platform
• Test on every OS
• Deal with platform-specific bugs (memory layouts, OS APIs) Java removed this by inserting a virtual machine layer between your program and the hardware.

1.3 Mental Model: The Compilation Pipeline

java
YourCode.java (source)
      │
      ▼  javac (compiler)
YourCode.class (bytecode)
      │
      ▼  java (launcher → JVM)
      JVM interprets/compiles bytecode to machine code
      │
      ▼
      OS / Hardware

2. The Compilation & Execution Pipeline

2.1 Step-by-Step Breakdown

2.2 Why is Bytecode Safe?

• No stack overflow/underflow
• All instructions operate on correct types
• No illegal memory access (unlike C pointers)
• Access to private members is prevented This is why Java is considered memory-safe — it prevents whole categories of bugs that plague C/C++.

2.3 Mental Model: JIT Compilation

pseudo
Hot method detected (runs frequently)
        │
        ▼
JIT compiler translates bytecode → native machine code
        │
        ▼
Native code cached and reused (much faster)

3. Your First Java Program

3.1 Syntax and Structure

java
// Hello.java — Every Java program starts here
public class Hello {          // Class declaration: public class ClassName
    public static void main(String[] args) {   // Entry point
        System.out.println("Hello, World!");   // Print to console
    }
}

3.2 File Naming Rule — CRITICAL

Why this matters: The JVM looks for a .class file named after the class. If the file is Hello.class but the source was Goodbye.java, the compiler can't find the right file.

3.3 The main Method — Deconstructed

java
public    // Anyone can call it (the JVM is "anyone")
static    // No object needed — JVM invokes it before any objects exist
void      // Returns nothing
main      // Fixed name — the JVM looks for exactly "main"
(String[] args)  // Command-line arguments as an array of Strings

3.4 Compiling and Running

bash
# 1. Write the code in Hello.java
# 2. Compile to bytecode
javac Hello.java
# Produces: Hello.class
# 3. Run (note: no .class extension!)
java Hello
# Output: Hello, World!

Common Mistake: Running java Hello.class instead of java Hello. The java command expects a class name, not a filename.

4. JDK vs JRE vs JVM

pseudo
┌─────────────────────────────────────┐
│              JDK                    │
│  ┌───────────────────────────────┐  │
│  │      JRE                      │  │
│  │  ┌─────────────────────────┐  │  │
│  │  │        JVM              │  │  │
│  │  │ ┌────────┐ ┌─────────┐  │  │  │
│  │  │ │JIT     │ │ GC      │  │  │  │
│  │  │ └────────┘ └─────────┘  │  │  │
│  │  │ ┌─────────────────────┐ │  │  │
│  │  │ │ Core Libraries      │ │  │  │
│  │  │ └─────────────────────┘ │  │  │
│  │  └─────────────────────────┘  │  │
│  │  ┌─────────────────────────┐  │  │
│  │  │ javac, jar, javadoc     │  │  │
│  │  └─────────────────────────┘  │  │
│  └───────────────────────────────┘  │
└─────────────────────────────────────┘

5. Java vs Python: Key Differences at a Glance

Example: Hello World in Both

python
Run Inline
# Python — concise
print("Hello, World!")

java
// Java — more ceremony
public class Hello {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

6. Common Pitfalls

Pitfall 1: Class Name Mismatch

java
public class Hello { }  // File must be Hello.java, not hello.java

Pitfall 2: main Method Signature Errors

java
public class Test {
    public void main(String[] args) { }  // Missing static!
}

Pitfall 3: Running with .class Extension

Pitfall 4: Forgetting to Compile First

7. Practice Questions

Q1: What does JVM stand for and what is its primary role?

Answer: JVM stands for Java Virtual Machine. Its primary role is to execute Java bytecode (.class files) by translating it into native machine code for the underlying operating system and hardware. It provides platform independence — the same bytecode runs on any OS with a compatible JVM.

The JVM also handles memory management (garbage collection), security (bytecode verification), and runtime optimization (JIT compilation). Q2: Trace the complete path from a .java file to a running program.

Answer:

1. Write Hello.java source code
2. Compile with javac Hello.java → produces Hello.class (bytecode)
3. Load — JVM's class loader reads Hello.class into memory
4. Verify — bytecode verifier checks for illegal instructions
5. Execute — JVM's execution engine (interpreter + JIT compiler) translates bytecode to native machine instructions
6. Output — program's output appears on console Q3: What is the output of running these commands?

bash
$ javac MyProg.java
$ java MyProg.class

Answer: The java command should be java MyProg (without .class). Running java MyProg.class produces: "Could not find or load main class MyProg.class"

The JVM expects a class name, not a filename. When given MyProg.class, it looks for a class named MyProg.class (with the dot in the name), which doesn't exist. Q4: What is the difference between JDK, JRE, and JVM?

Answer:

• JDK (Java Development Kit): Full toolkit for developers — includes JRE + compiler (javac), debugger, documentation tools
• JRE (Java Runtime Environment): For running Java programs — includes JVM + core libraries
• JVM (Java Virtual Machine): The engine that executes bytecode — includes interpreter, JIT compiler, garbage collector

Relationship: JDK ⊃ JRE ⊃ JVM (the JDK contains the JRE, which contains the JVM). Q5: Why does this code fail to compile?

java
public class hello {
    public static void main(String[] args) {
        System.out.println("Hello");
    }
}

Assume the file is named hello.java.

Answer: On most systems this would compile fine. But consider if the file is named Hello.java (capital H) and the class is hello (lowercase h). In Java, the public class name must exactly match the filename. Some compilers are case-sensitive and will reject Hello.java containing public class hello.

The correct approach: either rename the class to Hello (matching the filename) or rename the file to hello.java (matching the class). Q6: What is bytecode and why is it useful?

Answer: Bytecode is an intermediate, platform-independent binary representation of Java code, stored in .class files. It is not native machine code for any specific CPU. Its usefulness:

1. Platform independence: Same bytecode runs on any OS (Windows, Linux, macOS) with a JVM
2. Security: Bytecode verification happens before execution, catching illegal operations
3. Compact format: More compact than source code, faster to transmit over networks
4. Optimization: JIT compiler can optimize frequently-executed bytecode paths Q7: Can a .java file have more than one class? If so, how many can be public?

Answer: Yes, a .java file can contain multiple classes, but only one can be public, and that public class must match the filename. For example:

java
// File: Shape.java
public class Shape {          // Only this is public
    // ...
}

class Circle {                // Package-private (OK)
    // ...
}

class Square {                // Package-private (OK)
    // ...
}

Compiling Shape.java produces three .class files: Shape.class, Circle.class, Square.class. Q8: What would happen if you remove the static keyword from the main method?

java
public class Test {
    public void main(String[] args) {
        System.out.println("Hello");
    }
}

Answer: It compiles successfully (it's a valid method), but when you run java Test, you get: Error: Main method is not static in class Test. Please define the main method as: public static void main(String[] args)

The JVM calls main without creating any object first — it must be static to exist before any instances exist. Q9: If you have a program with no main method, does it compile? Does it run?

java
public class NoMain {
    public void doSomething() {
        System.out.println("Doing something...");
    }
}

Answer: It compiles successfully (javac checks syntax, not runtime behavior). But when you try to run it with java NoMain, you get: Error: Main method not found in class NoMain

A compiled Java program can exist without a main method (libraries, applets), but it cannot be executed as a standalone program. Q10: What is the JIT compiler and how does it improve performance?

Answer: JIT (Just-In-Time) is a component of the JVM that improves performance by:

1. Profiling: The JVM starts interpreting bytecode and profiles which methods are executed frequently ("hot spots")
2. Compilation: Hot methods are compiled from bytecode directly to native machine code
3. Caching: The compiled native code is cached and reused for subsequent calls

This gives Java near-native performance for frequently-executed code paths while maintaining portability. The longer a Java program runs, the faster it gets as more code is JIT-compiled.

🔗 Cross-References

• Next: Data Types & Operators — understanding Java's type system
• Python Comparison: See BSCS1002 Python — Introduction to Python
• Memory Model: Stack and Heap Memory — what happens when your program runs
• Reference: Oracle Java Tutorials — "Hello World!" Application Join Discord Next1.2 Data Types & Operators