Java 25 Flexible Constructor Bodies

public class PositiveBigInteger extends BigInteger {

    public PositiveBigInteger(long value) {
        // I want to validate that value > 0 BEFORE calling super()
        // But the compiler says: "Call to 'super()' must be first statement"
        super(Long.toString(value));  // Forced to call super first

        // Now I can validate, but the superclass already did all its work
        // with potentially invalid data
        if (value <= 0) {
            throw new IllegalArgumentException("non-positive value");
        }
    }
}

public class Employee extends Person {

    public Employee(String name, int age) {
        // === PROLOGUE (new in Java 25) ===
        // Validate arguments before calling super
        if (name == null || name.isBlank()) {
            throw new IllegalArgumentException("Name cannot be blank");
        }
        if (age < 18 || age > 67) {
            throw new IllegalArgumentException("Age must be between 18 and 67");
        }

        // Compute values to pass to super
        String normalizedName = name.trim().toUpperCase();

        // === CONSTRUCTOR INVOCATION ===
        super(normalizedName, age);

        // === EPILOGUE (same as before) ===
        // Full access to this, fields, methods
        this.startDate = LocalDate.now();
        log("Employee created: " + this.getName());
    }
}

public class PositiveBigInteger extends BigInteger {

    public PositiveBigInteger(long value) {
        // Validate BEFORE superclass does any work
        if (value <= 0) {
            throw new IllegalArgumentException("Value must be positive: " + value);
        }
        super(Long.toString(value));
    }
}

// Usage:
var num = new PositiveBigInteger(42);   // Works fine
var bad = new PositiveBigInteger(-5);   // Throws immediately, no wasted work

public class DatabaseConnection extends AbstractConnection {
    private final String schema;

    public DatabaseConnection(String host, int port, String schema, String user) {
        // Validate all arguments before superclass initializes the connection
        Objects.requireNonNull(host, "Host cannot be null");
        Objects.requireNonNull(schema, "Schema cannot be null");
        Objects.requireNonNull(user, "User cannot be null");

        if (host.isBlank()) {
            throw new IllegalArgumentException("Host cannot be blank");
        }
        if (port < 1 || port > 65535) {
            throw new IllegalArgumentException("Port must be between 1 and 65535: " + port);
        }
        if (!schema.matches("[a-zA-Z_][a-zA-Z0-9_]*")) {
            throw new IllegalArgumentException("Invalid schema name: " + schema);
        }

        // All validated -- safe to proceed with connection setup
        super(host, port, user);

        // Now we can initialize our own fields
        this.schema = schema;
    }
}

public class Order extends BaseEntity {

    public Order(List items, Customer customer, LocalDate deliveryDate) {
        // Business rule validation in the prologue
        if (items == null || items.isEmpty()) {
            throw new IllegalArgumentException("Order must have at least one item");
        }
        if (customer.isSuspended()) {
            throw new IllegalStateException("Cannot create order for suspended customer: "
                + customer.getId());
        }
        if (deliveryDate.isBefore(LocalDate.now().plusDays(1))) {
            throw new IllegalArgumentException("Delivery date must be at least tomorrow");
        }

        double total = items.stream()
            .mapToDouble(item -> item.price() * item.quantity())
            .sum();

        if (total > customer.getCreditLimit()) {
            throw new IllegalStateException(
                "Order total $%.2f exceeds credit limit $%.2f".formatted(
                    total, customer.getCreditLimit()));
        }

        // All business rules passed -- initialize the entity
        super(UUID.randomUUID(), LocalDateTime.now());
    }
}

public class HttpEndpoint extends Endpoint {

    public HttpEndpoint(String rawUrl) {
        // Parse and normalize the URL before passing to superclass
        String url = rawUrl.trim().toLowerCase();
        if (!url.startsWith("http://") && !url.startsWith("https://")) {
            url = "https://" + url;
        }

        URI uri = URI.create(url);
        String host = uri.getHost();
        int port = uri.getPort() == -1 ? 443 : uri.getPort();
        String path = uri.getPath().isEmpty() ? "/" : uri.getPath();

        super(host, port, path);
    }
}

public class Circle extends Shape {

