Chapter 1: Environment Setup

1. Installing JDK 21

Java 21 is the latest Long-Term Support (LTS) version, recommended for production use. Choose the installation method for your platform.

macOS (Homebrew)

On macOS, Homebrew is recommended to install Temurin (an open-source JDK distribution maintained by Eclipse):

# Install JDK 21 (Temurin distribution)
brew install --cask temurin@21

# Or use SDKMAN (recommended for managing multiple JDK versions)
curl -s "https://get.sdkman.io" | bash
sdk install java 21.0.4-tem

# Verify version
java --version

Ubuntu / Debian

# Install OpenJDK 21
sudo apt update
sudo apt install openjdk-21-jdk

# If not available in repos, use Adoptium (Temurin)
sudo apt install -y wget apt-transport-https
wget -qO - https://packages.adoptium.net/artifactory/api/gpg/key/public | sudo tee /etc/apt/trusted.gpg.d/adoptium.asc
echo "deb https://packages.adoptium.net/artifactory/deb $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/adoptium.list
sudo apt update
sudo apt install temurin-21-jdk

# Verify version
java --version

Windows

# Option 1: Using Scoop (recommended)
scoop bucket add java
scoop install temurin21-jdk

# Option 2: Using Chocolatey
choco install temurin21

# Option 3: Manual download
# Download JDK 21 installer from https://adoptium.net/
# After installation, add JAVA_HOME and bin directory to PATH

Verify Installation

$ java --version
openjdk 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 --version
javac 21.0.4

2. JAVA_HOME & Environment Variables

Many Java tools (Maven, Gradle, IDEs) depend on the JAVA_HOME environment variable. Make sure it points to the correct JDK installation path.

# macOS / Linux - Check JAVA_HOME
echo $JAVA_HOME

# If empty, set manually (add to ~/.zshrc or ~/.bashrc)
export JAVA_HOME=$(/usr/libexec/java_home -v 21)  # macOS
export JAVA_HOME=/usr/lib/jvm/temurin-21-jdk-amd64  # Ubuntu
export PATH=$JAVA_HOME/bin:$PATH

# Windows (PowerShell)
echo $env:JAVA_HOME
# Add JAVA_HOME via System Settings > Environment Variables

3. Hello World

Let's write a Java program to understand the basic structure. Java 21 supports running single-file programs directly without manual compilation.

// Hello.java
public class Hello {
    public static void main(String[] args) {
        String name = "Java";
        int version = 21;
        String[] features = {"Record", "Sealed Class", "Pattern Matching", "Virtual Threads"};

        System.out.println("Hello, " + name + " " + version + "!");

        // Text Block - Java 13+
        String message = """
                Java %d new features:
                """.formatted(version);
        System.out.print(message);

        // Enhanced for loop
        for (int i = 0; i < features.length; i++) {
            System.out.println("  " + (i + 1) + ". " + features[i]);
        }

        System.out.println(greet("Java 21"));
    }

    static String greet(String who) {
        return "Welcome to " + who + "!";
    }
}

Save and run:

# Method 1: Traditional compile and run
$ javac Hello.java
$ java Hello

# Method 2: Direct run (Java 11+, single-file no compile needed)
$ java Hello.java

Hello, Java 21!
Java 21 new features:
  1. Record
  2. Sealed Class
  3. Pattern Matching
  4. Virtual Threads
Welcome to Java 21!

4. Installing Maven

Maven is the most popular build and dependency management tool for Java, equivalent to npm for Node.js, pip for Python, and Composer for PHP.

Installing Maven

# macOS
brew install maven

# Ubuntu / Debian
sudo apt install maven

# Windows (Scoop)
scoop install maven

# Or via SDKMAN
sdk install maven

# Verify installation
mvn --version

Initialize a Project

# Create project skeleton using Maven archetype
mvn archetype:generate \
  -DgroupId=com.example \
  -DartifactId=my-java-project \
  -DarchetypeArtifactId=maven-archetype-quickstart \
  -DarchetypeVersion=1.5 \
  -DinteractiveMode=false

cd my-java-project

Generated project structure:

my-java-project/
├── pom.xml                  # Maven config file (like package.json)
└── src/
    ├── main/java/com/example/
    │   └── App.java          # Main program
    └── test/java/com/example/
        └── AppTest.java      # Tests

pom.xml is the project's core configuration file:

<project>
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>my-java-project</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>21</maven.compiler.source>
        <maven.compiler.target>21</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!-- Example dependency: Gson JSON library -->
        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>2.11.0</version>
        </dependency>
    </dependencies>
</project>

Common Maven Commands

# Compile project
mvn compile

# Run tests
mvn test

# Package as JAR
mvn package

# Clean build artifacts
mvn clean

# Install to local repository
mvn install

5. IDE Configuration

For Java development, IntelliJ IDEA is the recommended IDE. The Community Edition is free and fully featured for Java development.

If using VS Code, install the Extension Pack for Java:

# VS Code command line install
code --install-extension vscjava.vscode-java-pack

6. JShell Interactive Programming

Java 9 introduced JShell (REPL), allowing you to quickly test code snippets like Python's interactive interpreter.

$ jshell
|  Welcome to JShell -- Version 21.0.4
|  For an introduction type: /help intro

jshell> var name = "Java 21"
name ==> "Java 21"

jshell> System.out.println("Hello, " + name)
Hello, Java 21

jshell> List.of(1, 2, 3).stream().map(x -> x * x).toList()
$3 ==> [1, 4, 9]

jshell> record Point(int x, int y) {}
|  created record Point

jshell> new Point(3, 4)
$5 ==> Point[x=3, y=4]

jshell> /exit

7. Chapter Summary