Part 1: Java 24 Features (Project Amber): Complete Guide with Before/After, Examples, and Code

Java 24 introduces some of the most developer-friendly language improvements ever released, mainly driven by Project Amber, which focuses on making Java more expressive, concise, readable, and modern. These updates help developers write cleaner code with fewer boilerplate elements, more powerful patterns, and smarter data handling capabilities.

This guide explains all major Java 24 features such as Implicit Classes, String Templates, Unnamed Variables, Sequenced Collections, and Pattern Matching Enhancements in a simple, structured, and real-time manner. Each feature includes:

✔ What it is ✔ Before Java 24 (traditional way) ✔ After Java 24 (modern approach) ✔ Real-time examples ✔ Code snippets ✔ Where to use it in real-world applications

By the end of this guide, you’ll clearly understand how Java 24 improves productivity, cleans up syntax, enhances pattern matching, and makes Java more readable and intuitive than ever before.

1. Implicit Classes & Implicit Main Method (Finalized)

What is it?

Java 24 allows you to write a full program without writing a class or main method. You can now write top-level statements just like Python or JavaScript.

Before Java 24 (Old Way)

public class Hello {
    public static void main(String[] args) {
        System.out.println("Hello Java!");
    }
}

• You MUST define a class
• You MUST define public static void main

After Java 24 (Implicit Class + Implicit Main)

System.out.println("Hello Java!");
int x = 10;
System.out.println(x * 2);

1. No class
2. No main method
3. Works exactly like a normal Java program
4. File name can be anything: hello.java

How Java interprets it internally

Java internally rewrites it as:

class Hello {
    public static void main(String[] args) {
        System.out.println("Hello Java!");
        int x = 10;
        System.out.println(x * 2);
    }
}

2. String Templates (Finalized)

What are String Templates?

They allow you to embed expressions directly inside a string using the new template syntax:

STR."text expression"

Equivalent to JavaScript’s backticks:

`Hello ${name}`

Before 24 feature

String name = "Rama";
System.out.println("Hello " + name + ", today is " + LocalDate.now());

Problems:

1. Too many + operators
2. Hard to read
3. Error-prone

After Java 24 String Templates

String name = "Rama";
String message = STR."Hello \{name}, today is \{LocalDate.now()}";
System.out.println(message);

1. Clean
2. Fast
3. Safe (type-safe)
4. No messy concatenation

More Examples

int a = 10;
int b = 20;
System.out.println(STR."\{a} + \{b} = \{a + b}");

Output

10 + 20 = 30

3. Unnamed Variables & Unnamed Patterns (_)

What is _ ?

A special placeholder when you don’t care about the value.

3.1 Unnamed Variable

Before Java 24

for (int i = 0; i < list.size(); i++) {
    // i must be used, otherwise warning
}

After Java 24

for (int _ = 0; _ < list.size(); _++) {
    System.out.println("Hello");
}

OR

try {
    var _ = someMethod(); // we don't care about the return value
} catch (Exception _) {
    // ignore
}

1. _ means: “I don’t care about this variable.”
2. Removes compiler warnings
3. Cleaner code

3.2 Unnamed Pattern

Before Java 24

if (obj instanceof Person p) {
    System.out.println(p.getName());
}

After Java 24: Ignore the object

if (obj instanceof Person _) {
    System.out.println("It is a Person");
}

4. Pattern Matching Enhancements

Includes improvements in:

1. switch with patterns
2. Guarded patterns
3. Exhaustiveness
4. Better type inference

Example:

Before Java 24

switch (obj) {
    case String s -> System.out.println(s.toUpperCase());
    case Integer i -> System.out.println(i * 2);
    default -> System.out.println("Unknown");
}

After Java 24: Patterns + Guards

switch (obj) {
    case String s when s.length() > 5 ->
        System.out.println("Long String: " + s);

    case String s ->
        System.out.println("Short String: " + s);

    case Integer i when i > 100 ->
        System.out.println("Big Number");

    case Integer i ->
        System.out.println("Small Number");

    default ->
        System.out.println("Other Type");
}

5. Sequenced Collections (List, Set, Map)

What is it?

A new interface: SequencedCollection, SequencedSet, SequencedMap. It gives predictable order operations:

getFirst()
getLast()
addFirst()
addLast()
reversed()

Before Java 24

List<String> list = new ArrayList<>();
list.add("A");
list.add("B");

// No built-in first/last directly
String first = list.get(0);
String last = list.get(list.size() - 1);

After Java 24: Sequenced Collections

SequencedCollection<String> list = new ArrayList<>();

list.addFirst("X");
list.addLast("Y");

System.out.println(list.getFirst()); // X
System.out.println(list.getLast());  // Y

var rev = list.reversed();

Example with Maps:

SequencedMap<Integer, String> map = new LinkedHashMap<>();

map.putFirst(1, "A");
map.putLast(2, "B");

System.out.println(map.firstEntry());
System.out.println(map.lastEntry());

6. Primitive Types in Patterns (Preview)

You can now match primitive types like patterns.

if (obj instanceof Integer i) {
    System.out.println(i);
}

After Java 24 (Preview Feature)

switch (x) {
    case int i -> System.out.println("int: " + i);
    case long l -> System.out.println("long: " + l);
    case double d -> System.out.println("double: " + d);
    default -> System.out.println("Other type");
}

1. Useful for numeric processing
2. Supports type-specific logic

Conclusion

Thanks for reading! If you found value in this, drop a like and follow Ram for more clean code tips. Until next time, happy coding!