Java 17 features

What it is and why it exists

Java 17 features are not one syntax bundle whose parts appeared at the same time. They are a set of language capabilities that the Java 17 source level can use without preview flags. Of these, sealed classes were finalized in Java 17; the other four became final from Java 14 through Java 16. Treating them as one migration baseline separates “what the target project can use” from “when a construct was first released.”

The features remove recurring modeling friction. A record class declares a data carrier from its state; a pattern variable combines a type test with a safe conversion. A text block preserves the source shape of multiline text, while a switch expression makes branches produce a value. A sealed type turns “which direct subtypes are legal” into a compiler-checked constraint.

None of these constructs turns Java into a different language. A record is still a class, a text block still produces a String, pattern matching still performs a runtime type test, and a switch expression still follows static typing and exhaustiveness rules. Their value is more accurate expression of intent, not the character count they save.

You meet these boundaries in codebases moving to Java 17, library minimum-version declarations, build-plugin configuration, and AI-generated modern Java. Once a project can use Java 17, the constructs can normally be adopted incrementally rather than through a system-wide rewrite. Source level, runtime version, and dependency class-file version remain three different compatibility questions.

How it works

Five features, five final releases

The table records final releases, not preview releases. Java 17 can compile all five constructs as stable syntax, but only sealed classes became final in Java 17 itself.

A preview feature requires --enable-preview and is tied to the particular JDK used to compile it. Production code that promises a stable Java 17 source level should not depend on preview type patterns in switch. That syntax changed later, so case Type value -> or a when guard copied from a newer tutorial cannot be projected backward as stable Java 17 syntax.

Records declare a data shape

record Account(String owner, Tier tier) declares two record components. From them, the compiler provides private final fields with the same names, a canonical constructor, owner() and tier() accessors, and equals, hashCode, and toString based on all components. A record class implicitly extends java.lang.Record and is implicitly final, so it cannot extend another class or be extended by an ordinary class.

A compact canonical constructor omits its parameter list and explicit field assignments. Its body can validate or rebind parameters; the compiler then assigns the final parameter values to fields. This is the right place to establish construction invariants, but it does not automatically copy lists, arrays, or other mutable components.

Pattern variables use flow scoping

The expression value instanceof Account account tests the runtime type before it binds account. The variable’s availability follows control flow, not only the nearest braces. The right operand of && can therefore use a successfully matched variable, and code after a negated guard that returns can use it too.

null instanceof Account account evaluates to false; it neither binds the variable nor throws. Pattern matching removes a repeated explicit cast, but it does not validate fields, close an open hierarchy, or replace business validation.

Sealed types constrain direct inheritance

A sealed type uses permits to list its allowed direct subtypes; the compiler can infer the list when they are declared in the same compilation unit. Every direct subtype must choose final, sealed, or non-sealed, though records and enums can satisfy the rule implicitly. non-sealed reopens that branch, so a sealed root does not always imply a permanently finite set of descendants.

In a named module, permitted direct subtypes must belong to the same module as the sealed type. In an unnamed module, they must belong to the same package. The rule gives the type owner control, but it also makes a cross-module plugin contract a poor candidate for a sealed root.

Text blocks and switch still have exact semantics

The opening delimiter of a text block must be followed by a line terminator. The compiler normalizes line terminators, removes common incidental indentation, and then interprets escapes; the closing delimiter participates in indentation calculation. The result is an ordinary String, usually including the final line break before a closing delimiter placed on its own line.

A switch expression must cover every possible selector value. Arrow rules do not fall through; an expression rule supplies its result directly, while a block rule supplies it with yield. In stable Java 17, an enum demonstrates this exhaustiveness cleanly, while a pattern switch over a sealed type is still beyond the stable boundary.

Examples

Combine stable features in one Java 17 program

The first example puts a record, an instanceof pattern variable, an enum switch expression, and a text block in one source file. It needs no preview flag, so it also works as a small Java 17 source-compatibility smoke test.

The compact constructor rejects a blank name before the rebound owner parameter is assigned to the record field. After the negated pattern branch returns, later code can use account as a bound Account. Every enum constant is covered, so the switch needs no default.

