Objects

// ── Object creation and reference ────────────────────────────────────
//
//  StringBuilder sb = new StringBuilder("Hello");
//
//  Stack (variables)       Heap (objects)
//  ┌─────────────────┐    ┌──────────────────────────┐
//  │ sb → [0x4A2F] ──┼───►│ StringBuilder object     │
//  └─────────────────┘    │   value = "Hello"         │
//                         │   capacity = 16           │
//                         └──────────────────────────┘

StringBuilder sb1 = new StringBuilder("Hello");
StringBuilder sb2 = sb1;        // TWO references, ONE object
StringBuilder sb3 = new StringBuilder("Hello");  // NEW object

// ── == compares references (memory addresses) ─────────────────────────
System.out.println(sb1 == sb2);  // true  — same object
System.out.println(sb1 == sb3);  // false — different objects

// ── Shared reference — modification visible through both ──────────────
sb1.append(" World");
System.out.println(sb2.toString());  // "Hello World" — sb2 sees the change

// ── null reference — points nowhere ──────────────────────────────────
String s = null;
System.out.println(s == null);  // true
// s.length();                  // NullPointerException — no object to call on

// ── References as method parameters — pass-by-value ───────────────────
// Java passes the VALUE of the reference (the address), not the object
// The method gets its own copy of the reference

public static void tryReassign(StringBuilder sb) {
    sb = new StringBuilder("New");  // reassigns local copy of reference
    // original reference in caller is unchanged
}

public static void mutate(StringBuilder sb) {
    sb.append(" mutated");  // modifies the object both references point to
    // change IS visible to caller
}

StringBuilder original = new StringBuilder("Original");
tryReassign(original);
System.out.println(original);  // "Original" — reassignment did not propagate

mutate(original);
System.out.println(original);  // "Original mutated" — mutation propagated

// ── Every class inherits from Object ────────────────────────────────
public class Point {
    private final int x;
    private final int y;

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    // ── Default toString() — not useful ───────────────────────────────
    // Point@7852e922   ← class name + hex hashCode
    // Override to return meaningful representation:
    @Override
    public String toString() {
        return "Point(" + x + ", " + y + ")";
    }

    // ── Default equals() uses == (reference equality) ─────────────────
    // Two distinct Point objects with same x,y would NOT be equal
    // Override for value-based equality:
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;       // same reference — definitely equal
        if (!(obj instanceof Point other)) return false;  // null or wrong type
        return this.x == other.x && this.y == other.y;
    }

    // ── hashCode MUST be consistent with equals ───────────────────────
    // Contract: if a.equals(b) then a.hashCode() == b.hashCode()
    // Violation breaks HashMap, HashSet, and any hash-based structure
    @Override
    public int hashCode() {
        return Objects.hash(x, y);   // combines field hash codes
    }
}

// ── Without overrides ─────────────────────────────────────────────────
Point p1 = new Point(3, 4);
Point p2 = new Point(3, 4);
System.out.println(p1.equals(p2));  // false  (default = ==)
System.out.println(p1.toString());  // Point@7852e922

// ── With overrides ────────────────────────────────────────────────────
System.out.println(p1.equals(p2));  // true   (compares x, y)
System.out.println(p1.toString());  // Point(3, 4)

// ── Correct HashMap behaviour requires correct hashCode ──────────────
Set<Point> visited = new HashSet<>();
visited.add(new Point(3, 4));
System.out.println(visited.contains(new Point(3, 4)));  // true (with override)
                                                         // false (without)

// ── Mutable class — state can change after construction ─────────────
public class MutablePoint {
    private int x;
    private int y;

    public MutablePoint(int x, int y) { this.x = x; this.y = y; }

    public void setX(int x) { this.x = x; }
    public void setY(int y) { this.y = y; }
    public int getX() { return x; }
    public int getY() { return y; }

    public void translate(int dx, int dy) {
        this.x += dx;   // modifies state
        this.y += dy;
    }
}

// ── Immutable class — state fixed at construction forever ─────────────
public final class ImmutablePoint {  // final prevents subclasses

    private final int x;   // final — cannot be reassigned
    private final int y;

    public ImmutablePoint(int x, int y) {
        this.x = x;
        this.y = y;
    }

    // No setters — field values can never change
    public int getX() { return x; }
    public int getY() { return y; }

    // Operations return NEW objects rather than modifying this
    public ImmutablePoint translate(int dx, int dy) {
        return new ImmutablePoint(x + dx, y + dy);
    }

    public double distanceTo(ImmutablePoint other) {
        int dx = this.x - other.x;
        int dy = this.y - other.y;
        return Math.sqrt(dx * dx + dy * dy);
    }

