RecordsAndPatterns.java

package Phase9_ModernJavaAndModules.ModernJava;

/**
 * Records (Java 16+) and Record Patterns (Java 21)
 * ------------------------------------------------
 * A RECORD is a special kind of class introduced in Java 16 for IMMUTABLE
 * data carriers. The compiler generates the boilerplate for you:
 * <p>
 *
 * public record Point(int x, int y) {}
 * <p>
 *
 * - Final class, cannot be subclassed.
 * - Final fields x and y - immutable after construction.
 * - Canonical constructor (int x, int y).
 * - Accessor methods: x() and y(). (NOT getX() / getY())
 * - equals(), hashCode(), toString() generated based on the components.
 * <p>
 *
 * Why Records?
 * ------------
 * Before records, a simple data class needed 30+ lines of boilerplate. With
 * records:
 * <p>
 *
 * record Point(int x, int y) {} // that's it.
 * <p>
 *
 * Record Patterns (Java 21)
 * -------------------------
 * Java 21 lets you DECONSTRUCT a record value inside an `instanceof` or a
 * switch case, binding the components to local variables:
 * <p>
 *
 * if (obj instanceof Point(int x, int y)) {
 * // x and y are usable directly here
 * }
 * <p>
 *
 * Record patterns can NEST - deconstruct records inside records:
 * <p>
 *
 * if (shape instanceof Rect(Point(int x1, int y1), Point(int x2, int y2))) {
 * ...
 * }
 * <p>
 *
 * Customising a Record
 * --------------------
 * You can add:
 * - Static fields and methods.
 * - Instance methods (regular or default).
 * - A "compact constructor" for validation (see below).
 * - Static factory methods.
 * You CANNOT add instance fields beyond the components.
 */

public class RecordsAndPatterns {

 // --- 1) Simple record ---
 public record Point(int x, int y) {}

 // --- 2) Record with validation via the compact constructor ---
 public record Range(int low, int high) {
 public Range { // compact constructor - no parameter list
 if (low > high) {
 throw new IllegalArgumentException("low must be <= high");
 }
 }
 public int span() { return high - low; }
 }

 // --- 3) Nested record for the record-pattern demo ---
 public record Line(Point start, Point end) {}

 public static void main(String[] args) {

 // --- a) Use the auto-generated bits ---
 Point p = new Point(3, 4);
 System.out.println("p.x() = " + p.x());
 System.out.println("p.y() = " + p.y());
 System.out.println("p = " + p); // Point[x=3, y=4]

 Point p2 = new Point(3, 4);
 System.out.println("p.equals(p2)? " + p.equals(p2)); // true - value equality

 // --- b) Compact constructor validates inputs ---
 Range ok = new Range(1, 10);
 System.out.println("Range span = " + ok.span());
 try {
 new Range(5, 2);
 } catch (IllegalArgumentException e) {
 System.out.println("Range rejected: " + e.getMessage());
 }

 // --- c) Java 21 record pattern with instanceof ---
 Object obj = new Point(7, 9);
 if (obj instanceof Point(int x, int y)) {
 System.out.println("Deconstructed point: x=" + x + ", y=" + y);
 }

 // --- d) Nested record pattern ---
 Object thing = new Line(new Point(0, 0), new Point(3, 4));
 if (thing instanceof Line(Point(int x1, int y1), Point(int x2, int y2))) {
 int dx = x2 - x1, dy = y2 - y1;
 double dist = Math.hypot(dx, dy);
 System.out.println("Line length = " + dist);
 }

 // --- e) Record patterns inside a switch expression ---
 Object shape = new Line(new Point(1, 1), new Point(4, 5));
 String desc = switch (shape) {
 case Point(int x, int y) -> "Point at (" + x + "," + y + ")";
 case Line(Point(int x1, int y1),
 Point(int x2, int y2)) -> "Line from (" + x1 + "," + y1 +
 ") to (" + x2 + "," + y2 + ")";
 case null -> "no shape";
 default -> "unknown shape: " + shape;
 };
 System.out.println(desc);

 // OUTPUT
 // p.x() = 3
 // p.y() = 4
 // p = Point[x=3, y=4]
 // p.equals(p2)? true
 // Range span = 9
 // Range rejected: low must be <= high
 // Deconstructed point: x=7, y=9
 // Line length = 5.0
 // Line from (1,1) to (4,5)
 }
}