Exception Handling

A checked exception must be either caught or declared with throws, and the compiler enforces this. An unchecked exception (RuntimeException or Error and their subclasses) is not enforced by the compiler.

Common ones: NullPointerException (used a null), IllegalArgumentException (bad argument passed in), IllegalStateException (called at the wrong time), ClassCastException (bad cast), ArrayIndexOutOfBoundsException (index past the array end), and NumberFormatException (parsed text that isn't a number).

Throwable is the root of everything you can throw or catch. It splits into Error (serious system problems you shouldn't catch, like running out of memory) and Exception (problems your program can handle, like a missing file or bad input).

Checked exceptions must be handled or declared with throws, or your code won't compile. Unchecked ones (RuntimeException and Error) don't force you to do anything. The compiler enforces checked exceptions; it ignores unchecked ones.

Look at its ancestry. If it is a subclass of RuntimeException or of Error, it is unchecked. If it is a subclass of Exception but not of RuntimeException, it is checked.

A finally block holds cleanup code that runs after the try (and any matching catch), whether or not an exception was thrown. You use it to release resources like files or connections.

Multi-catch lets one catch block handle several exception types. You list the types separated by a vertical bar (|), like catch (IOException | SQLException e), and write a single shared body.

You put risky code in a try block. If it throws, Java checks each catch block top to bottom and runs the first one whose declared type matches the thrown exception. If none match, the exception keeps propagating up.

It is a try block that declares resources (like a file or connection) in parentheses. Java automatically closes them when the block ends, even if an error happens, so you do not need a finally block to close them yourself.

Catch the more specific type first. If you put the supertype (like Exception) before a subtype (like IOException), the subtype's catch can never be reached, so Java refuses to compile it as an unreachable catch.

If a method does not catch an exception, Java stops running that method and hands the exception to the method that called it. This repeats up the call chain until some method catches it, or the program prints the error and stops.

Use throw e; to rethrow the exact exception you caught. Because it is the same object, its stack trace stays intact. If you wrap it in a new exception, pass the original as the cause so the trace is not lost.

The throws clause lists exceptions a method might throw. For checked exceptions Java forces you to either handle them with try/catch or declare them with throws, so callers know to deal with them.

throw raises an exception. After the keyword you put an object that is a Throwable (an Exception or Error). Once thrown, the current method stops normal execution and control jumps to a matching catch block, or out of the method if none catches it.

throw is a statement that raises one exception right now inside a method body. throws is part of a method's signature that declares which checked exceptions the method might pass to its caller. One acts; the other warns.

Exception chaining means attaching the original exception (the cause) to a new exception when you wrap it. You pass the original to the new exception's constructor so you don't lose information about what really went wrong.

A checked exception (extends Exception) must be declared or caught — the compiler forces it. An unchecked exception (extends RuntimeException) does not. Use checked for problems the caller can recover from, unchecked for programming bugs.

Extend Exception for a checked exception that callers must handle or declare; extend RuntimeException for an unchecked one that needs no try/catch or throws clause. Use checked for recoverable errors, unchecked for programming bugs.

Provide four constructors mirroring Throwable: no-arg, message-only (String), message-and-cause (String, Throwable), and cause-only (Throwable). Each just calls the matching super(...) so the message and cause are stored correctly.

If the caller can do something useful to recover, make it checked so they're forced to handle it. If the failure is a bug the caller should have prevented, or can't recover from, make it unchecked.

An empty catch block catches an exception but does nothing with it, so the error silently disappears. The program keeps running as if nothing went wrong, hiding real failures and making bugs very hard to find.

Fail-fast means you check for invalid inputs or bad state right away and stop immediately by throwing an error, instead of letting the program keep running with bad data and breaking later in a confusing place.

try-with-resources declares a resource in the try header and Java automatically closes it when the block ends, even on an exception. It is preferred because manual finally blocks are easy to get wrong and can leak resources.

It throws a new exception but never passes the original (e) as the cause, so the real error and its stack trace are lost. Fix it by chaining: throw new ServiceException("...", e).

Catching a specific type means you only handle the errors you expect and know how to deal with. A broad catch grabs everything — including bugs and errors you never anticipated — and treats them all the same, which hides real problems.