Java Handbook

Java is a general-purpose, statically typed, object-oriented language created by James Gosling at Sun Microsystems and released in 1995. You write .java source files, the compiler javac turns them into bytecode (.class files), and the Java Virtual Machine (JVM) runs that bytecode on any operating system. That is the old slogan "write once, run anywhere": the same compiled program runs on Windows, macOS and Linux without a rebuild.

Thirty years on, Java is not a legacy curiosity. A new version ships every six months, and every two years one becomes a long-term support (LTS) release that companies standardise on. This handbook teaches Java 21 LTS — records, var, switch expressions, text blocks, pattern matching and sealed types — and every example also runs unchanged on newer JDKs.

• Backend services — Spring Boot is the most common way large companies build web APIs; banks, insurers, airlines, e-commerce and payment systems run on it.
• Android — the Android SDK is a Java API; Kotlin is now preferred for new apps, but it runs on the same platform and millions of lines of Android code are Java.
• Big data and streaming — Apache Kafka, Hadoop, Elasticsearch, Cassandra and Flink are written in Java, and Spark runs on the JVM. Data engineers read Java stack traces every week.
• Enterprise and fintech — long-lived systems where a strict compiler, mature tooling and a huge hiring pool matter more than terse syntax.

JDK (Java Development Kit)

What you install as a developer: the compiler javac, the launcher java, tools like jshell and jar, plus the standard library.

JVM (Java Virtual Machine)

The program that loads bytecode and runs it. It interprets hot code at first, then compiles it to fast native machine code at runtime (the JIT compiler).

JRE (Java Runtime Environment)

The JVM plus the standard library, without the compiler. Modern JDKs no longer ship a separate JRE download; you just install the JDK.

Bytecode

The portable instruction format inside .class files. The same bytecode runs on every JVM, on every operating system.

LTS

Long-term support release. Java 8, 11, 17, 21 and 25 are LTS versions; most companies run one of them in production.

1. 1
   1. You write source

   Main.java — plain text, human readable.

2. 2
   2. javac compiles

   javac Main.java checks every type and writes Main.class (bytecode). Type errors stop here, before the program ever runs.

3. 3
   3. The JVM runs it

   java Main starts a JVM, loads Main.class, and calls its main method.

Install a JDK, then open a new terminal and check that both the launcher and the compiler are on your PATH. If you see a version number from both commands, you are done.

brew install --cask temurin@21
java -version
javac -version

winget install EclipseAdoptium.Temurin.21.JDK
# close and reopen PowerShell, then:
java -version
javac -version

sudo apt update
sudo apt install openjdk-21-jdk
java -version
javac -version

openjdk version "21.0.4" 2024-07-16 LTS
OpenJDK Runtime Environment Temurin-21.0.4+7 (build 21.0.4+7-LTS)
OpenJDK 64-Bit Server VM Temurin-21.0.4+7 (build 21.0.4+7-LTS, mixed mode)
javac 21.0.4

For an editor, IntelliJ IDEA Community Edition is free and is what most Java teams use; VS Code with the "Extension Pack for Java" is a lighter option. Both can download a JDK for you if you skipped the step above.

Create a folder, save the code below as Main.java (the file name must match the public class name, capital M included), and run it.

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello, Java!");
        System.out.println("2 + 3 = " + (2 + 3));
    }
}

Hello, Java!
2 + 3 = 5

# Classic: compile to bytecode, then run the class
javac Main.java     # writes Main.class
java Main           # note: no .java, no .class

# Since Java 11: run a single source file directly
java Main.java      # compiles in memory and runs

Single-file launch is perfect for learning and for every example in this handbook. Real projects compile with a build tool (Maven or Gradle, Module 12).

A Java source file holds one or more classes. A class holds fields (data) and methods (behaviour). A method holds statements, each ending in ;. Curly braces { } mark where each class, method or block starts and ends — indentation is for humans only, the compiler ignores it.

public class Main {
    // a field: data that belongs to the class
    static String language = "Java";

    // a method other code can call
    static int square(int n) {
        return n * n;
    }

    // the entry point the JVM calls
    public static void main(String[] args) {
        System.out.println("Learning " + language);
        System.out.println("7 squared is " + square(7));
        System.out.print("print() does not add a newline, ");
        System.out.println("println() does.");
    }
}

Learning Java
7 squared is 49
print() does not add a newline, println() does.

Java has three comment styles. The compiler throws all of them away; they exist for the next person who reads the code — often you, six months later. Comment why something is done, not what the line obviously does.

/**
 * A Javadoc comment: tools turn these into HTML API docs,
 * and IDEs show them when you hover over the class or method.
 */
public class Main {
    public static void main(String[] args) {
        // A single-line comment runs to the end of the line.
        int seats = 42; // it can also follow code

        /* A block comment
           can span several lines. */
        System.out.println("Seats: " + seats);
        // System.out.println("This line is commented out, so it never runs");
    }
}

Seats: 42

Seventeen modules, each its own page, from variables to a job-ready resume. The rail on the left lists them; the bar at the top and the pill at the bottom-left track your progress. A lesson ticks itself when you reach its end, and the tick survives closing the tab — no account needed.

• Examples are compiled and verified. Java cannot run inside a web page, so every example here is a complete program that was compiled and run with a real JDK before publishing. The output shown under it is exactly what it printed — copy the program into your IDE or save it as Main.java and run java Main.java to see the same result.
• "Your turn" tasks under each example ask you to change one thing. Do them — predicting output before you run is the fastest way to learn.
• Traces step through a program line by line with the variables at each step — used where loops, recursion and method dispatch get confusing.
• Error cards show the real javac or JVM message, why it happened, and the fix. Module 11 collects the fifteen most common.
• Interview questions appear where the topic is taught and are collected in Module 15, tiered junior, mid and senior.
• The handbook ends with a certification exam (25 questions, 70% to pass), then the ATS resume checker with a real job posting.

An AI assistant can write a working Java class in seconds. That is exactly why you should type the code yourself while learning. The goal is not the code; it is the model in your head — why == on two Strings can be false, why a method cannot change the caller's variable, why a checked exception must be declared. That model is what an interviewer tests and what lets you fix a production stack trace at 2 a.m.

Ready? Module 01 starts with variables, the eight primitive types, operators and reading keyboard input.