OOP & Collections Deep Dive

class BankAccount {
    private double balance;  // hidden — cannot access directly
    BankAccount(double init) { balance = init; }

    public void deposit(double amt) {
        if (amt <= 0) throw new IllegalArgumentException("Amount must be positive");
        balance += amt;
    }
    public double getBalance() { return balance; } // read-only access
}
// Cannot do: account.balance = -1000; (compile error!)
// Must go through deposit/withdraw which enforce business rules

abstract class Shape {
    abstract double area();
    void print() { System.out.println("Area: " + area()); } // inherited
}

class Circle extends Shape {
    double r;
    Circle(double r) { this.r = r; }
    @Override double area() { return Math.PI * r * r; }
}

class Rectangle extends Shape {
    double w, h;
    Rectangle(double w, double h) { this.w=w; this.h=h; }
    @Override double area() { return w * h; }
}

// Polymorphism in action:
Shape[] shapes = {new Circle(5), new Rectangle(3,4)};
for (Shape s : shapes) s.print(); // calls correct area() per type

class Employee implements Comparable<Employee> {
    String name; int salary;
    @Override
    public int compareTo(Employee o) {
        return Integer.compare(this.salary, o.salary); // natural order = by salary
    }
}

// Comparable: used when ONE natural ordering makes sense
// TreeSet<Employee> automatically uses compareTo()

// Comparator: used when you need MULTIPLE orderings or can't modify class
Comparator<Employee> byName = Comparator.comparing(e -> e.name);
Comparator<Employee> bySalaryDesc = (a,b) -> b.salary - a.salary;

// Chaining comparators (sort by salary desc, then by name asc)
Comparator<Employee> combined =
    Comparator.comparingInt((Employee e) -> e.salary).reversed()
              .thenComparing(e -> e.name);

list.sort(combined);
Arrays.sort(arr, combined);
new PriorityQueue<>(combined); // custom-ordered heap

// Generic method — works for any Comparable type
public static <T extends Comparable<T>> T findMax(List<T> list) {
    T max = list.get(0);
    for (T item : list) if (item.compareTo(max) > 0) max = item;
    return max;
}

// Bounded wildcards
// ? extends T — can READ (covariant): upper bound
double sumOfList(List<? extends Number> list) {
    double sum = 0;
    for (Number n : list) sum += n.doubleValue();
    return sum;
} // works for List<Integer>, List<Double>, List<Long>

// ? super T — can WRITE (contravariant): lower bound
void addNumbers(List<? super Integer> list) {
    for (int i = 1; i <= 10; i++) list.add(i);
} // works for List<Integer>, List<Number>, List<Object>

// PECS: Producer Extends, Consumer Super

// Pseudocode approximation of ArrayList internals
class SimpleArrayList<T> {
    Object[] data = new Object[10]; // default capacity
    int size = 0;

    void add(T item) {
        if (size == data.length) {               // capacity hit
            int newCap = (size * 3) / 2 + 1;      // ~1.5× growth
            data = Arrays.copyOf(data, newCap);   // O(n) copy!
        }
        data[size++] = item;                      // O(1)
    }

    void remove(int idx) {                       // O(n) — shifts elements left
        System.arraycopy(data, idx+1, data, idx, size-idx-1);
        data[--size] = null;                   // prevent memory leak
    }
}
// Tip: new ArrayList<>(expectedSize) avoids all resizing overhead