Multiple Exceptions

Lecture 90:-  Multiple Exceptions

In Java, you can use multiple catch blocks to handle different types of exceptions that may be thrown within a try block. This allows you to handle various exceptional situations differently based on the specific exception type. Using multiple catch blocks can make your exception handling more precise and provide targeted error handling for different scenarios.

The syntax for handling multiple exceptions using multiple catch blocks is as follows:

javaCopy code
try {
    // Code that may throw exceptions
} catch (ExceptionType1 e1) {
    // Code to handle ExceptionType1
} catch (ExceptionType2 e2) {
    // Code to handle ExceptionType2
} catch (ExceptionType3 e3) {
    // Code to handle ExceptionType3
} // Add more catch blocks as needed for different exception types

Here's an example that demonstrates how to use multiple catch blocks:

javaCopy code
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class MultipleExceptionsExample {
    public static void main(String[] args) {
        try {
            readAndProcessFile("data.txt");
        } catch (FileNotFoundException e) {
            System.out.println("File not found: " + e.getMessage());
        } catch (IOException e) {
            System.out.println("Error reading file: " + e.getMessage());
        }
    }

    public static void readAndProcessFile(String fileName) throws IOException {
        BufferedReader reader = null;
        try {
            reader = new BufferedReader(new FileReader(fileName));
            // Code to read and process data from the file
        } finally {
            if (reader != null) {
                reader.close();
            }
        }
    }
}

In this example, the readAndProcessFile method attempts to read data from a file. It uses a BufferedReader to read the file's contents. Since the BufferedReader constructor and the close method may throw IOException, we catch that exception using a catch block for IOException.

Additionally, the readAndProcessFile method declares that it throws IOException, which means that any checked exceptions thrown by the method will be propagated to its caller. In the main method, we catch the IOException using a catch block specifically for IOException.

If an exception is thrown within the try block, Java will attempt to match the thrown exception with the catch blocks in order. If a matching catch block is found, the corresponding code will be executed. If no matching catch block is found, the program will terminate with an uncaught exception.

By using multiple catch blocks, you can provide targeted and specific error handling for different exceptional situations, leading to more robust and reliable code.

Disclaimer:-

Under Section 107 of the copyright act 1976, allowance is made for fair use for purposes such as criticism, comment, news reporting, scholarship, and research. Fair use is a use permitted by copyright statute that might otherwise be infringing. Non-profit, educational, or personal use tips the balance in favor of fair use.