Throwable Hierarchy

## Why these exist as a family `RuntimeException` is the unchecked sub-branch of `Exception` reserved for **programming errors** — failures that, in principle, correct code would not produce. Because they signal *bugs*, the language does not force you to declare or catch them; the proper fix is usually to correct the code, not wrap it in `try/catch`. Recognizing each type quickly tells you *what kind of mistake* occurred. ## The common members ### NullPointerException (NPE) Thrown when you try to use a `null` reference as if it pointed to an object — calling a method on it, accessing a field, indexing it, unboxing it, or throwing it. The single most common runtime exception. Since Java 14, *helpful NPE messages* name exactly which variable was null ("Cannot invoke \"String.length()\" because \"name\" is null"). ```java String s = null; int n = s.length(); // NullPointerException ``` ### IllegalArgumentException (IAE) Thrown to indicate a method was passed an argument that is unacceptable by its contract — e.g. a negative count where only non-negative is allowed. You throw this yourself in *guard clauses* to reject bad input early. ```java void setAge(int age) { if (age < 0) throw new IllegalArgumentException("age must be >= 0"); } ``` ### NumberFormatException A **subclass of `IllegalArgumentException`**, specifically for failed string→number conversions. ```java Integer.parseInt("12x"); // NumberFormatException ``` ### IllegalStateException (ISE) Thrown when a method is called at a time the object isn't ready for it — the *arguments* may be fine, but the *object's state* is wrong. E.g. calling `next()` rules, or starting an already-started thread, or modifying a builder after it was consumed. ```java Iterator<String> it = list.iterator(); it.remove(); // IllegalStateException — next() wasn't called yet ``` ### ClassCastException (CCE) Thrown when you cast an object to a type it is not actually an instance of. Common with raw collections or careless downcasts. ```java Object o = "hello"; Integer i = (Integer) o; // ClassCastException ``` ### ArrayIndexOutOfBoundsException / IndexOutOfBoundsException `IndexOutOfBoundsException` is the general case (used by `List`, etc.); `ArrayIndexOutOfBoundsException` and `StringIndexOutOfBoundsException` are array/string-specific subclasses. Thrown when an index is negative or ≥ the length. ```java int[] a = new int[3]; int x = a[3]; // ArrayIndexOutOfBoundsException (valid indices 0..2) ``` ### ConcurrentModificationException (CME) Thrown by many collections' iterators when the collection is *structurally modified* (add/remove) during iteration by anything other than the iterator's own methods. It can occur even in single-threaded code — the name refers to modification *concurrent with iteration*, not necessarily multiple threads. The fix is to use the iterator's `remove()`, collect changes and apply after, or use a copy-on-write/concurrent collection. ```java for (String s : list) { if (s.isEmpty()) list.remove(s); // ConcurrentModificationException } ``` ## How to reason about them When you see one in a stack trace, read it as a *diagnosis*: NPE → a missing null check; IAE/NumberFormat → bad input reaching a method; ISE → an operation in the wrong lifecycle order; CCE → a type assumption that was false; IndexOutOfBounds → off-by-one or unchecked bounds; CME → mutating while looping. Because all are unchecked, the goal is prevention (guards, validation, correct logic), not blanket catching.