throws Clause and Declaration Requirement

## What this is about In Java, an **exception** is an object representing an abnormal event (a file is missing, a number can't be parsed). When code 'throws' an exception, normal execution stops and Java looks for a matching `catch` block up the call stack. The **`throws` clause** is the part of a method's signature that announces which exception types a method might let escape to whoever called it. ```java void loadConfig() throws IOException { ... } ``` This says: "calling `loadConfig()` might result in an `IOException`." ## Checked vs. unchecked exceptions Java splits exceptions into two families based on their class: - **Checked exceptions**: subclasses of `Exception` that are **not** subclasses of `RuntimeException` (e.g. `IOException`, `SQLException`). The compiler *checks* that you deal with them. - **Unchecked exceptions**: subclasses of `RuntimeException` (e.g. `NullPointerException`, `IllegalArgumentException`) and subclasses of `Error` (e.g. `OutOfMemoryError`). The compiler does **not** check these. The whole `throws`/catch-or-declare machinery applies **only to checked exceptions**. ## The catch-or-declare requirement For every checked exception that a piece of code *can* throw, the enclosing method must do one of two things, or the code will not compile: 1. **Catch it** — surround the risky call in a `try` block with a matching `catch`: ```java void run() { try { loadConfig(); } catch (IOException e) { // handle or recover } } ``` 2. **Declare it** — add the exception type to the method's own `throws` clause, passing the obligation to the caller: ```java void run() throws IOException { loadConfig(); } ``` This is sometimes called 'catch or specify'. The obligation cascades: if `run()` declares `IOException`, then *its* caller must again catch or declare. Eventually some method handles it or it reaches `main` and terminates the thread. ## Why unchecked exceptions are exempt Unchecked exceptions usually signal **programming bugs** (dereferencing null, bad array index) that could happen at almost any line. Forcing a declaration on every method would be noise. So `RuntimeException` and `Error` need not be declared or caught; you *may* still list a `RuntimeException` in `throws` purely as documentation, but it changes nothing the compiler enforces. ## What 'can be thrown' means A method 'can throw' a checked exception E if it contains a `throw` statement of type E (or a subtype), or calls another method that *declares* E. So declarations propagate transitively through the `throws` clauses you call. ## Multiple exceptions A `throws` clause can list several comma-separated types: `throws IOException, SQLException`. You may also declare a common supertype (e.g. `throws Exception`) to cover several at once, though that's coarse and hides detail from callers. ## Common mistakes the compiler catches - Calling a method that declares a checked exception without catching or declaring it → compile error: 'unreported exception ... must be caught or declared'. - Declaring a checked exception that the method body can never actually throw → for *checked* types this is a compile error in a `catch` clause (you can't catch an exception that's never thrown), but a redundant `throws` declaration of a never-thrown checked exception is allowed and harmless. ## Deriving the answer at any level Given all the above: the `throws` clause documents-and-enforces the contract for *recoverable, anticipated* failures; the compiler guarantees a caller is aware of them. Unchecked exceptions opt out because they model bugs and would otherwise pollute every signature.