1. Getting Started with Java & the JVM

[!NOTE] Welcome to your first step into the Java ecosystem. By the end of this chapter, you will understand the fundamental architecture of the Java language, how its compilation process differs from languages like C++, and you will write your very first program.

The Core Philosophy of Java

Java was introduced by Sun Microsystems in 1995 with a revolutionary mantra: "Write Once, Run Anywhere" (WORA).

In previous decades, if you wrote a program in C or C++, you had to manually compile separate versions of your program for Windows, for Mac, and for Linux. Furthermore, you had to manage memory manually, leading to catastrophic system crashes if you accidentally caused a "memory leak".

Java solved this by introducing an abstraction layer over the operating system: The Java Virtual Machine (JVM).

The Lifecycle of Java Code

Unlike interpreted languages (like Python) that read code line-by-line, and unlike fully compiled languages (like C) that translate directly into raw machine code, Java takes a hybrid approach.

[!TIP] TL;DR: Always remember the pipeline: Source -> Compiler -> Bytecode -> JVM -> OS.

Writing Your First Program

Let's look at the absolute minimum amount of code required to print something to the screen.

public class HelloWorld {
    // This is the entry point
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

  

Let's break down this famously verbose syntax line by line:

1.

public class HelloWorld

Java is aggressively Object-Oriented. Everything must live inside a class (a blueprint). The keyword public means this class is accessible from anywhere.

[!CAUTION] If your class is public, the filename must exactly match the class name. This file must be saved as HelloWorld.java, matching the casing perfectly.

2.

public static void main(String[] args)

This is the Entry Point of your application. When the JVM starts your program, it specifically looks for a method with this exact, precise signature.

• public: The JVM can access it from outside the class.
• static: The JVM can run this method without needing to create an instance (object) of the HelloWorld class first.
• void: This method does not return any data back to the JVM when it finishes.
• String[] args: An array of Strings that allows you to pass command-line arguments into your program when you start it.

3.

System.out.println("Hello, World!");

This is the command that actually prints the text to your console.

• System: A built-in class providing access to system resources.
• out: A static member of the System class representing the standard output stream (your console/terminal).
• println: A method that prints the text and then moves the cursor to a new line.

Summary

While Java may seem terribly wordy at first compared to Python (print("Hello")), this rigid, strictly typed structure is exactly what makes Java the backbone of massive enterprise architectures. It prevents silly mistakes and naturally forces you into organized design patterns.