    @Override public String toString() {
        return "(" + x + ", " + y + ")";
    }
    @Override public boolean equals(Object o) {
        if (!(o instanceof ImmutablePoint p)) return false;
        return x == p.x && y == p.y;
    }
    @Override public int hashCode() { return Objects.hash(x, y); }
}

// ── Defensive copy for immutability with mutable fields ───────────────
public final class DateRange {

    private final LocalDate start;   // LocalDate is already immutable
    private final LocalDate end;
    private final List<String> tags; // List IS mutable — needs defence

    public DateRange(LocalDate start, LocalDate end,
                     List<String> tags) {
        if (start.isAfter(end)) throw new IllegalArgumentException(
            "Start must not be after end");
        this.start = start;
        this.end   = end;
        this.tags  = List.copyOf(tags);  // defensive copy — immutable view
    }

    public List<String> getTags() {
        return tags;  // safe — already an unmodifiable list
    }
}

// ── Correct equals() and hashCode() ──────────────────────────────────
public class Money {

    private final BigDecimal amount;
    private final String     currency;

    public Money(BigDecimal amount, String currency) {
        Objects.requireNonNull(amount,   "amount cannot be null");
        Objects.requireNonNull(currency, "currency cannot be null");
        this.amount   = amount.stripTrailingZeros();
        this.currency = currency.toUpperCase();
    }

    @Override
    public boolean equals(Object obj) {
        // Step 1: reference check — cheapest possible equality
        if (this == obj) return true;

        // Step 2: null and type check — pattern match in Java 16+
        if (!(obj instanceof Money other)) return false;

        // Step 3: field comparison — the actual equality logic
        return this.amount.compareTo(other.amount) == 0
            && this.currency.equals(other.currency);
        // Note: BigDecimal.compareTo() not equals() — 2.0 equals 2.00
    }

    @Override
    public int hashCode() {
        // Must use the same normalised form as in equals()
        return Objects.hash(
            amount.stripTrailingZeros(),
            currency);
    }

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

// ── Breaking the contract causes silent data loss ─────────────────────
// Bad implementation — hashCode uses 'amount' but equals ignores scale
// new Money("2.00", "USD") and new Money("2.0", "USD") could be
// "equal" per equals() but have DIFFERENT hashCode — this breaks HashMap

// ── Correct behaviour ─────────────────────────────────────────────────
Money m1 = new Money(new BigDecimal("10.00"), "USD");
Money m2 = new Money(new BigDecimal("10.0"),  "USD");

System.out.println(m1.equals(m2));   // true — compareTo handles scale
System.out.println(m1.hashCode() == m2.hashCode());  // true — must match

Map<Money, String> labels = new HashMap<>();
labels.put(m1, "price");
System.out.println(labels.get(m2));   // "price" — works correctly

// ── Object lifecycle demonstration ───────────────────────────────────
public class ResourceHolder implements AutoCloseable {

    private final String name;
    private boolean open = true;

    public ResourceHolder(String name) {
        this.name = name;
        System.out.println("Created: " + name);
    }

    public void use() {
        if (!open) throw new IllegalStateException(
            name + " is closed");
        System.out.println("Using: " + name);
    }

    @Override
    public void close() {
        open = false;
        System.out.println("Closed: " + name);
    }
}

// ── Lifecycle phases ──────────────────────────────────────────────────
{
    // Phase 1: Creation — memory allocated, constructor runs
    ResourceHolder r = new ResourceHolder("connection");

    // Phase 2: Active use — r references the object on the heap
    r.use();
    r.use();

}   // Phase 3: r goes out of scope — object becomes unreachable
    // GC will eventually reclaim the memory
    // NOTE: close() was NOT called — resource leak!

// ── Correct resource management — try-with-resources ─────────────────
try (ResourceHolder r = new ResourceHolder("connection")) {
    r.use();
    r.use();
}   // close() called automatically at block exit (even on exception)
    // "Closed: connection" always printed

// ── When objects become unreachable ──────────────────────────────────
String s = new String("temporary");
s = "new value";   // original String object now unreachable
                   // (no reference points to it — eligible for GC)

List<Object> cache = new ArrayList<>();
Object big = new Object();
cache.add(big);
big = null;        // big variable released, but cache still holds reference
                   // Object is NOT eligible for GC — cache is reachable

cache.clear();     // now the Object has no live references — eligible for GC

// ── Soft, Weak, and Phantom references ───────────────────────────────
// java.lang.ref package provides weaker reference strengths:
// SoftReference<T>  — collected when JVM needs memory (caches)
// WeakReference<T>  — collected at next GC cycle (canonical maps)
// PhantomReference<T> — collected after finalization (cleanup actions)