Money, defensive copies and typed IDs

Thread: Monday's practical hits the double fee bug and the leaking spot list, then builds Money and safe collections → Tuesday's skill block hunts aliasing hazards across the codebase → Wednesday's lecture explains why double cannot hold a fare, entity versus value, the equals/hashCode contract and typed IDs → Thursday's skill block designs typed IDs and a state design with no illegal combinations (used in Weeks 3 and 6).

Practical — P2: defensive copying and immutable Money

Folded in from the lab manual: Lab 2 (ParkingFee must not be negative) as the warm‑up, and Lab 4 (list of vehicles, count cars, remove by number) as the collection task.

public final class Money implements Comparable<Money> {
    private static final Currency INR = Currency.getInstance("INR");
    private final long paise;            // never double
    private final Currency currency;

    private Money(long paise, Currency currency) {
        if (paise < 0) throw new IllegalArgumentException("Money cannot be negative: " + paise);
        this.paise = paise;
        this.currency = Objects.requireNonNull(currency, "currency");
    }
    public static Money ofPaise(long paise)   { return new Money(paise, INR); }
    public static Money ofRupees(long rupees) { return new Money(Math.multiplyExact(rupees, 100), INR); }

    public Money plus(Money o)  { same(o); return new Money(Math.addExact(paise, o.paise), currency); }
    public Money minus(Money o) { same(o); return new Money(Math.subtractExact(paise, o.paise), currency); }
    public Money times(long n)  { return new Money(Math.multiplyExact(paise, n), currency); }

    /** Splits into n parts that differ by at most 1 paisa and add up exactly to this amount. */
    public List<Money> allocate(int n) {
        if (n <= 0) throw new IllegalArgumentException("n must be > 0");
        long base = paise / n, extra = paise % n;
        List<Money> parts = new ArrayList<>(n);
        for (int i = 0; i < n; i++) parts.add(new Money(base + (i < extra ? 1 : 0), currency));
        return List.copyOf(parts);
    }
    private void same(Money o) {
        if (!currency.equals(o.currency)) throw new IllegalArgumentException("Currency mismatch");
    }
    @Override public boolean equals(Object x) {
        return x instanceof Money m && paise == m.paise && currency.equals(m.currency);
    }
    @Override public int hashCode() { return Objects.hash(paise, currency); }
    @Override public int compareTo(Money o) { same(o); return Long.compare(paise, o.paise); }
    @Override public String toString() { return String.format("₹%d.%02d", paise / 100, paise % 100); }
}

Acceptance checks: no double anywhere in fee code; Money.ofPaise(100).allocate(3) gives 34, 33, 33 paise; every leak test now proves the leak is closed; Facility exposes no mutable list.

Deliverable (P): commit W2-P2, green test screenshot, 3–5 lines on why long paise is safer than double.

Skill A — S3: aliasing doorways and escaping references

Worksheet: fill in the blank cells yourself, then compare with your team.

Deliverable (S3): completed review sheet in docs/week02/aliasing-review.md, one fixed hazard with its test, and a UML object diagram of one aliasing case.

Lecture — L3 + L4: Money as a value, identity and equality, typed IDs, illegal states

// Equality that lies: equals/hashCode use the mutable status field
Set<Booking> open = new HashSet<>();
open.add(b);                 // stored in the bucket for status ACTIVE
b.checkOut(exitTime);        // status -> COMPLETED, so hashCode changes
open.contains(b);            // false: the booking is "lost" inside the set
// Rule: entities compare by ID only; values compare by all (immutable) fields.

Deliverable (L): exit ticket with the entity/value classification for 4 types and the team's must‑not‑compile list.

Skill B — S4: typed IDs and illegal states made unrepresentable

Folded in from the lab manual: Lab 3 (immutable VehicleId and BookingId, then SpotId).

public record SpotId(String value) {
    private static final Pattern FORMAT = Pattern.compile("^L\\d{1,2}-[A-Z]\\d{2}$");   // e.g. L2-E07
    public SpotId {
        Objects.requireNonNull(value, "value");
        if (!FORMAT.matcher(value).matches()) throw new IllegalArgumentException("Bad SpotId: " + value);
    }
}

Deliverable (S4): commit W2-S4 with 4 typed‑ID records and tests, docs/week02/must-not-compile.md, and the sealed BookingState class diagram (input to Week 6).