What are Java 17 LTS features?

• Records (JEP 395) – immutable data carriers: record Trade(String id, BigDecimal amount) {} auto-generates constructor, accessors, equals(), hashCode(), and toString().
• Sealed classes (JEP 409) – restrict inheritance to a known set of subtypes: sealed interface Instruction permits Buy, Sell, enabling exhaustive handling in switch.
• Pattern matching instanceof (JEP 394) – combines type check and cast in one expression: if (obj instanceof Trade t) { use t; }.
• Switch expressions (JEP 361) – return values, arrow syntax without fall-through, yield for blocks.
• Text blocks (JEP 378) – triple-quoted multi-line strings without escape characters.
• Strong encapsulation – JDK internals are strongly encapsulated; illegal reflective access is denied by default.

What are Java 17 LTS features?

Java 17 is an LTS (Long-Term Support) release that consolidates several preview features into stable APIs. It is the baseline for Spring Boot 3.x and the most widely adopted Java version in enterprise environments.

What are records?

Records (JEP 395, final in Java 16) are immutable data carriers that eliminate POJO boilerplate.

package com.bank.model;

import java.math.BigDecimal;

// One line replaces ~50 lines of POJO boilerplate
public record Trade(String tradeId, String symbol, BigDecimal amount, String status) {}

// Auto-generated: constructor, getters (tradeId(), symbol(), etc.),
// equals(), hashCode(), toString()

Trade t = new Trade("TRD-001", "RELIANCE", new BigDecimal("245050"), "SETTLED");
t.symbol()     // "RELIANCE" (accessor, not getSymbol())
t.toString()   // Trade[tradeId=TRD-001, symbol=RELIANCE, amount=245050, status=SETTLED]

What are sealed classes?

Sealed classes (JEP 409) restrict which types can extend or implement a type. This creates a closed hierarchy that the compiler can verify for exhaustiveness in switch.

package com.bank.model;

import java.math.BigDecimal;

public sealed interface Instruction permits Buy, Sell, Transfer {}
public record Buy(String symbol, int qty) implements Instruction {}
public record Sell(String symbol, int qty) implements Instruction {}
public record Transfer(String from, String to, BigDecimal amount) implements Instruction {}

// Adding a new subtype without updating all switches is a compile error

What is pattern matching instanceof?

Pattern matching instanceof (JEP 394) combines the type check and cast in one expression, eliminating the separate cast line.

// BEFORE: separate check and cast
if (obj instanceof Trade) {
    Trade t = (Trade) obj;        // redundant cast
    process(t.amount());
}

// AFTER: combined check and binding
if (obj instanceof Trade t) {    // t is bound and cast in one step
    process(t.amount());
}

// Works with negation too:
if (!(obj instanceof Trade t)) {
    return;  // not a Trade
}
process(t.amount());  // t is in scope here

How do records, sealed, and pattern matching work together?

public String describe(Instruction instr) {
    return switch (instr) {
        case Buy b     -> "Buy " + b.qty() + " of " + b.symbol();
        case Sell s    -> "Sell " + s.qty() + " of " + s.symbol();
        case Transfer t -> "Transfer Rs." + t.amount() + " from " + t.from() + " to " + t.to();
        // Exhaustive: all permitted subtypes covered
    };
}

This gives Java algebraic-data-type modeling: a sealed hierarchy of records with exhaustive pattern matching.

How is Java 17 different from Java 8?

| Feature | Java 8 | Java 17 |
|---|---|---|
| Data carriers | Verbose POJOs | Records |
| Type hierarchies | Open (any class can extend) | Sealed (controlled) |
| Type checking | instanceof + cast | Pattern matching instanceof |
| Switch | Statement, fall-through | Expression, no fall-through |
| Multi-line strings | String concatenation | Text blocks |
| Modules | Not available | Available (since Java 9) |
| GC | Parallel GC default | G1 GC default, ZGC available |

Why do teams adopt Java 17?

• Spring Boot 3.x requires Java 17 as minimum. Spring Boot 2.x reached end-of-life in November 2023.
• LTS: Oracle and vendors provide security patches for years (minimum 5 years, extended support longer).
• Modern features reduce boilerplate and bugs (records, sealed, pattern matching).
• Performance: improved GC (G1, ZGC), better JIT compilation, and startup improvements.
• The upgrade path from Java 11 is smooth for most applications.

What should a senior engineer know?

• Strong encapsulation of JDK internals means --add-opens may be needed for libraries that use deep reflection (Hibernate, Mockito older versions).
• Records are implicitly final and cannot extend classes (but can implement interfaces).
• Sealed classes and records together replace the Visitor pattern with simpler exhaustive switch.
• Java 17 removed deprecated APIs: RMI Activation, Applet API, and Security Manager (for removal).

What are common interview follow-up questions?

• Can a record have custom methods? (Yes. You can add instance methods, static methods, and compact constructors for validation.)
• Can a sealed class have non-sealed subtypes? (Yes. A non-sealed subtype reopens the hierarchy for extension.)
• What is the next LTS after Java 17? (Java 21, released September 2023.)