What’s New in Java 24? 8 Game‑Changing Features You Must Try

Why Java 24 Matters

JDK 24 is a milestone because many JEP candidate features are likely to become official features of JDK 25, the next LTS release scheduled for September 2025.

1. Simplified Hello World: Say Goodbye to Boilerplate

Traditional vs New Syntax

Traditional JDK 21 style:

<code>public class MyFirstClass {
    public static void main(String[] args) {
        System.out.println("Hello, World");
    }
}</code>

New JDK 24 style:

<code>void main() {
    println("Hello, World");
}</code>

Note: This is not a new language; experienced developers can still use the full syntax.

Implementation: the JVM implicitly declares a class and instance method, and automatically imports required packages for methods like

println()

.

Practical Example

<code>void main() {
    var name = readln();
    var message = "Hello, World and " + name;
    println(message);
}</code>

Equivalent traditional code:

<code>import java.io.*;
import java.util.Scanner;

public class A {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String name = sc.nextLine();
        String message = "Hello, World and " + name;
        System.out.println(message);
        sc.close();
    }
}</code>

Related JEP: JEP 495 – Simple Source Files and Instance Main Methods.

2. Primitive Type Pattern Matching for instanceof and switch

JDK 21 required the matched variable to be a reference type. Starting with JDK 24,

instanceof

and

switch

can match primitive types.

instanceof Example

<code>public class Test {
    public static String identifyType(Object value) {
        if (value instanceof int i) {
            return String.format("int: %d", i);
        } else if (value instanceof String s) {
            return String.format("String: %s", s);
        } else if (value instanceof Double d) {
            return String.format("Double: %f", d);
        } else {
            return "Unknown type";
        }
    }
}</code>

switch‑case Example

<code>String identifyType(Object value) {
    return switch (value) {
        case int i -> String.format("int: %d", i);
        case Double d -> String.format("Double: %f", d);
        case String s -> String.format("String: %s", s);
        default -> "Unknown type";
    };
}</code>

Related JEP: JEP 488 – Primitive Types in Pattern Matching.

3. Flexible Constructor Bodies: Super() with Logic

Developers can now place logic before and after the

super()

call, divided into a prologue and an epilogue.

<code>public class A extends B {
    public A() {
        // Prologue – logic before super()
        super();
        // Epilogue – logic after super()
    }
}</code>

Note: The prologue cannot access the instance being initialized.

Related JEP: JEP 492 – Flexible Constructor Bodies.

4. ScopedValue: A Perfect Replacement for ThreadLocal

ScopedValue provides immutable data sharing across threads (including virtual threads) and tasks, solving mutability, unbounded lifecycle, and costly inheritance issues of ThreadLocal.

Usage Example

<code>static final ScopedValue<String> USERNAME = ScopedValue.newInstance();

void main(String[] args) {
    ScopedValue.where(USERNAME, "Amrit").run(() -> {
        System.out.println("Main task value: " + USERNAME.get());
        performSubTask();
    });
}

static void performSubTask() {
    System.out.println("Subtask value: " + USERNAME.get());
}</code>

Related JEP: JEP 487 – Scoped Values.

5. Module Import Declarations: Batch Imports

Developers can import a whole module instead of listing individual packages, reducing redundancy.

Traditional:

<code>import javax.xml.*;
import javax.xml.parsers.*;
import javax.xml.stream.*;</code>

New:

<code>import module java.xml;</code>

Other modules such as

java.base

,

java.desktop

,

java.sql

are available.

Related JEP: JEP 494 – Module Import Declarations.

6. Structured Concurrency: A New Paradigm

JDK 24 introduces the

StructuredTaskScope

API, allowing sub‑tasks to be grouped as a single unit whose failure propagates to the whole scope.

Comparison

<code>// StructuredTaskScope example
try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
    Supplier<Integer> x = scope.fork(() -> fun1());
    Supplier<Integer> y = scope.fork(() -> fun2());
    scope.join().throwIfFailed();
} catch (Exception e) {
    println("Both tasks stopped because fun1 failed");
}

// Traditional ExecutorService
ExecutorService ex = Executors.newFixedThreadPool(3);
Future<Integer> x = ex.submit(() -> fun1());
Future<Integer> y = ex.submit(() -> fun2());
ex.shutdown();</code>

Related JEP: JEP 499 – Structured Tasks.

7. AOT Class Loading and Linking: 40% Faster Startup

Ahead‑of‑time class loading caches class data during one run and reuses it in subsequent runs, improving startup time by about 40%.

Related JEP: JEP 483 – AOT Class Loading and Linking.

8. Dropping 32‑bit Windows Support

JDK 24 removes the Windows x86 32‑bit port. Users on 32‑bit Windows must migrate to 64‑bit systems to continue using future JDK releases.

Related JEP: JEP 479 – Remove Windows 32‑bit x86 Port.

References: JEP 495, JEP 488, JEP 492, JEP 487, JEP 494, JEP 499, JEP 483, JEP 479.