Java 17: LTS Release with Sealed Classes and Pattern Matching

// Standard feature for domain modeling
public sealed class Transport permits Car, Bus, Truck {
    protected String model;
    
    public abstract void describe();
}
 
public final class Car extends Transport {
    @Override
    public void describe() {
        System.out.println("Car: " + model);
    }
}
 
public final class Bus extends Transport {
    private int capacity;
    
    @Override
    public void describe() {
        System.out.println("Bus: " + model + " (capacity: " + capacity + ")");
    }
}
 
public final class Truck extends Transport {
    private double loadCapacity;
    
    @Override
    public void describe() {
        System.out.println("Truck: " + model + " (capacity: " + loadCapacity + "T)");
    }
}
 
// ❌ Cannot create new subclasses
// public class InvalidTransport extends Transport {}
// Error: class is not allowed to extend sealed class Transport

// Sealed interface for payment methods
public sealed interface PaymentMethod permits 
    CreditCardPayment, DigitalWalletPayment, CryptoCurrency {}
 
public final class CreditCardPayment implements PaymentMethod {
    private String cardNumber;
    private String cvv;
}
 
public non-sealed class DigitalWalletPayment implements PaymentMethod {
    private String walletId;
    // Allow further subclasses
}
 
public final class CryptoCurrency implements PaymentMethod {
    private String walletAddress;
    private String cryptoType;
}

// Record pattern matching - standard feature
public record Point(int x, int y) {}
public record Rectangle(Point topLeft, Point bottomRight) {}
public record Circle(Point center, int radius) {}
 
public String describeShape(Object shape) {
    return switch (shape) {
        case Point(int x, int y) -> String.format("Point at (%d, %d)", x, y);
        case Rectangle(Point tl, Point br) -> {
            int width = br.x() - tl.x();
            int height = br.y() - tl.y();
            yield String.format("Rectangle: %d x %d", width, height);
        }
        case Circle(Point center, int radius) -> 
            String.format("Circle at %s with radius %d", center, radius);
        default -> "Unknown shape";
    };
}
 
// Guarded patterns
public double getInsuranceRate(Object vehicle) {
    return switch (vehicle) {
        case Car car when car.age() > 10 -> 800.0 * 1.5;  // Older cars higher rate
        case Car car -> 800.0;
        case Bus bus when bus.seatingCapacity() > 50 -> 2000.0;
        case Bus bus -> 1500.0;
        default -> 500.0;
    };
}
 
// Nested pattern matching
record Employee(String name, String department, SalaryInfo salary) {}
record SalaryInfo(double base, double bonus, String currency) {}
 
public boolean isHighEarner(Object emp) {
    return switch (emp) {
        case Employee(var name, var dept, SalaryInfo(double base, double bonus, _)) 
            when (base + bonus) > 150000 -> true;
        default -> false;
    };
}

// Standard for immutable data carriers
public record User(
    long id,
    String username,
    String email,
    @NotNull String name
) {
    // Compact constructor for validation
    public User {
        if (username.isBlank()) {
            throw new IllegalArgumentException("Username cannot be empty");
        }
        if (!email.contains("@")) {
            throw new IllegalArgumentException("Invalid email format");
        }
    }
    
    // Instance methods
    public boolean isVIP() {
        return id <= 100; // First 100 users are VIP
    }
}
 
// Generic records
public record Result<T, E>(T success, E error) {
    public boolean isSuccess() {
        return success != null;
    }
    
    public static <T> Result<T, String> ok(T value) {
        return new Result<>(value, null);
    }
    
    public static <E> Result<Void, E> err(E error) {
        return new Result<>(null, error);
    }
}
 
// Usage
Result<String, String> apiResult = Result.ok("Success!");
if (apiResult.isSuccess()) {
    System.out.println(apiResult.success());
}

// Standard feature - no preview flag needed
public void processValue(Object value) {
    if (value instanceof String str) {
        System.out.println("String: " + str.toUpperCase());
    } else if (value instanceof Integer num) {
        System.out.println("Number: " + (num * 2));
    } else if (value instanceof Point(int x, int y)) {
        System.out.println("Point at: " + (x + y));
    }
}
 
