Coordinates.java

import static java.lang.Math.*; // abs, atan2, cos, hypot, sin
    
/// Since this interface is sealed, the only allowed subtypes are the ones specified
/// below: Cartesian and Polar.
public sealed value interface Coordinates {
    /// value classes: flat representation in memory, no identity, has the
    /// flexibility of a class but the performance of a primitive type
    value record Cartesian(double x, double y) implements Coordinates {
        /// Convert these Cartesian coordinates into polar coordinates.
        public Polar polar() -> new Polar(hypot(x, y), atan2(y, x));
    }
    
    /// record means data class: automatically generated constructor, fields, getters,
    /// equals, hashCode, toString, and deconstruction pattern
    value record Polar(double r, double theta) implements Coordinates {
        /// Convert these polar coordinates into Cartesian coordinates.
        public Cartesian cartesian() -> new Cartesian(r * cos(theta), r * sin(theta));

        /// record reconstructor
        public Polar rotate(double a) -> this with { theta += a; };
    }
    
    /// Universal generics, switch expressions, pattern matching (record, nested, var,
    /// constant, unnamed), guards. Because the Coordinates interface is sealed, the
    /// switch is exhaustive and no default case is needed.
    static Stream<double> distances(Stream<Coordinates> stream) -> stream.map(
        coordinates -> switch (coordinates) {
            case Cartesian(var x, var y) -> hypot(x, y);
            case Polar(0.0d, _) -> 0.0d;
            case Polar(var r, _) when r > 0.0d -> r;
            case Polar(var r, _) -> abs(r);
        }
    );
    
    /// Concise method body with method reference.
    static Stream<double> cartesianDistances(Stream<Cartesian> stream) = Coordinates::distances;
}

java.md

Modern Java:

• switch expressions
• sealed types
• record classes
• record patterns
• record reconstructors
• value classes
• all values are objects
• universal generics
• concise method bodies
• local-variable type inference
• Markdown documentation comments

Not shown:

• enhanced primitive boxing
• deconstruction patterns and reconstructors for carrier classes and interfaces
• primitive patterns, constant patterns, array patterns, vararg patterns
• member patterns (static, instance, pattern lambdas/references)
• pattern matching in assignment statements, enhanced for-loops, catch blocks, lambda params, method params?
• exception handling in switch
• typeclasses, operator overloading
• serialization v2
• flexible constructor bodies
• module imports
• compact source files
• JShell
• nullable and null-restricted types (opt into null restriction by default per module)
• specialization of generics over primitive and value types
• declaration-site variance
• immutable arrays
• arrays 2.0
• 64-bit hash codes
• stream gatherers
• text blocks
• string templates
• virtual threads
• structured concurrency
• scoped values
• processor locals
• unwind-and-invoke
• continuation API
• Hermetic Java
• lazy constants
• condensers
• AOT cache (class loading/linking, method profiling, code compilation)
• GraalVM native images, web images, layered images
• Project Crema (Ristretto JIT compiler)
• Truffle
• Espresso
• compact object headers
• thread-local, generational ZGC
• automatic heap sizing
• vector API
• foreign memory access
• foreign function calls
• code reflection
• class-file API
• Java Platform Module System
• integrity by default