What is a compact canonical constructor in Records?

Question

Accepted Answer

**Compact canonical constructor** — validation without parameter list repetition.

**Regular constructor:**
- Must repeat all parameters.
- Assigns fields manually.
- More verbose but more explicit.

```java
public record Person(String name, int age) {
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
```

**Compact canonical constructor:**
- No parameter list.
- Fields are assigned automatically after body.
- Only for validation/modification.
- Cannot assign fields explicitly — assignment happens automatically.

```java
public record Person(String name, int age) {
    public Person {
        // Validation only
        if (name == null || name.isBlank()) {
            throw new IllegalArgumentException("Name cannot be blank");
        }
        if (age < 0 || age > 150) {
            throw new IllegalArgumentException("Invalid age");
        }
        // Fields assigned automatically after this block
    }
}
```

**How it works step-by-step:**
1. The constructor body runs first (validation logic).
2. After the body completes, fields are assigned from the constructor parameters.
3. You cannot assign `this.name = name` in a compact constructor — the compiler does it.
4. If you need to modify values, use a regular canonical constructor instead.

**Real-world example with normalization:**
```java
public record Email(String address) {
    public Email {
        if (address == null || !address.contains("@")) {
            throw new IllegalArgumentException("Invalid email: " + address);
        }
        // Note: we cannot do address = address.toLowerCase() here
        // because compact constructors assign fields after the body
    }
}

// For normalization, use a regular canonical constructor
public record Email(String address) {
    public Email(String address) {
        this.address = address != null ? address.toLowerCase() : null;
    }
}
```

**Benefits:**
- Less boilerplate.
- Clear separation of validation and assignment.
- Reduces errors from manual field assignment.

Java: What is a compact canonical constructor in Records?