// Type narrowing in complex conditions
Map<String, Object> response = getApiResponse();
Object data = response.get("user");
 
if (data instanceof Map<?, ?> map && 
    map.get("role") instanceof String role &&
    role.equals("admin")) {
    System.out.println("Admin access granted");
}

// Incubating feature for JVM-C interop
import java.lang.foreign.*;
 
public class FFMExample {
    static final Linker LINKER = Linker.nativeLinker();
    static final SymbolLookup STDLIB = LINKER.defaultLookup();
    
    public static void main(String[] args) throws Throwable {
        // Calling native C function: strlen
        MemorySegment segment = Arena.ofAuto()
            .allocateUtf8String("Hello, World!");
        
        MemorySegment result = LINKER.downcallHandle(
            STDLIB.find("strlen").get(),
            FunctionDescriptor.of(ValueLayout.JAVA_LONG, ValueLayout.ADDRESS)
        ).invoke(segment);
        
        System.out.println("String length: " + result);
    }
}

// Text blocks for templates
String htmlTemplate = """
    <!DOCTYPE html>
    <html>
    <head>
        <title>User Profile</title>
    </head>
    <body>
        <h1>Profile Page</h1>
        <div id="user-info">
            <p>Username: {{username}}</p>
            <p>Email: {{email}}</p>
            <p>Registration Date: {{joinDate}}</p>
        </div>
    </body>
    </html>
    """;
 
// SQL queries as text blocks
String complexQuery = """
    WITH sales_by_month AS (
        SELECT 
            DATE_TRUNC('month', sale_date) as month,
            SUM(amount) as monthly_total
        FROM sales
        GROUP BY 1
    )
    SELECT 
        month,
        monthly_total,
        LAG(monthly_total) OVER (ORDER BY month) as previous_month
    FROM sales_by_month
    ORDER BY month DESC;
    """;
 
// Configuration as text block
String appConfig = """
    {
      "database": {
        "host": "localhost",
        "port": 5432,
        "name": "myapp"
      },
      "redis": {
        "host": "localhost",
        "port": 6379
      },
      "logging": {
        "level": "INFO",
        "format": "json"
      }
    }
    """;

// REMOVED: RMI Activation
// Previously available in Java.rmi.activation
// Workaround: Use Java EE / Jakarta EE messaging
 
// REMOVED: Applets
// Use web browsers or standalone applications
 
// REMOVED: Security Manager
// Use: Java Platform Module System for encapsulation

// Modern Java 17 microservice architecture
 
// Domain model with sealed classes
public sealed interface OrderEvent permits 
    OrderCreatedEvent, OrderProcessedEvent, OrderShippedEvent, OrderCancelledEvent {}
 
public record OrderCreatedEvent(Order order, LocalDateTime timestamp) implements OrderEvent {}
public record OrderProcessedEvent(Order order, PaymentInfo payment) implements OrderEvent {}
public record OrderShippedEvent(Order order, TrackingInfo tracking) implements OrderEvent {}
public record OrderCancelledEvent(Order order, String reason) implements OrderEvent {}
 
// Service with pattern matching
@Service
public class OrderEventProcessor {
    public void handle(OrderEvent event) {
        switch (event) {
            case OrderCreatedEvent(var order, var timestamp) -> {
                sendConfirmationEmail(order);
                logEvent("Order created", order.id());
            }
            case OrderProcessedEvent(var order, var payment) -> {
                updateInventory(order);
                recordPayment(payment);
            }
            case OrderShippedEvent(var order, var tracking) -> {
                sendTrackingNotification(order, tracking);
                updateOrderStatus(order.id(), "SHIPPED");
            }
            case OrderCancelledEvent(var order, var reason) -> {
                refundPayment(order);
                notifyCustomer(order, reason);
            }
        }
    }
}
 
// Data transfer with records
public record OrderDTO(
    long id,
    String customerName,
    List<ItemDTO> items,
    double totalAmount,
    OrderStatus status
) {}
 
public record ItemDTO(String sku, int quantity, double price) {}