What is a record deconstruction pattern in Java, and how does it differ from a plain type pattern?

## Background: records and pattern matching A **record** is a compact, immutable Java class declared like `record Point(int x, int y) {}`. From that one line the compiler generates a private final field per component, a public **accessor** named after each component (`x()`, `y()`), a **canonical constructor** taking the components in order, plus `equals`, `hashCode`, and `toString`. The *components* are the named parts listed in the header. **Pattern matching** is a language feature that combines a type test with extracting data. A **type pattern** such as `obj instanceof Point p` does two things at once: it checks `obj instanceof Point` and, if true, declares and assigns a new variable `p` of type `Point`. That variable is called a **pattern variable**. ## What a record deconstruction pattern adds A **record deconstruction pattern** (record pattern) extends the type pattern so it also takes the record apart. Syntax: ```java obj instanceof Point(int x, int y) ``` Read it as: *is `obj` a `Point`? If so, call its accessors and bind `x = obj.x()`, `y = obj.y()`.* The part inside the parentheses — `int x, int y` — is a list of **sub-patterns**, one per record component, in declaration order. Each sub-pattern can itself be a type pattern (`int x`), a `var` pattern (`var x`), or another record pattern (nesting). The pattern's shape deliberately mirrors the canonical constructor. Where you *built* the value with `new Point(3, 4)`, you *take it apart* with `Point(int x, int y)`. This symmetry is why it is called *deconstruction*. ## Why it is more than syntax sugar Without record patterns you write: ```java if (obj instanceof Point p) { int x = p.x(); int y = p.y(); // use x, y } ``` With a record pattern: ```java if (obj instanceof Point(int x, int y)) { // use x, y directly } ``` The code is shorter, the intent ("I care about the parts") is explicit, and the binding count is checked by the compiler against the record's component count. ## Type test semantics For the whole pattern to match, two things must hold: the value must be an instance of the record type, **and** each sub-pattern must match its component. If you write `Point(int x, int y)` the component types must be exactly the declared types (here `int`), so those sub-patterns always match once the outer type matches. If a sub-pattern is itself a type pattern over a *reference* type, that nested type is also tested at runtime. ## Where it works Record patterns are usable in `instanceof` expressions and in `switch` (case labels), introduced as a standard feature in Java 21. They require a **record** type because deconstruction needs the compiler-known component accessors; you cannot deconstruct a normal class with this syntax. ## A null note In `instanceof`, a record pattern does not match `null` (just like a type pattern), so the guarded block is null-safe for the bound value.