Exception Handling in Java

Exception handling in Java allows you to handle and manage exceptional conditions that may occur during the execution of a program. Exceptions represent abnormal conditions or errors that disrupt the normal flow of program execution. Java provides a robust exception handling mechanism to help developers identify, handle, and recover from these exceptions. Here are the key components and concepts related to exception handling in Java:

Exceptions: In Java, exceptions are represented by classes that extend the Throwable class or one of its subclasses. There are two types of exceptions: checked exceptions and unchecked exceptions. Checked exceptions are required to be declared or handled by the code, while unchecked exceptions (also known as runtime exceptions) do not require explicit handling.
try-catch-finally: The try-catch-finally block is used to handle exceptions in Java. The try block contains the code that may throw an exception. The catch block catches and handles the exception if it occurs. The finally block contains code that is always executed, regardless of whether an exception occurs or not. It is used for cleanup and resource release.

try {
    // Code that may throw an exception
} catch (ExceptionType1 e1) {
    // Exception handling for ExceptionType1
} catch (ExceptionType2 e2) {
    // Exception handling for ExceptionType2
} finally {
    // Code that is always executed
}

try {

// Code that may throw an exception

} catch (ExceptionType1 e1) {

// Exception handling for ExceptionType1

} catch (ExceptionType2 e2) {

// Exception handling for ExceptionType2

} finally {

// Code that is always executed

}

Throwing Exceptions: Exceptions can be thrown explicitly using the throw keyword. This allows you to create and throw custom exceptions or propagate exceptions to higher levels of the program for handling.

void divide(int dividend, int divisor) {
    if (divisor == 0) {
        throw new ArithmeticException("Divisor cannot be zero");
    }
    int result = dividend / divisor;
    System.out.println("Result: " + result);
}

void divide(int dividend, int divisor) {

if (divisor == 0) {

throw new ArithmeticException("Divisor cannot be zero");

}

int result = dividend / divisor;

System.out.println("Result: " + result);

}

Exception Handling Hierarchy: The Throwable class is the root of the exception hierarchy in Java. It has two main subclasses: Exception and Error. Exceptions are further divided into checked exceptions (subclasses of Exception except RuntimeException) and unchecked exceptions (RuntimeException and its subclasses).
Exception Propagation: If an exception is not caught and handled within a method, it is propagated up the call stack until it is caught and handled or until it reaches the top-level of the program, where it may terminate the program.
Custom Exceptions: Java allows you to create your own custom exception classes by extending the Exception class or one of its subclasses. Custom exceptions help you handle specific exceptional scenarios in your application.

class CustomException extends Exception {
    // Custom exception implementation
}

class CustomException extends Exception {

// Custom exception implementation

}

7. Exception Handling Best Practices: It is recommended to catch specific exceptions instead of using a generic catch block for better exception handling. Handle exceptions at an appropriate level in the program, log exception details for debugging, and provide meaningful error messages to users.

try {
    // Code that may throw IOException
} catch (IOException e) {
    // Exception handling for IOException
    logger.error("An IO error occurred: " + e.getMessage());
    displayErrorMessage("An error occurred. Please try again later.");
}

try {

// Code that may throw IOException

} catch (IOException e) {

// Exception handling for IOException

logger.error("An IO error occurred: " + e.getMessage());

displayErrorMessage("An error occurred. Please try again later.");

}

In Java, the exception hierarchy is structured as follows:

                           ┌───────────────────────────┐
                           │          Throwable        │
                           └───────────────────────────┘
                                        │
                      ┌─────────────────┴─────────────────┐
                      │                                   │
                ┌─────┴───────┐                  ┌────────┴────────┐
                │             │                  │                 │
        ┌──────────────┐ ┌───────────┐   ┌─────────┐    ┌─────────┐
        │    Error     │ │  Exception │   │  RuntimeException │
        └──────────────┘ └───────────┘   └─────────┘    └─────────┘

┌───────────────────────────┐

│ Throwable │

└───────────────────────────┘

│

┌─────────────────┴─────────────────┐

│ │

┌─────┴───────┐ ┌────────┴────────┐

│ │ │ │

┌──────────────┐ ┌───────────┐ ┌─────────┐ ┌─────────┐

│ Error │ │ Exception │ │ RuntimeException │

└──────────────┘ └───────────┘ └─────────┘ └─────────┘

Throwable: Throwable is the root class of the exception hierarchy. It is the superclass for all exceptions and errors in Java.
Error: Error represents exceptional conditions that are typically beyond the control of the application and usually indicate serious problems that should not be caught or handled by normal program logic. Examples include OutOfMemoryError and StackOverflowError. Errors are generally not recoverable.
Exception: Exception is a subclass of Throwable and represents exceptional conditions that can be caught and handled by the application. Exceptions are further divided into two main types:
- Checked Exceptions: Checked exceptions are exceptions that must be declared or handled by the code. They are checked at compile-time and ensure that the programmer is aware of the potential exceptional conditions that can occur. Examples include IOException and SQLException.
- Unchecked Exceptions (Runtime Exceptions): Unchecked exceptions are exceptions that do not need to be declared or handled explicitly. They are typically programming errors or unexpected conditions that occur at runtime. Examples include NullPointerException and ArrayIndexOutOfBoundsException.
RuntimeException: RuntimeException is a subclass of Exception and represents exceptions that occur due to programming errors or unexpected conditions at runtime. Since they are unchecked exceptions, they do not need to be declared or caught explicitly. Examples include NullPointerException and IllegalArgumentException.

The exception hierarchy in Java helps classify and organize exceptions based on their nature and intended use. It provides a structured approach to handling different types of exceptions in a program, allowing developers to catch and handle specific exceptions or propagate them to higher levels for appropriate handling.