Immutable Classes

import java.util.Arrays;

public class Seal {

    // Both ends are open. Leave this one exactly as it is.
    static final class LeakySquad {
        private final String name;
        private final int[] memberIds;

        LeakySquad(String name, int[] memberIds) {
            this.name = name;
            this.memberIds = memberIds;
        }

        String getName()     { return name; }
        int[] getMemberIds() { return memberIds; }
        public String toString() { return name + " " + Arrays.toString(memberIds); }
    }

    // TODO: the same class with both holes closed
    static final class SealedSquad {
        private final String name;
        private final int[] memberIds;

        SealedSquad(String name, int[] memberIds) {
            this.name = name;
            this.memberIds = memberIds;
        }

        String getName()     { return name; }
        int[] getMemberIds() { return memberIds; }
        public String toString() { return name + " " + Arrays.toString(memberIds); }
    }

    // A mutable field that is not an array. Same question.
    static final class BuilderSquad {
        private final StringBuilder notes;
        BuilderSquad(StringBuilder notes) { this.notes = notes; }
        StringBuilder getNotes() { return notes; }
    }

    // Try to change the PRIVATE array from outside. Did it work?
    static boolean leaksThroughConstructor() { return false; }  // TODO
    static boolean leaksThroughGetter()      { return false; }  // TODO

    // Now try the same two attacks on SealedSquad.
    static boolean sealedResistsConstructor() { return true; }  // TODO
    static boolean sealedResistsGetter()      { return true; }  // TODO

    // Which fields need a defensive copy, and which do not?
    static boolean nameNeedsCopy()    { return true; }   // TODO
    static boolean builderNeedsCopy() { return false; }  // TODO

    // Show the StringBuilder field leaking the same way the array did.
    static boolean leaksThroughStringBuilder() { return false; }  // TODO

    // How many copies does closing this properly take?
    static int copiesNeeded() { return 1; }  // TODO

    public static void main(String[] args) {
        // TODO: change a private final field from outside, twice, two different ways
    }
}

import java.math.BigDecimal;

public final class Money {
    private final BigDecimal amount;
    private final String currency;

    public Money(BigDecimal amount, String currency) {
        this.amount = amount;
        this.currency = currency;
    }

    public BigDecimal amount()  { return amount; }
    public String currency()    { return currency; }

    // TODO: return a new Money holding the sum. Reject a different currency.
    public Money plus(Money other) {
        return null;
    }

    // TODO: return a new Money holding the difference. Reject a different currency.
    public Money minus(Money other) {
        return null;
    }

    // TODO: return a new Money worth factor times this one.
    public Money times(int factor) {
        return null;
    }

    // TODO: answer this once you have written the three methods above.
    // Do BigDecimal and String need copying before you store them?
    public static boolean fieldsNeedDefensiveCopies() { return true; }

    @Override public String toString() { return currency + " " + amount; }

    public static void main(String[] args) {
        Money a = new Money(new BigDecimal("10.50"), "INR");
        Money b = new Money(new BigDecimal("4.25"), "INR");

        Money sum = a.plus(b);
        System.out.println("a   = " + a);       // must still be 10.50
        System.out.println("sum = " + sum);
    }
}

import java.util.*;

public class Shallow {
    record Squad(String name, int[] memberIds, List<String> notes) { }

    // TODO: did the String field need copying before it was stored?
    static boolean nameFieldNeededCopying() { return true; }

    // TODO: after List.copyOf, did the notes accessor need overriding?
    static boolean notesAccessorNeededOverriding() { return true; }

    public static void main(String[] args) {
        int[] ids = {101, 102};
        List<String> notes = new ArrayList<>(List.of("initial"));

        Squad alpha = new Squad("Alpha", ids, notes);
        System.out.println("built : " + alpha.name() + " " + Arrays.toString(alpha.memberIds()) + " " + alpha.notes());

        ids[0] = 999;
        notes.add("added from outside");
        alpha.memberIds()[1] = 888;

        System.out.println("after : " + alpha.name() + " " + Arrays.toString(alpha.memberIds()) + " " + alpha.notes());

        // TODO: fix the record so none of those three lines can affect it
    }
}

import java.util.*;

public class ImmutableRegistry {
    // TODO: final class Unit    - name, id, readiness, active. Immutable.
    // TODO: final class Registry - name, List<Unit>. Immutable.
    //
    // Registry needs:
    //   withUnit(Unit u)       -> a NEW Registry with one more unit
    //   withoutUnit(int id)    -> a NEW Registry with that unit gone
    //   units()                -> callers must not be able to modify the list
    //   findById(int id)       -> Unit or null
    //   averageReadiness()

    public static void main(String[] args) {
        // build a Registry, add units with withUnit, and prove the original never changes
    }
}