• When Clauses
• Type Patterns with Primitive Types
• Primitive Types in Record Patterns
• Primitive Values in switch Expressions and Statements
• Safe Casting with instanceof and switch

In this release:

• Type-import-on-demand declarations shadow module import declarations.
• Modules may declare a transitive dependence on the java.base module.
• The java.se module transitively requires the java.base module. Consequently, importing the java.se module imports the entire Java SE API.

• When Clauses
• Type Patterns with Primitive Types
• Primitive Types in Record Patterns
• Primitive Values in switch Expressions and Statements
• Safe casting with instanceof and switch

In this release:

In this release, you can succinctly import all of the packages exported by a module with a module import declaration.

In this release:

• Implicitly declared classes automatically import the static methods from the new class java.io.IO for simple textual I/O with the console.
• Implicitly declared classes automatically import, on demand, all of the public top-level classes and interfaces of the packages exported by the java.base module.

In this release, a constructor body may initialize fields in the same class before explicitly invoking a constructor. This enables a constructor in a subclass to ensure that a constructor in a superclass never runs code that sees the default value of a field in the subclass (for example, 0, false, or null). This can occur when, due to overriding, the superclass constructor invokes a method in the subclass that uses the field.

In constructors in the Java programming language, you may add statements that don't reference the instance being created before an explicit constructor invocation.

This feature remains unchanged since Java SE 21.

Except for a technical change in the types of template expressions, which is described in String Templates (Second Preview) in The Java Language Specification: Java SE 22 Edition, this feature remains unchanged since Java SE 21.

In this release, support for record patterns appearing in the header of an enhanced for statement has been removed.

In this release:

• Parenthesized patterns have been removed.
• Qualified enum constants as case constants in switch expressions and statements are allowed.

String templates complement Java's existing string literals and text blocks by coupling literal text with embedded expressions and template processors to produce specialized results.

Unnamed patterns match a record component without stating the component's name or type. Unnamed variables are variables that can be initialized but not used. You denote both with the underscore character (_).

Unnamed classes and instance main methods enable students to write streamlined declarations for single-class programs and then seamlessly expand their programs later to use more advanced features as their skills grow.

Preview feature from Java SE 17 re-previewed for this release.

In this release:

• An exhaustive switch (that is, a switch expression or a pattern switch statement) over an enum class throws a MatchException instead of an IncompatibleClassChangeError if no switch label applies at run time.
• The grammar for switch labels is simpler.
• The compiler can infer the type of the type arguments for generic record patterns in all constructs that accept patterns: switch statements and expressions, instanceof expressions, and enhanced for statements.

Preview feature from Java SE 19 re-previewed for this release.

In this release:

• The compiler can infer the type of the type arguments for generic record patterns.
• Record patterns can appear in an enhanced for statement.
• Named record patterns are no longer supported.

Preview feature from Java SE 17 re-previewed for this release.

In this release:

• The syntax of a guarded pattern label consists of a pattern and a when clause.
• If a selector expression evaluates to null and the switch block does not have null case label, then a NullPointerException is thrown, even if a pattern label can match the type of the null value.
• If a switch expression or statement is exhaustive at compile time but not at run time, then a MatchException is thrown.

Introduced as a preview feature for this release.

A record pattern consists of a type, a record component pattern list used to match against the corresponding record components, and an optional identifier. You can nest record patterns and type patterns to enable a powerful, declarative, and composable form of data navigation and processing.

Preview feature from Java SE 17 re-previewed for this release.

In this release:

• Dominance checking forces a constant label to appear before a guarded pattern labels, which must appear before a non-guarded type pattern label; see the section "Pattern Label Dominance" in Pattern Matching for switch Expressions and Statements.
• Exhaustiveness checking has been expanded to take into account generic sealed classes and to check switch expressions; see the section "Type Coverage in switch Expressions and Statements" in Pattern Matching for switch Expressions and Statements and the section "Exhaustiveness of switch Statements" in Switch Expressions.

First previewed in Java SE 15, this feature is permanent in this release. This means that it can be used in any program compiled for Java SE 17 without enabling preview features.

A sealed class or interface restricts which classes or interfaces can extend or implement it.

Introduced as a preview feature for this release.

Pattern matching for switch expressions and statements allows an expression to be tested against a number of patterns, each with a specific action, so that complex data-oriented queries can be expressed concisely and safely.

Preview feature from Java SE 15 re-previewed for this release. It has been enhanced with several refinements, including more strict checking of narrowing reference conversions with respect to sealed type hierarchies.

First previewed in Java SE 14, this feature is permanent in this release. This means that it can be used in any program compiled for Java SE 16 without enabling preview features.

In this release, inner classes may declare members that are either explicitly or implicitly static. This includes record class members, which are implicitly static.

A record is a class that acts as transparent carrier for immutable data.

First previewed in Java SE 14, this feature is permanent in this release. This means that it can be used in any program compiled for Java SE 16 without enabling preview features.

In this release, pattern variables are no longer implicitly final, and it's a compile-time error if a pattern instanceof expression compares an expression of type S with a pattern of type T, where S is a subtype of T.

Pattern matching allows common logic in a program, namely the conditional extraction of components from objects, to be expressed more concisely and safely.