    public Circle(double radius) {
        if (radius <= 0) {
            throw new IllegalArgumentException("Radius must be positive: " + radius);
        }

        // Compute area and circumference to pass to superclass
        double area = Math.PI * radius * radius;
        double circumference = 2 * Math.PI * radius;

        super("Circle", area, circumference);
    }
}

public class Rectangle extends Shape {

    public Rectangle(double width, double height) {
        if (width <= 0 || height <= 0) {
            throw new IllegalArgumentException(
                "Dimensions must be positive: %s x %s".formatted(width, height));
        }

        double area = width * height;
        double perimeter = 2 * (width + height);

        super("Rectangle", area, perimeter);
    }
}

public class ConfigurableService extends ManagedService {

    public ConfigurableService(Path configPath) {
        // Read and parse configuration before superclass init
        Properties props;
        try {
            props = new Properties();
            props.load(Files.newInputStream(configPath));
        } catch (IOException e) {
            throw new UncheckedIOException("Cannot read config: " + configPath, e);
        }

        String serviceName = props.getProperty("service.name", "default");
        int threadPoolSize = Integer.parseInt(
            props.getProperty("thread.pool.size", "10"));
        Duration timeout = Duration.parse(
            props.getProperty("timeout", "PT30S"));

        super(serviceName, threadPoolSize, timeout);
    }
}

class Parent {
    int parentField;
    void parentMethod() { System.out.println("parent"); }
}

class Child extends Parent {
    int childField = 10;
    String name;  // No initializer -- can be assigned in prologue

    Child(int value) {
        // CANNOT reference 'this' explicitly
        System.out.println(this);           // COMPILE ERROR
        this.hashCode();                    // COMPILE ERROR

        // CANNOT read instance fields (even uninitialized ones)
        int x = childField;                // COMPILE ERROR
        int y = this.childField;           // COMPILE ERROR

        // CANNOT call instance methods
        toString();                         // COMPILE ERROR
        this.someMethod();                  // COMPILE ERROR

        // CANNOT access superclass members
        int z = super.parentField;          // COMPILE ERROR
        super.parentMethod();               // COMPILE ERROR

        // CANNOT create inner class instances (they capture 'this')
        class Inner {}
        new Inner();                        // COMPILE ERROR

        super(value);
    }

    void someMethod() {}
}

class Child extends Parent {
    final int x;       // No initializer
    String label;      // No initializer

    Child(int value, String rawLabel) {
        // CAN declare and use local variables
        int computed = value * 2 + 1;
        String normalized = rawLabel.trim().toLowerCase();

        // CAN call static methods
        Objects.requireNonNull(rawLabel);
        int validated = Math.max(0, value);

        // CAN throw exceptions
        if (value < 0) {
            throw new IllegalArgumentException("negative: " + value);
        }

        // CAN use control flow (if/else, switch, try/catch, loops)
        String prefix;
        switch (value) {
            case 0 -> prefix = "ZERO";
            case 1 -> prefix = "ONE";
            default -> prefix = "OTHER";
        }

        // CAN assign to uninitialized fields (no initializer in declaration)
        this.x = computed;
        this.label = prefix + "_" + normalized;

        // CAN access enclosing instance (if this is a nested class)
        // CAN use constructor parameters
        // CAN create objects that do not reference 'this'

        super(validated);
    }
}

class Super {
    Super() {
        // Superclass constructor calls overridable method
        overriddenMethod();
    }
    void overriddenMethod() {}
}

// BEFORE Java 25: Field is 0 when overriddenMethod() is called
class OldSub extends Super {
    final int x;
    OldSub(int x) {
        super();          // Calls overriddenMethod() -- this.x is still 0!
        this.x = x;       // Too late
    }
    @Override
    void overriddenMethod() {
        System.out.println("x = " + x);  // Prints "x = 0" -- uninitialized!
    }
}

// AFTER Java 25: Field is properly set before super() runs
class NewSub extends Super {
    final int x;
    NewSub(int x) {
        this.x = x;       // Set field BEFORE super()
        super();           // Calls overriddenMethod() -- this.x is already set!
    }
    @Override
    void overriddenMethod() {
        System.out.println("x = " + x);  // Prints "x = 42" -- correct!
    }
}

