java-21_skill

Overview

This skill packages Java 21 language and runtime patterns for modern, safe code. It focuses on records for immutable data, sealed types with pattern matching, and virtual threads for scalable blocking I/O. Use it to adopt concise, expressive, and correct idioms when targeting Java 21.

How this skill works

The skill highlights concrete patterns and small code idioms you can apply directly in application and library code. It shows how to validate data in record compact constructors, model closed hierarchies with sealed types and exhaustive switch pattern matching, and replace heavy platform threads with virtual-thread executors for blocking tasks. Each pattern includes the intent, benefits, and anti-pattern guidance so you can apply them safely.

When to use it

• Writing application or library code targeting Java 21
• Designing immutable DTOs or value objects that require validation
• Modeling closed or evolving type hierarchies where exhaustiveness matters
• Handling large numbers of blocking I/O tasks without a heavyweight thread pool
• Upgrading legacy code to safer, more concise language features

Best practices

• Prefer records for DTOs and value objects; validate inputs in the compact constructor
• Use sealed interfaces/classes to capture closed hierarchies and enable exhaustive switch patterns
• Use switch pattern matching to centralize type-specific logic with compiler exhaustiveness checks
• Use Executors.newVirtualThreadPerTaskExecutor() for blocking I/O to avoid creating raw platform threads
• Avoid public mutable fields or mutable DTO types; prefer immutable records or well-encapsulated classes

Example use cases

• Define Email, Money, or Identifier types as records with validation in the compact constructor
• Model payment methods with a sealed Payment interface and implement Card/BankTransfer as records
• Write a PaymentPrinter that uses switch pattern matching to produce stable, exhaustive descriptions
• Fetch many URLs concurrently by using a virtual-thread-per-task executor for each blocking request
• Refactor mutable service DTOs into records to reduce accidental state changes and simplify equals/hashCode