Model a closed result with a sealed interface

Java 17 can declare a sealed hierarchy and use instanceof pattern matching for each branch as stable features. This example deliberately avoids a type-pattern switch; the final exception also prevents a future edit from failing silently.

import java.util.ArrayList;
import java.util.List;

public class SealedResult {
    sealed interface Lookup permits Found, Missing {}

    record Found(String id, List<String> roles) implements Lookup {
        Found {
            roles = List.copyOf(roles);
        }
    }

    record Missing(String id) implements Lookup {}

    static String describe(Lookup result) {
        if (result instanceof Found found) {
            return found.id() + ": " + found.roles().size() + " roles";
        }
        if (result instanceof Missing missing) {
            return missing.id() + ": missing";
        }
        throw new IllegalStateException("unhandled result: " + result);
    }

    public static void main(String[] args) {
        var sourceRoles = new ArrayList<>(List.of("reader", "author"));
        var found = new Found("u-17", sourceRoles);

        sourceRoles.add("admin");
        System.out.println(describe(found));
        System.out.println(describe(new Missing("u-18")));
        System.out.println("source roles: " + sourceRoles.size());
        System.out.println("snapshot roles: " + found.roles().size());
    }
}

u-17: 2 roles
u-18: missing
source roles: 3
snapshot roles: 2

Both records are implicitly final, so they legally close the two branches of the sealed interface. List.copyOf gives Found an unmodifiable snapshot; mutating the source list later does not change the record’s value. A mutable domain object used as a component would still need its own copying or immutability policy.

Make text-block indentation and yield visible

The third example has a block switch rule produce a value with yield, then inserts that result into a text block. The common indentation shared with the closing delimiter is removed, while the two extra spaces inside the content remain.

public class TextBlockReport {
    enum Status { QUEUED, RUNNING, DONE }

    static String render(Status status, int count) {
        String detail = switch (status) {
            case QUEUED -> "waiting";
            case RUNNING -> {
                if (count == 0) {
                    yield "starting";
                }
                yield "processed " + count;
            }
            case DONE -> "complete";
        };

        return """
            status=%s
              detail=%s
            """.formatted(status, detail);
    }

    public static void main(String[] args) {
        System.out.print(render(Status.RUNNING, 3));
        System.out.print(render(Status.DONE, 0));
    }
}

status=RUNNING
  detail=processed 3
status=DONE
  detail=complete

yield ends only the current block rule and provides its value to the switch expression; return would try to exit the entire method. The text block has a final newline because the closing delimiter is on the next line. Putting the closing delimiter immediately after the final content would omit that automatic newline.

Pitfalls

Fix: Record each final release: switch expressions in 14, text blocks in 15, records and instanceof patterns in 16, and sealed classes in 17. A migration guide can call them Java 17 baseline features without rewriting their release history.

Fix: Build code that promises Java 17 with javac --release 17 and no --enable-preview. Use an instanceof chain, a visitor, or polymorphic methods at this source level; if you need final pattern switches, raise the declared minimum to Java 21.

Fix: Validate components in the canonical constructor and apply List.copyOf, array copies, or immutable domain types according to ownership. Also check whether an accessor re-exposes mutable storage: records provide shallow state constraints, not recursive freezing.

Fix: For a closed enum owned by the current module, name every constant and let source recompilation expose an omission. Handle unknown text or network values at the parsing boundary; source exhaustiveness also does not replace binary-compatibility tests for old consumers.

Fix: Use the serializer, escaper, or parameterized-query API for the target format. formatted() only performs string formatting; placing untrusted input in a SQL text block still creates an injection flaw.

Fix: Seal a hierarchy only when one module or package owns its type set, and inspect the modifier on every direct subtype. Use an ordinary interface for extension points; when a branch is intentionally open, do not treat the root permits list as a list of every runtime type.

Further reading

• JEP 409: Sealed Classes
• JEP 394: Pattern Matching for instanceof
• JEP 395: Records
• JEP 378: Text Blocks
• JEP 361: Switch Expressions