public static void main(String[] args) {
    new OldSub(42);  // Prints: x = 0
    new NewSub(42);  // Prints: x = 42
}

// BEFORE: Validation AFTER super() -- too late, superclass already ran
class OldEmployee extends Person {
    OldEmployee(String name, int age) {
        super(name, age);  // Person does work with potentially bad values
        if (age < 0 || age > 150) {
            throw new IllegalArgumentException("Invalid age: " + age);
        }
    }
}

// AFTER: Validation BEFORE super() -- fail fast
class NewEmployee extends Person {
    NewEmployee(String name, int age) {
        if (age < 0 || age > 150) {
            throw new IllegalArgumentException("Invalid age: " + age);
        }
        Objects.requireNonNull(name, "Name required");
        super(name, age);
    }
}

// BEFORE: Static helper method workaround
class OldHttpUrl extends Url {
    OldHttpUrl(String rawUrl) {
        super(normalizeUrl(rawUrl));  // Must use static method
    }

    // Forced to write a static helper just to prepare the argument
    private static String normalizeUrl(String raw) {
        String url = raw.trim().toLowerCase();
        if (!url.startsWith("https://")) {
            url = "https://" + url;
        }
        return url;
    }
}

// AFTER: Inline computation in the prologue
class NewHttpUrl extends Url {
    NewHttpUrl(String rawUrl) {
        String url = rawUrl.trim().toLowerCase();
        if (!url.startsWith("https://")) {
            url = "https://" + url;
        }
        super(url);
    }
}

// BEFORE: Ternary operator abuse for conditional arguments
class OldRetryPolicy extends Policy {
    OldRetryPolicy(int maxRetries, Duration timeout) {
        super(
            maxRetries <= 0 ? 3 : maxRetries,           // Default if invalid
            timeout == null ? Duration.ofSeconds(30) : timeout,  // Default if null
            maxRetries > 10 ? "aggressive" : "standard"  // Computed strategy
        );
    }
}

// AFTER: Clear, readable prologue
class NewRetryPolicy extends Policy {
    NewRetryPolicy(int maxRetries, Duration timeout) {
        // Normalize with clear variable names
        int retries = maxRetries <= 0 ? 3 : maxRetries;
        Duration actualTimeout = timeout != null ? timeout : Duration.ofSeconds(30);
        String strategy = retries > 10 ? "aggressive" : "standard";

        super(retries, actualTimeout, strategy);
    }
}

// BEFORE: Multiple static helpers or deeply nested ternaries
class OldSecureConnection extends Connection {
    OldSecureConnection(String host, Map config) {
        super(
            extractHost(host),
            extractPort(host, config),
            buildSslContext(config)
        );
    }

    private static String extractHost(String host) {
        return host.contains(":") ? host.split(":")[0] : host;
    }

    private static int extractPort(String host, Map config) {
        if (host.contains(":")) {
            return Integer.parseInt(host.split(":")[1]);
        }
        return Integer.parseInt(config.getOrDefault("default.port", "443"));
    }

