Exception Handling (try-catch-finally)

Exception handling in programming is a mechanism to deal with unexpected or erroneous situations that may occur during the execution of a program. Java provides a robust exception handling mechanism through the `try`, `catch`, and `finally` blocks.

`try`, `catch`, `finally` Blocks

- try: The `try` block is used to enclose the code that might throw an exception. It is followed by one or more `catch` blocks or a `finally` block (or both).  

- catch: The `catch` block is used to handle exceptions that are thrown within the corresponding `try` block. It specifies the type of exception it can handle, denoted by the exception class. You can have multiple `catch` blocks to handle different types of exceptions.

- finally: The `finally` block is optional and is used to execute code regardless of whether an exception is thrown or not. It's often used for cleanup tasks such as closing resources (like files or database connections) that were opened in the `try` block.

Syntax

try {
    // Code that may throw an exception
} catch (ExceptionType1 e1) {
    // Code to handle exception of type ExceptionType1
} catch (ExceptionType2 e2) {
    // Code to handle exception of type ExceptionType2
} finally {
    // Code that always executes, regardless of whether an exception was thrown or not
}

Example

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = null;
        try {
            // Opening a file
            File file = new File("example.txt");
            scanner = new Scanner(file);
            
            // Reading contents of the file
            while (scanner.hasNextLine()) {
                System.out.println(scanner.nextLine());
            }
        } catch (FileNotFoundException e) {
            // Handling FileNotFoundException
            System.out.println("File not found: " + e.getMessage());
        } finally {
            // Closing the scanner (cleanup)
            if (scanner != null) {
                scanner.close();
            }
        }
    }
}

In this example:

- The `try` block contains code that tries to open a file (`example.txt`) and read its contents using a `Scanner`.

- If the file is not found (`FileNotFoundException`), the `catch` block handles the exception by printing an error message.

- The `finally` block ensures that the `Scanner` is closed, whether an exception occurred or not.

Exception handling is crucial for writing robust and reliable code, especially when dealing with I/O operations, network communications, or other potentially error-prone activities. It helps in gracefully handling errors and preventing abrupt termination of the program.