Java — Overview

Before you start: no prior programming experience is required, though comfort with basic programming logic (variables, loops, if/else in any language) helps — Java's syntax is introduced from scratch below.

Why This Exists (The Hook)

A C program compiled on Windows won't run on Linux without recompiling from source for that specific machine — the compiled output is tied to one operating system's hardware conventions. Java exists specifically to break that dependency: compile once to an intermediate form (bytecode), and any machine with a JVM installed — Windows, Linux, macOS — runs that exact same compiled file unchanged. "Write once, run anywhere" isn't marketing language; it's a direct description of what the JVM layer mechanically does.

Analogy — Think of Java bytecode like a universal power adapter, not a country-specific plug. A device with a fixed US plug simply doesn't work in a UK socket — you'd need to rebuild the device itself for each country. A universal adapter (the JVM) lets the exact same device (your compiled bytecode) plug into any country's socket, because the adapter — not the device — handles the platform-specific translation. javac compiles your code into that universal "plug" once; each platform's own JVM is the adapter that makes it work there.

Try it (2 minutes) — Reason through why javac HelloWorld.java and java HelloWorld are two separate commands instead of one, without looking anything up: javac (the compiler) translates your .java source into .class bytecode — a file no operating system can execute directly. java (invoked via the JVM) is what actually reads and runs that bytecode. If Java collapsed both into a single "compile and run directly to native machine code" step, the way a language like C does, what would happen to the promise that the same compiled output runs unchanged on Windows, Linux, and macOS?

What is Java?

Java is a class-based, object-oriented programming language designed around "write once, run anywhere" (WORA). Java source code compiles to an intermediate form called bytecode, which runs on the Java Virtual Machine (JVM) rather than directly on the underlying hardware — that's what makes the same compiled .class file run unchanged on Windows, Linux, or macOS, as long as each has a JVM installed.

Released in 1995 by Sun Microsystems (now owned by Oracle), Java remains one of the most widely used languages in the world — enterprise backend systems, Android apps, and large parts of the big-data ecosystem (Hadoop, Spark) are built on it.

JDK vs. JRE vs. JVM — A Distinction Worth Getting Right

These three terms get confused constantly, and interviewers ask about the distinction specifically because it reveals whether you actually understand the Java toolchain, not just the language:

|---|---|

In practice today, most installations just ship the JDK (which includes everything), so this distinction matters more for understanding what each tool does than for choosing what to install.

Why Learn Java?

Java Versions

|---|---|---|

LTS (Long-Term Support) versions — 8, 11, 17, 21 — receive updates and security patches for years after release, which is why production systems standardize on them rather than every new release. For new learning and new projects, Java 17 or 21 is the reasonable default.

Install Java

# Ubuntu/Debian
sudo apt update
sudo apt install openjdk-21-jdk
java -version

# macOS (Homebrew)
brew install openjdk@21
java -version

# Windows: download from adoptium.net (Temurin OpenJDK)

# Verify both are installed correctly
javac -version   # Java compiler (part of the JDK)
java -version    # Java runtime (JVM)

Hello World, With the Compile-Then-Run Cycle Made Explicit

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

        // Variables
        String name = "SynfraCore";
        int year = 2026;
        double price = 99.99;

        // String formatting
        System.out.printf("Learning Java at %s in %d%n", name, year);
        System.out.println("Price: ₹" + price);
    }
}

# Compile and run — two separate steps, unlike an interpreted language
javac HelloWorld.java    # Compiles source -> HelloWorld.class (bytecode)
java HelloWorld          # JVM loads and executes the bytecode
# Output: Hello, World!

This two-step compile-then-run cycle is worth internalizing early: javac never produces something directly executable by your OS — it produces bytecode, which only the JVM (invoked via the java command) can run. This is the mechanical reason Java code is portable across operating systems.

Where Java Is Actually Used

Course Sections