Java Errors vs. Exceptions: Handling the Unexpected

1. The Throwable Hierarchy

In Java, every error and exception is a subclass of the java.lang.Throwable class. This hierarchy is split into two main branches:

2. Types of Exceptions

Exceptions are further divided into two categories based on when the compiler notices them:

A. Checked Exceptions (Compile-time)

The compiler forces you to handle these. If you don't handle them using a try-catch or the throws keyword, the code won't even compile. They usually occur due to external factors like files or databases.

• IOException
• SQLException
• ClassNotFoundException

B. Unchecked Exceptions (Runtime)

These occur during the execution of the program. They are usually the result of bad programming logic. The compiler doesn't force you to check these, but they will crash your app if they happen.

• ArithmeticException (e.g., dividing by zero)
• NullPointerException (accessing a null object)
• ArrayIndexOutOfBoundsException

3. The Handling Mechanics: Try, Catch, Finally

To prevent your program from stopping abruptly, Java provides a structured way to handle exceptions.

• try: The block of code where you expect an exception might occur.
• catch: The block that handles the specific exception if it occurs.
• finally: The block that always executes, whether an exception happened or not. Use this to close files or database connections.
• throw: Used to manually throw an exception.
• throws: Used in a method signature to warn that this method might throw an exception.

4. Mastery Code Example: Robust Division

This example shows how to catch a specific exception and use the finally block for cleanup.

5. Custom Exceptions

Sometimes, Java’s built-in exceptions aren't enough. You can create your own by extending the Exception class. This is common in business logic, like throwing an InsufficientFundsException in a banking app.

6. Common Errors (The Unstoppables)

While you catch exceptions, you usually just watch Errors happen. Here are the big ones:

• StackOverflowError: Happens when a method calls itself recursively too many times.
• OutOfMemoryError: Happens when the JVM runs out of RAM and cannot allocate more objects.
• NoClassDefFoundError: Happens when the JVM tries to load a class that was present during compile-time but is missing at runtime.

7. Best Practices for Exception Handling

1. Be Specific: Catch FileNotFoundException instead of a generic Exception.
2. Don't Swallow Exceptions: Never leave a catch block empty. At least log the error so you know it happened.
3. Use Finally: Always use finally (or try-with-resources) to close connections.
4. Don't Over-catch: Only catch exceptions you can actually handle. Otherwise, let them propagate.

8. Interview Preparation: Q&A Mastery

Q: Can we have a try block without a catch block?
A: Yes, but only if you have a finally block. A try-finally is valid for cleanup, but it won't handle the exception.

Q: What is the difference between throw and throws?
A: throw is used to trigger an exception manually. throws is used in method signatures to declare which exceptions might be thrown.

Q: What is "Try-with-resources"?
A: Introduced in Java 7, it's a way to automatically close resources (like files) without needing a manual finally block.