Java Exception Handling

Exception Handling Overview

• This module is about the creation and handling of exceptions in Java.
• Objectives include using exception handling in applications and comparing programs with and without exception handling.

Exceptions in Java Programming

• Exceptions can occur when a Java program uses classes/methods from existing Java libraries/packages due to code reuse.
• A NumberFormatException is thrown if the parseInt method of the Integer class receives a string that cannot be parsed into an integer or if the parseDouble method of the Double class cant parse a string into a floating point #.
• A StringIndexOutOfBoundsException is thrown during the execution of the substring method of the String class if the index is greater than or equal to the string's length.
• An ArrayIndexOutOfBoundsException is thrown if an array index is out of the valid range, which is from 0 to (lengthOfArray-1).
• Java division operator throws an ArithmeticException if dividing by zero (0).
• An exception is an object describing an unusual or erroneous situation that can be thrown, caught, and handled.
• A program contains normal and exceptional execution flows.
• An error is represented as an object in Java, it usually suggests an unrecoverable situation and should not be caught.

Exception Handling

• Java has a predefined set of exceptions and errors that can occur during execution.
• A program can handle an exception by:
  • Ignoring it (only possible with "unchecked" exceptions, leading to abnormal termination)
  • Handling it where it occurs
  • Handling it in another part of the program
• The handling approach is an important design decision.
• The try block executes the code that might throw an exception
• catch clauses follow a try block.
• catch clause has an exception type and is called an exception handler.
• Processing continues at the first catch clause that matches the exception type when an exception occurs.
• Catch blocks can handle multiple exception types in Java 7 and later, simplifying cases with similar exception handling code.
• A try statement can have a finally clause after the catch clauses.
• The code in the finally clause is always executed
• In the absence of exceptions, the finally clause executes after the try block.
• If an exception is generated, the finally clause executes after the appropriate catch clause completes.

The try-with-resources

• Java 7 supports try-with-resources, it ensures resources declared in the try block are closed after execution.
• Previously, the finally block was used to close resources opened in the try block.
• try-with-resources offers a more efficient coding method

Exception Class Hierarchy

• Exception classes are related by inheritance and form a hierarchy.
• All error and exception classes inherit from the Throwable class.

Checked vs Unchecked Exceptions

• Exceptions can be classified:
  • Checked:
    • Exceptions that must be caught by a method using a try statement.
    • They must be listed in the throws clause of any method that might throw or propagate it
    • A throws clause is appended to the method header
    • The compiler will issue an error if a checked exception is not caught or asserted in a throws clause
  • Unchecked:
    • Exceptions do not require explicit handling.
    • The only unchecked exceptions in Java are objects of type RuntimeException or any of its descendants
• Errors should not be caught or require a throws clause

User-Defined Exceptions

• User-defined exceptions can be created by extending predefined Exception classes in Java.
• The type (checked or unchecked) depends on the extended class.