    private static SSLContext buildSslContext(Map config) {
        try {
            SSLContext ctx = SSLContext.getInstance(
                config.getOrDefault("ssl.protocol", "TLSv1.3"));
            ctx.init(null, null, null);
            return ctx;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

// AFTER: Everything inline in the prologue -- clear flow, no scattered helpers
class NewSecureConnection extends Connection {
    NewSecureConnection(String host, Map config) {
        // Parse host and port
        String actualHost;
        int port;
        if (host.contains(":")) {
            String[] parts = host.split(":");
            actualHost = parts[0];
            port = Integer.parseInt(parts[1]);
        } else {
            actualHost = host;
            port = Integer.parseInt(config.getOrDefault("default.port", "443"));
        }

        // Build SSL context
        SSLContext sslContext;
        try {
            String protocol = config.getOrDefault("ssl.protocol", "TLSv1.3");
            sslContext = SSLContext.getInstance(protocol);
            sslContext.init(null, null, null);
        } catch (Exception e) {
            throw new RuntimeException("Failed to create SSL context", e);
        }

        super(actualHost, port, sslContext);
    }
}

// BEFORE: Cannot make defensive copy before super()
class OldImmutableConfig extends Config {
    private final Map properties;

    OldImmutableConfig(Map properties) {
        super(properties);  // Passes mutable reference to super!
        // Defensive copy is too late -- super already has the mutable reference
        this.properties = Map.copyOf(properties);
    }
}

// AFTER: Defensive copy in prologue -- super gets the immutable version
class NewImmutableConfig extends Config {
    private final Map properties;

    NewImmutableConfig(Map properties) {
        // Make defensive copy BEFORE super sees it
        var safeCopy = Map.copyOf(properties);
        super(safeCopy);  // Super gets the immutable copy
        this.properties = safeCopy;
    }
}

// OLD: Static factory workaround
class OldPercentage extends Number {
    private final double value;

    // Private constructor -- no validation here
    private OldPercentage(double validated) {
        this.value = validated;
    }

    // Public factory does the validation
    public static OldPercentage of(double value) {
        if (value < 0 || value > 100) {
            throw new IllegalArgumentException("Not a percentage: " + value);
        }
        return new OldPercentage(value);
    }

    // ... Number abstract methods ...
}

// NEW: Direct constructor with prologue
class NewPercentage extends Number {
    private final double value;

    public NewPercentage(double value) {
        if (value < 0 || value > 100) {
            throw new IllegalArgumentException("Not a percentage: " + value);
        }
        super();
        this.value = value;
    }

    // ... Number abstract methods ...
}

// OLD: Static helper method to compute super() arguments
class OldTimestamp extends Instant {
    OldTimestamp(String isoString) {
        super(parseToEpochSecond(isoString), parseToNano(isoString));
    }

    private static long parseToEpochSecond(String s) {
        return Instant.parse(s).getEpochSecond();
    }

    private static int parseToNano(String s) {
        return Instant.parse(s).getNano();  // Parses TWICE!
    }
}

// NEW: Parse once in the prologue
class NewTimestamp extends Instant {
    NewTimestamp(String isoString) {
        Instant parsed = Instant.parse(isoString);
        super(parsed.getEpochSecond(), parsed.getNano());  // Parse once, use twice
    }
}

// OLD: Unreadable nested ternaries
class OldCacheConfig extends Config {
    OldCacheConfig(String name, int size, boolean isLocal) {
        super(
            name == null ? "default-cache" : name.trim(),
            size <= 0 ? (isLocal ? 1000 : 10000) : Math.min(size, isLocal ? 5000 : 50000),
            isLocal ? Duration.ofMinutes(5) : Duration.ofHours(1),
            name != null && name.startsWith("temp-") ? EvictionPolicy.LRU : EvictionPolicy.LFU
        );  // Good luck debugging this
    }
}

// NEW: Clear, debuggable prologue
class NewCacheConfig extends Config {
    NewCacheConfig(String name, int size, boolean isLocal) {
        String cacheName = (name == null) ? "default-cache" : name.trim();

        int maxAllowed = isLocal ? 5000 : 50000;
        int defaultSize = isLocal ? 1000 : 10000;
        int cacheSize = (size <= 0) ? defaultSize : Math.min(size, maxAllowed);

        Duration ttl = isLocal ? Duration.ofMinutes(5) : Duration.ofHours(1);

        EvictionPolicy policy = (name != null && name.startsWith("temp-"))
            ? EvictionPolicy.LRU
            : EvictionPolicy.LFU;

        super(cacheName, cacheSize, ttl, policy);
    }
}

public class RestClient extends HttpClient {

    public RestClient(RestClientConfig config) {
        // Extract and validate in the prologue
        Objects.requireNonNull(config, "Config required");
        String baseUrl = config.getBaseUrl();
        if (baseUrl == null || baseUrl.isBlank()) {
            throw new IllegalArgumentException("Base URL required");
        }

        Duration connectTimeout = config.getConnectTimeout() != null
            ? config.getConnectTimeout()
            : Duration.ofSeconds(10);

        Duration readTimeout = config.getReadTimeout() != null
            ? config.getReadTimeout()
            : Duration.ofSeconds(30);

        int maxConnections = Math.max(1, config.getMaxConnections());

        // Pass extracted values to superclass
        super(baseUrl, connectTimeout, readTimeout, maxConnections);
    }
}

public class ImmutableMatrix extends Matrix {

    public ImmutableMatrix(double[][] data) {
        // Deep defensive copy in the prologue
        Objects.requireNonNull(data, "Data required");
        if (data.length == 0) {
            throw new IllegalArgumentException("Matrix must have at least one row");
        }

        int cols = data[0].length;
        double[][] copy = new double[data.length][cols];
        for (int i = 0; i < data.length; i++) {
            if (data[i].length != cols) {
                throw new IllegalArgumentException("Jagged arrays not allowed");
            }
            System.arraycopy(data[i], 0, copy[i], 0, cols);
        }

        // Super receives the defensive copy -- original cannot mutate our state
        super(copy, data.length, cols);
    }
}

public class EmailAddress extends Address {

    public EmailAddress(String email) {
        Objects.requireNonNull(email, "Email required");

        // Canonicalize: trim, lowercase, validate format
        String canonical = email.trim().toLowerCase(Locale.ROOT);

        if (!canonical.matches("^[a-z0-9._%+-]+@[a-z0-9.-]+\\.[a-z]{2,}$")) {
            throw new IllegalArgumentException("Invalid email format: " + email);
        }

        // Split into parts for the superclass
        int atIndex = canonical.indexOf('@');
        String localPart = canonical.substring(0, atIndex);
        String domain = canonical.substring(atIndex + 1);

        super(localPart, domain);
    }
}

public class AuditedTransaction extends Transaction {
    private static final Logger log = LoggerFactory.getLogger(AuditedTransaction.class);

    public AuditedTransaction(BigDecimal amount, String fromAccount, String toAccount) {
        // Log and audit BEFORE the transaction is constructed
        log.info("Creating transaction: {} from {} to {}",
            amount, fromAccount, toAccount);

        if (amount.compareTo(BigDecimal.ZERO) <= 0) {
            log.warn("Rejected: non-positive amount {}", amount);
            throw new IllegalArgumentException("Amount must be positive");
        }

        if (amount.compareTo(new BigDecimal("1000000")) > 0) {
            log.warn("Large transaction flagged for review: {}", amount);
            AuditService.flagForReview(fromAccount, toAccount, amount);
        }

        // Generate a unique transaction ID
        String txId = UUID.randomUUID().toString();
        log.debug("Assigned transaction ID: {}", txId);

        super(txId, amount, fromAccount, toAccount);
    }
}

record Point(double x, double y) {

    // Compact canonical constructor -- validates components
    Point {
        if (Double.isNaN(x) || Double.isNaN(y)) {
            throw new IllegalArgumentException("Coordinates cannot be NaN");
        }
    }

    // Non-canonical: construct from polar coordinates
    Point(double radius, double angleRadians, boolean polar) {
        // Prologue: validate and convert polar to cartesian
        if (radius < 0) {
            throw new IllegalArgumentException("Radius cannot be negative: " + radius);
        }
        double cartX = radius * Math.cos(angleRadians);
        double cartY = radius * Math.sin(angleRadians);

        this(cartX, cartY);  // Delegate to canonical constructor
    }

    // Non-canonical: construct from string "x,y"
    Point(String coordinates) {
        // Prologue: parse and validate
        Objects.requireNonNull(coordinates, "Coordinates string required");
        String[] parts = coordinates.split(",");
        if (parts.length != 2) {
            throw new IllegalArgumentException(
                "Expected format 'x,y' but got: " + coordinates);
        }

        double parsedX;
        double parsedY;
        try {
            parsedX = Double.parseDouble(parts[0].trim());
            parsedY = Double.parseDouble(parts[1].trim());
        } catch (NumberFormatException e) {
            throw new IllegalArgumentException(
                "Invalid coordinate numbers: " + coordinates, e);
        }

        this(parsedX, parsedY);
    }
}

record DateRange(LocalDate start, LocalDate end) {

    // Canonical validates ordering
    DateRange {
        if (start.isAfter(end)) {
            throw new IllegalArgumentException(
                "Start date %s is after end date %s".formatted(start, end));
        }
    }

    // Construct from a pair of ISO strings
    DateRange(String startStr, String endStr) {
        LocalDate parsedStart = LocalDate.parse(startStr);
        LocalDate parsedEnd = LocalDate.parse(endStr);

        this(parsedStart, parsedEnd);  // Delegates to canonical
    }

    // Construct a range of N days starting from a date
    DateRange(LocalDate start, int days) {
        if (days <= 0) {
            throw new IllegalArgumentException("Days must be positive: " + days);
        }
        LocalDate computedEnd = start.plusDays(days - 1);

        this(start, computedEnd);
    }

    // Construct for "this week" (Monday to Sunday)
    DateRange(int isoWeekNumber, int year) {
        if (isoWeekNumber < 1 || isoWeekNumber > 53) {
            throw new IllegalArgumentException("Invalid week: " + isoWeekNumber);
        }

        LocalDate monday = LocalDate.of(year, 1, 1)
            .with(java.time.temporal.WeekFields.ISO.weekOfYear(), isoWeekNumber)
            .with(java.time.DayOfWeek.MONDAY);

        LocalDate sunday = monday.plusDays(6);

        this(monday, sunday);
    }
}

record ImmutablePair(A first, B second) {

    ImmutablePair {
        Objects.requireNonNull(first, "First element cannot be null");
        Objects.requireNonNull(second, "Second element cannot be null");
    }

    // Construct from a Map.Entry with defensive extraction
    ImmutablePair(Map.Entry entry) {
        Objects.requireNonNull(entry, "Entry cannot be null");

        // Extract values in prologue -- entry might be modified concurrently
        A extractedFirst = entry.getKey();
        B extractedSecond = entry.getValue();

        this(extractedFirst, extractedSecond);
    }
}

// GOOD: Short, focused prologue
public class ApiClient extends HttpClient {
    public ApiClient(String baseUrl) {
        Objects.requireNonNull(baseUrl, "Base URL required");
        String normalized = baseUrl.endsWith("/")
            ? baseUrl.substring(0, baseUrl.length() - 1)
            : baseUrl;
        super(URI.create(normalized));
    }
}

// BAD: Prologue doing too much work
public class OverEngineered extends Service {
    public OverEngineered(Path configFile) {
        // 50 lines of config parsing, network calls, database lookups...
        // This belongs in a factory method or builder, not a prologue
        Properties props = new Properties();
        // ... 40 more lines ...
        super(/* many args */);
    }
}

// Pattern 1: Fail-fast with descriptive messages
public class Account extends Entity {
    public Account(String id, BigDecimal balance, String currency) {
        Objects.requireNonNull(id, "Account ID cannot be null");
        Objects.requireNonNull(balance, "Balance cannot be null");
        Objects.requireNonNull(currency, "Currency cannot be null");

        if (id.length() != 10) {
            throw new IllegalArgumentException(
                "Account ID must be 10 characters, got: " + id.length());
        }
        if (balance.signum() < 0) {
            throw new IllegalArgumentException(
                "Initial balance cannot be negative: " + balance);
        }
        if (!Set.of("USD", "EUR", "GBP", "JPY").contains(currency)) {
            throw new IllegalArgumentException(
                "Unsupported currency: " + currency);
        }

        super(id, balance, currency);
    }
}

// Pattern 2: Use Preconditions utility (like Guava)
public class Shipment extends Entity {
    public Shipment(String trackingId, double weight, String destination) {
        Preconditions.checkNotNull(trackingId, "Tracking ID required");
        Preconditions.checkArgument(weight > 0, "Weight must be positive: %s", weight);
        Preconditions.checkArgument(
            destination != null && !destination.isBlank(),
            "Destination required");

        super(trackingId);
    }
}

// Step 1: Identify the pattern
class Before extends Parent {
    Before(String input) {
        super(validate(input), transform(input));  // Static helpers
    }
    private static String validate(String s) {
        if (s == null || s.isBlank()) throw new IllegalArgumentException("blank");
        return s;
    }
    private static int transform(String s) {
        return s.trim().length();
    }
}

// Step 2 & 3: Inline and delete
class After extends Parent {
    After(String input) {
        if (input == null || input.isBlank()) {
            throw new IllegalArgumentException("blank");
        }
        String trimmed = input.trim();
        int length = trimmed.length();
        super(trimmed, length);
    }
    // No more static helpers needed
}

---