1. Modern Java Idioms

Modern Java is still Java: classes, methods, packages, and static typing are the foundation. The difference is that many common patterns now have clearer language support. This chapter focuses on stable features available in the JDK 25 LTS baseline.

1.1. Records for data

Use records for small immutable data carriers. A record declares its state in the header and Java generates the constructor, accessors, equals(), hashCode(), and toString().

public record Student(String id, String firstName, String lastName, int grade) {

  public String fullName() {
    return firstName + " " + lastName;
  }

  public boolean passing() {
    return grade >= 60;
  }
}

Records can have normal methods when the data has behavior closely tied to it. Callers use accessor methods named after the components.

public static void main(String[] args) {
  var student = new Student("s-1001", "Ada", "Lovelace", 98);

  System.out.println(student);
  System.out.println(student.id());
  System.out.println(student.fullName());
  System.out.println(student.passing());

Use a class instead of a record when identity, mutation, inheritance, or a long lifecycle is central to the object.

1.2. Sealed hierarchies

Use sealed types when a hierarchy has a known set of implementations. This is common for domain alternatives such as commands, events, messages, or result types.

sealed interface Media permits Book, Movie {}

record Book(String title, String author, int pages) implements Media {}

record Movie(String title, int minutes) implements Media {}

The compiler can use the sealed hierarchy to check whether a switch handles every possible subtype.

1.3. Pattern matching

Pattern matching removes the old “check, cast, assign” ceremony around instanceof.

static int length(Object value) {
  if (value instanceof String text) {
    return text.length();
  }

  return 0;
}

Pattern matching for switch and record patterns work well with sealed hierarchies. The switch below handles every permitted Media subtype and decomposes records directly in the case labels.

static String describe(Media media) {
  return switch (media) {
    case Book(String title, String author, int pages) when pages > 500 ->
        "long book: " + title + " by " + author;
    case Book(String title, String author, int pages) ->
        "book: " + title + " by " + author;
    case Movie(String title, int minutes) ->
        "movie: " + title + " (" + minutes + " minutes)";
  };
}

This style is usually clearer than a chain of if statements when the input can be one of several known shapes.

1.4. Module imports

JDK 25 supports module import declarations. They import the public API exported by a module and are useful in small programs, examples, and exploratory code.

import module java.base;

public class ModuleImportDemo {

  public static void main(String[] args) {
    List<String> names = List.of("Ada", "Grace", "Katherine");
    Path report = Path.of("names.txt");

    String text = names.stream()
        .map(String::toUpperCase)
        .collect(Collectors.joining(", "));

    System.out.println(report.toAbsolutePath());
    System.out.println(text);

Explicit imports are still better in many production files because they show exactly which external names the file uses. Module imports are strongest when they lower beginner friction or make short examples easier to read.

1.5. Flexible constructor bodies

JDK 25 lets a constructor do validation and simple preparation before calling super(...). This keeps invalid values out of the parent constructor.

static class PositiveRectangle extends Rectangle {

  PositiveRectangle(int width, int height) {
    if (width <= 0 || height <= 0) {
      throw new IllegalArgumentException("dimensions must be positive");
    }

    super(width, height);
  }

The code before super(...) is still restricted. It cannot read from the partly constructed object through this.

1.6. Unnamed variables and patterns

Use _ when a variable or pattern component is intentionally unused.

try {
  int value = Integer.parseInt(text);
  System.out.println(value);
} catch (NumberFormatException _) {
  System.out.println("not a number");
}

This avoids fake names such as ignored or unused. It also tells the reader and compiler that the value is deliberately not used.

1.7. Compact source files

For small programs, scripts, and first lessons, compact source files avoid the full class wrapper.

void main() {
  IO.println("Hello, world!");
}

Use compact source files at the beginning of the learning path. Move to normal class-based files when you need packages, tests, multiple classes, or ordinary project structure.