17.8. Exception Handling and the Exception Hierarchy in Java: Catching Multiple Exceptions

17.8 Exception Handling and the Exception Hierarchy in Java

Exception handling is a fundamental aspect in Java programming, as it allows programs to deal with abnormal situations in a controlled manner. An exception in Java is an event that occurs during the execution of a program and that interrupts the normal flow of instructions. When an exception is thrown, the program flow is transferred to a special code block called "catch", which is designed to handle that specific exception.

Exception Hierarchy in Java

Java uses a hierarchy of classes to define exceptions, all derived from the base class Throwable. The hierarchy is divided into two main branches: Error and Exception. Errors are serious conditions that an application should not normally attempt to catch, such as Java Virtual Machine (JVM) problems. Exceptions are conditions that an application can and should attempt to catch.

Exceptions in Java are categorized into two main categories:

• Checked Exceptions: These are exceptions that must be handled or declared in the method signature. These exceptions are checked at compile time.
• Unchecked Exceptions: These are exceptions that do not need to be explicitly handled or declared. They include subclasses of RuntimeException and are checked at run time.

It's important to understand this hierarchy to know how to catch and handle different types of exceptions effectively.

Catching Multiple Exceptions

In Java, it is possible to catch multiple exceptions in a single catch block using the pipe (|) operator. This can simplify code and reduce redundancy when different exceptions are handled in a similar way.

try {
    // Code that can throw exceptions
} catch (IOException | SQLException ex) {
    // Handling for IOException and SQLException
    System.out.println("Error accessing external resource: " + ex.getMessage());
}

When you catch multiple exceptions in this way, the exception variable (ex in the example above) is implicitly final and cannot be assigned another value within the catch block .

Good Practices in Exception Handling

When handling exceptions, it is important to follow some good practices:

• Only handle exceptions that you can handle: Do not catch generic exceptions like Exception or Throwable unless you can adequately handle all possible exceptions.
• Avoid swallowing exceptions: Do not leave catch blocks empty or with just one comment. This can make debugging very difficult as you lose track of what caused the problem.
• Use custom exceptions: Create your own exception classes if Java's standard exceptions do not adequately describe the problem you are trying to represent.
• Document exceptions: Use Javadoc to document the exceptions that your method can throw, which is especially important for checked exceptions.
• Consider using finally blocks: They run regardless of whether an exception is thrown or not, making them a suitable place to free up resources, such as closing network connections. network or files.

Example of Exception Handling

Here is a more detailed example of how to handle exceptions in Java:

public class ExampleExcecoes {
    public static void main(String[] args) {
        try {
            // Code that can throw exceptions
            int result = division(10, 0);
            System.out.println("Result: " + result);
        } catch (ArithmeticException ex) {
            // Specific handling for ArithmeticException
            System.out.println("Arithmetic error: " + ex.getMessage());
        } catch (NullPointerException ex) {
            // Specific handling for NullPointerException
            System.out.println("Null reference: " + ex.getMessage());
        } catch (Exception ex) {
            // Handling other unexpected exceptions
            System.out.println("Unexpected exception: " + ex.getMessage());
        } finally {
            // Code executed after try/catch blocks
            System.out.println("Block finally executed.");
        }
    }

    public static int division(int numerator, int denominator) throws ArithmeticException {
        return numerator / denominator;
    }
}

In this example, the division method may throw an ArithmeticException if the denominator is zero. The try block catches this exception and also two other possible exceptionsexceptions, treating them in a specific way. The finally block is executed at the end, regardless of whether an exception was thrown or not.

Conclusion

Exception handling is a critical part of Java programming. Understanding the exception hierarchy and knowing how to catch and handle multiple exceptions can help you create more robust and reliable programs. Following best practices and using the correct syntax is essential for writing code that is easy to maintain and debug.

In our complete Java course, you will learn in detail about each type of exception, how to create your own custom exceptions, and how to apply exception handling best practices to your projects. This knowledge is fundamental to becoming a proficient Java developer prepared to face the challenges of software development in the real world.