Java 17 Lts

// Sealed interface with permitted implementations
public sealed interface PaymentMethod
    permits CreditCard, BankTransfer, Cash {

    BigDecimal getAmount();
    boolean process();
}

public final class CreditCard implements PaymentMethod {
    private final String cardNumber;
    private final BigDecimal amount;

    public CreditCard(String cardNumber, BigDecimal amount) {
        this.cardNumber = cardNumber;
        this.amount = amount;
    }

    @Override
    public BigDecimal getAmount() { return amount; }

    @Override
    public boolean process() {
        // Credit card processing logic
        return true;
    }
}

public final class BankTransfer implements PaymentMethod {
    private final String accountNumber;
    private final BigDecimal amount;

    @Override
    public BigDecimal getAmount() { return amount; }

    @Override
    public boolean process() {
        // Bank transfer logic
        return true;
    }
}

public final class Cash implements PaymentMethod {
    private final BigDecimal amount;

    @Override
    public BigDecimal getAmount() { return amount; }

    @Override
    public boolean process() {
        // Cash processing logic
        return true;
    }
}

// Exhaustive switch - compiler ensures all cases covered
public class PaymentProcessor {
    public void process(PaymentMethod payment) {
        switch (payment) {
            case CreditCard card ->
                System.out.println("Credit: " + card.getAmount());
            case BankTransfer transfer ->
                System.out.println("Transfer: " + transfer.getAmount());
            case Cash cash ->
                System.out.println("Cash: " + cash.getAmount());
            // No default needed - compiler checks exhaustiveness
        }
    }
}

// Sealed class with mixed modifiers
public abstract sealed class Transaction
    permits ZakatTransaction, GeneralDonation {

    protected final String id;
    protected final BigDecimal amount;
    protected final LocalDateTime timestamp;

    protected Transaction(String id, BigDecimal amount) {
        this.id = id;
        this.amount = amount;
        this.timestamp = LocalDateTime.now();
    }

    public abstract String getType();
}

// Final subclass (cannot be extended)
public final class ZakatTransaction extends Transaction {
    private final String donorId;
    private final ZakatCategory category;

    @Override
    public String getType() { return "ZAKAT"; }
}

// Sealed subclass (controlled extension)
public sealed class GeneralDonation extends Transaction
    permits EmergencyDonation, ProgramDonation {

    protected final String purpose;

    @Override
    public String getType() { return "DONATION"; }
}

public final class EmergencyDonation extends GeneralDonation {
    private final String emergencyType;
}

public final class ProgramDonation extends GeneralDonation {
    private final String programName;
}

public class TransactionValidator {

    // Before Java 17 - verbose instanceof chain
    public String validateOld(Object tx) {
        String result;
        if (tx instanceof CreditCard) {
            CreditCard card = (CreditCard) tx;
            result = "Credit card: " + card.getAmount();
        } else if (tx instanceof BankTransfer) {
            BankTransfer transfer = (BankTransfer) tx;
            result = "Transfer: " + transfer.getAmount();
        } else {
            result = "Unknown";
        }
        return result;
    }

    // Java 17 - pattern matching for switch
    public String validate(Object tx) {
        return switch (tx) {
            case CreditCard card ->
                "Credit card: " + card.getAmount();
            case BankTransfer transfer ->
                "Transfer: " + transfer.getAmount();
            case Cash cash ->
                "Cash: " + cash.getAmount();
            case null ->
                "Null transaction";
            default ->
                "Unknown type";
        };
    }

    // Pattern matching with guards
    public String validateWithAmount(PaymentMethod payment) {
        return switch (payment) {
            case CreditCard card when card.getAmount().compareTo(BigDecimal.ZERO) > 0 ->
                "Valid credit card";
            case BankTransfer transfer when transfer.getAmount().compareTo(BigDecimal.ZERO) > 0 ->
                "Valid transfer";
            case Cash cash when cash.getAmount().compareTo(BigDecimal.ZERO) > 0 ->
                "Valid cash";
            default ->
                "Invalid amount";
        };
    }
}

// Had to use strictfp for consistent results
public strictfp class FinancialCalculator {
    public double calculateInterest(double principal, double rate) {
        return principal * rate;
    }
}

// strictfp no longer needed - all operations strict by default
public class FinancialCalculator {
    public double calculateInterest(double principal, double rate) {
        return principal * rate;
        // Guaranteed IEEE 754 compliant on all platforms
    }
}

import java.util.random.RandomGenerator;
import java.util.random.RandomGeneratorFactory;

public class DonationDistributor {

    // Use specific algorithm
    public void distributeRandomly() {
        RandomGenerator generator = RandomGeneratorFactory
            .of("L128X1024MixRandom")
            .create(12345L);  // Seed for reproducibility

        int beneficiaryIndex = generator.nextInt(100);
        double amount = generator.nextDouble(1000.0);

        System.out.println("Selected beneficiary: " + beneficiaryIndex);
        System.out.println("Amount: " + amount);
    }

    // Use default generator
    public void distributeWithDefault() {
        RandomGenerator generator = RandomGenerator.getDefault();

        // Stream-based operations
        generator.ints(10, 1, 101)
            .forEach(index ->
                System.out.println("Beneficiary " + index + " selected"));
    }

    // List available algorithms
    public void listAlgorithms() {
        RandomGeneratorFactory.all()
            .map(RandomGeneratorFactory::name)
            .sorted()
            .forEach(System.out::println);
    }
}