How does Java handle exceptions? Provide an example of exception handling in Java.

In Java, exceptions are used to handle runtime errors and exceptional conditions that may occur during the execution of a program. Java provides a robust exception handling mechanism that allows developers to gracefully handle and recover from such errors. Here's an in-depth explanation of how Java handles exceptions and an example of exception handling:

1. Exception Hierarchy: Java has a built-in hierarchy of exception classes, with the base class being `java.lang.Throwable`. The hierarchy is divided into two main types of exceptions: checked exceptions and unchecked exceptions. Checked exceptions (e.g., `IOException`, `SQLException`) must be explicitly handled or declared, while unchecked exceptions (e.g., `NullPointerException`, `ArrayIndexOutOfBoundsException`) do not require explicit handling.
2. Try-Catch Block: Exception handling in Java involves the use of try-catch blocks. The code that may throw an exception is enclosed within a try block, and the possible exceptions are caught and handled in one or more catch blocks. A catch block specifies the type of exception it can handle, and if an exception of that type is thrown, the corresponding catch block is executed.
3. Exception Propagation: If an exception is not caught and handled within the current method, it is propagated up the call stack to the calling method. This propagation continues until an appropriate catch block is encountered or until the exception reaches the top-level method (such as the main method), where it may cause the program to terminate if not handled.
4. The finally Block: The `finally` block is an optional block that follows the try-catch block(s). It is used to specify code that should be executed regardless of whether an exception occurs or not. The finally block is commonly used for cleaning up resources (e.g., closing files, releasing database connections) and ensures that such cleanup operations are performed even if an exception is thrown.

Here's an example of exception handling in Java:

```
java`import java.io.FileReader;
import java.io.IOException;

public class FileReadExample {
public static void main(String[] args) {
FileReader fileReader = null;
try {
fileReader = new FileReader("input.txt");
// Code for reading and processing the file
} catch (IOException e) {
System.out.println("An error occurred while reading the file: " + e.getMessage());
} finally {
try {
if (fileReader != null) {
fileReader.close();
}
} catch (IOException e) {
System.out.println("An error occurred while closing the file: " + e.getMessage());
}
}
}
}`
```
In the above example, we are attempting to read a file named "input.txt" using a `FileReader` object. Since the `FileReader` constructor may throw an `IOException`, we enclose it within a try block. If an exception occurs, the catch block is executed, which prints an error message. Regardless of whether an exception occurs or not, the finally block is executed, ensuring that the file is properly closed.

Exception handling in Java allows developers to handle anticipated errors and take appropriate actions, such as providing error messages, logging, or gracefully recovering from exceptions. By using try-catch blocks and the exception hierarchy, Java enables robust error handling and promotes the creation of reliable and fault-tolerant software.