Java Immutable Objects, final Keyword & Thread Safety

import java.util.Arrays;

// ---------------------------------------------------------------
// IMMUTABLE CLASS: Money (5 Rules Applied)
// ---------------------------------------------------------------
final class Money {
    private final double amount;
    private final String currency;

    public Money(double amount, String currency) {
        if (amount < 0) throw new IllegalArgumentException("Negative amount: " + amount);
        if (currency == null || currency.isBlank()) throw new IllegalArgumentException("Currency required.");
        this.amount   = amount;
        this.currency = currency.toUpperCase().trim();
    }

    public double getAmount()   { return amount; }
    public String getCurrency() { return currency; }

    // Immutable update pattern: returns NEW object instead of mutating!
    public Money add(Money other) {
        if (!this.currency.equals(other.currency))
            throw new IllegalArgumentException("Cannot add different currencies: "
                    + this.currency + " and " + other.currency);
        return new Money(this.amount + other.amount, this.currency);
    }

    public Money multiply(double factor) {
        return new Money(this.amount * factor, this.currency);
    }

    @Override
    public String toString() {
        return String.format("Money{%.2f %s}", amount, currency);
    }
}

// ---------------------------------------------------------------
// IMMUTABLE CLASS WITH ARRAY FIELD: Snapshot (Defensive Copying)
// ---------------------------------------------------------------
final class DataSnapshot {
    private final String label;
    private final int[] readings; // Mutable array — must defensive copy!
    private final long timestamp;

    public DataSnapshot(String label, int[] readings) {
        this.label     = label;
        this.readings  = readings.clone(); // Rule 5: defensive copy IN constructor
        this.timestamp = System.currentTimeMillis();
    }

    public String getLabel()    { return label; }
    public long getTimestamp()  { return timestamp; }
    public int[] getReadings()  { return readings.clone(); } // Rule 5: defensive copy OUT getter

    public double getAverage() {
        int sum = 0;
        for (int r : readings) sum += r;
        return (double) sum / readings.length;
    }

    @Override
    public String toString() {
        return String.format("Snapshot{label='%s', avg=%.1f, readings=%s}",
                label, getAverage(), Arrays.toString(readings));
    }
}

// ---------------------------------------------------------------
// Java 16+ RECORD: Concise immutable data
// ---------------------------------------------------------------
record Point(double x, double y) {
    // Compact constructor with validation
    Point {
        if (Double.isNaN(x) || Double.isNaN(y))
            throw new IllegalArgumentException("Coordinates cannot be NaN!");
    }

    // Custom method (records can have methods!)
    public double distanceTo(Point other) {
        double dx = this.x - other.x;
        double dy = this.y - other.y;
        return Math.sqrt(dx * dx + dy * dy);
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println("=== 1. Immutable Money Operations ===");
        Money price    = new Money(49.99, "usd");
        Money tax      = new Money(8.99,  "usd");
        Money subtotal = price.add(tax);           // Returns new Money object!
        Money doubled  = subtotal.multiply(2.0);   // Returns new Money object!

        System.out.println("Price    : " + price);
        System.out.println("Tax      : " + tax);
        System.out.println("Subtotal : " + subtotal);
        System.out.println("Doubled  : " + doubled);

        System.out.println("
=== 2. Defensive Copy Protection in DataSnapshot ===");
        int[] sensorData = {45, 78, 92, 61, 55};
        DataSnapshot snap = new DataSnapshot("Temperature Sensor A", sensorData);

        // Try to corrupt via original array (protected by constructor copy)
        sensorData[0] = 0;
        System.out.println("Original array corrupted: sensorData[0] = " + sensorData[0]);
        System.out.println("Snapshot internal safe  : " + snap.getReadings()[0]);
        System.out.println("Snapshot                : " + snap);

        // Try to corrupt via returned array (protected by getter copy)
        int[] returned = snap.getReadings();
        returned[0] = 9999;
        System.out.println("Returned array changed  : returned[0] = " + returned[0]);
        System.out.println("Snapshot still safe     : " + snap.getReadings()[0]);

        System.out.println("
=== 3. Java Record Demo ===");
        Point origin = new Point(0, 0);
        Point target = new Point(3.0, 4.0);

        System.out.println("Origin      : " + origin);
        System.out.println("Target      : " + target);
        System.out.printf("Distance    : %.2f units%n", origin.distanceTo(target));
        System.out.println("x component : " + target.x());
        System.out.println("y component : " + target.y());

        System.out.println("
=== 4. Currency Mismatch Exception ===");
        try {
            Money usd = new Money(100, "USD");
            Money eur = new Money(90,  "EUR");
            usd.add(eur); // Different currencies!
        } catch (IllegalArgumentException e) {
            System.out.println("Currency error: " + e.getMessage());
        }
    }
}

// Industry Simulation: Audit Log Entry (Must be immutable for compliance!)
final class AuditEntry {
    private final String userId;
    private final String action;
    private final long timestamp;

    public AuditEntry(String userId, String action) {
        if (userId == null || action == null) throw new IllegalArgumentException("Fields required.");
        this.userId    = userId;
        this.action    = action;
        this.timestamp = System.currentTimeMillis();
    }

    public String getUserId()   { return userId; }
    public String getAction()   { return action; }
    public long getTimestamp()  { return timestamp; }

    @Override
    public String toString() {
        return String.format("AuditEntry{user='%s', action='%s', ts=%d}", userId, action, timestamp);
    }
}

public class PracticalApplication {
    public static void main(String[] args) {
        AuditEntry e1 = new AuditEntry("USR-001", "LOGIN");
        AuditEntry e2 = new AuditEntry("USR-001", "TRANSFER_FUNDS");
        AuditEntry e3 = new AuditEntry("USR-002", "CHANGE_PASSWORD");

        System.out.println("=== Compliance Audit Trail (Immutable Log) ===");
        System.out.println(e1);
        System.out.println(e2);
        System.out.println(e3);
    }
}