Version Enhancements in Exception Handling introduced in Java SE 7

Java SE 7 introduced major improvements to how errors are handled, bringing in features that make error management in Java applications simpler and more efficient. These changes aimed to improve code readability, decrease repetitive code (boilerplate), and enhance the overall experience for developers.

The evolution of exception handling in Java SE 7 highlights key features such as the try-with-resources statement, multi-catch, and improved Exception handling syntax. Understanding these advancements is crucial for Java developers leveraging the latest capabilities for more robust and efficient error handling in their Code.

Try with resources.

In Java, the introduction of Automatic Resource Management (ARM) through the try-with-resources statement, starting from Java 7, represents a significant advancement. the feature is engineered to bolster code robustness and promote code conciseness.

The try-with-resources statement extends the standard try statement, allowing the declaration of one or more resources within its scope. The key benefit of this construct lies in its automatic resource management functionality. It ensures that each declared resource is promptly closed after the statement's execution.

Algorithm:

Step 1: Initialize a BufferedReader named inputReader for user input and a String variable fileLocation for the file path.

Step 2: Use inputReader to read the file path entered by the user.

Step 3: Declare a String variable fileContent for each line from the file.

Step 4: Open a BufferedReader for file reading using the entered file path (FileReader for the file).

Step 5: Use a while loop to read each line from the file until the end of the file is reached.

Step 6: Use a try-catch block to catch any IOException during file reading or user input.

Step 7: Print the stack trace if an IOException is caught.

Step 8: Use a finally block to ensure that resources are closed, checking if inputReader is not null before closing it.

Step 9: Print the stack trace if an IOException occurs during resource closure.

Implementation:

Filename: CustomFileReader.java

import java.io.*;
public class CustomFileReader {
    public static void main(String arguments[]) {
        // BufferedReader for user input
        BufferedReader inputReader = null;

        // Variable to store the file path entered by the user
        String fileLocation = " ";

        System.out.println("Enter the file path:");

        // Initializing BufferedReader for user input
        inputReader = new BufferedReader(new InputStreamReader(System.in));

        try {
            // Reading the file path provided by the user
            fileLocation = inputReader.readLine();

            // Variable to store each line from the file
            String fileContent;

            // Accessing the file resource
            inputReader = new BufferedReader(new FileReader(fileLocation));

            // Reading and printing each line from the file
            while ((fileContent = inputReader.readLine()) != null) {
                System.out.println("Content: " + fileContent);
            }
        } catch (IOException ioException) {
            // Handling IOException
            ioException.printStackTrace();
        }

        // Prior to Java 7, manual resource closure was necessary
        // With try-with-resources in Java 7, this part is optional
        finally {
            try {
                if (inputReader != null)
                    // Closing the resource within the 'finally' block
                    inputReader.close();
            } catch (IOException ex) {
                // Handling IOException during resource closure
                ex.printStackTrace();
            }
        }
    }
}

Output:

Enter the file path:
D:\javatpoint\CustomFileReader.txt
Content: Hello World!

Advantages of try with recourses:

1. Automatic Resource Closure:

Resources opened in the try block are automatically closed when the block concludes, either normally or due to an exception.
Eliminates the need for explicit resource closure, reducing programming complexity.

2. Declaring Multiple Resources:

Multiple resources can be declared and utilized within the try-with-resources statement.
Resources are listed and separated by semicolons in parentheses.

try (Resource1; Resource2; Resource3) {
    // Code block for resource utilization
    // ...
}

3. AutoCloseable Resources:

Resources must implement the AutoCloseable interface, either directly or indirectly.
Common resources related to databases, networks, and file I/O inherently implement AutoCloseable.

4. Implicit Finality of Resource Variables:

Resource reference variables declared within the try-with-resources statement are implicitly considered final.
Attempts to reassign values to these variables within the try block result in a compile-time error.

try (BufferedReader br = new BufferedReader(new FileReader("abc.txt"))) { 
    // Reassignment would trigger a compile-time error
    // br = new BufferedReader(new FileReader("abc.txt"));
}

Version Compatibility (Java 7 Onward):

Before Java 7, the try statement required either a catch or finally block.
In Java 7 and later versions, having a try-with-resources statement without a catch or finally block is valid.

try (Resource) {
    // Code block
    // ...
}  // Valid from Java 7 onwards

Multiple catch blocks:

The "Multi-catch" block in Java 7 addresses the challenge of handling multiple exceptions more concisely and efficiently. Before Java 7, developers had to use multiple catch blocks to handle different types of exceptions individually. The approach could lead to repetitive Code and reduced code readability.

In Java, the try-with-resources statement supports multiple catch blocks to handle different exceptions.

Syntax:

try (ResourceType1 resource1 = initializeResource1; ResourceType2 resource2 = initializeResource2; /* ... */) {
    // Code block where resources are utilized
    // ...
} catch (ExceptionType1 e1) {
    // Exception handling for ExceptionType1
    // ...
} catch (ExceptionType2 e2) {
    // Exception handling for ExceptionType2
    // ...
} catch (CommonExceptionType commonException) {
    // Common Exception handling for other types of exceptions
    // ...
} finally {
    //Code in the finally block (optional)
    // The block is executed whether an exception occurs or not
}

With the Multi-catch block, a single catch block can handle multiple exception types more compactly.

try {
    //Code that may throw exceptions
} catch (ExceptionType1 | ExceptionType2 | ... | ExceptionTypeN e) {
    // Common Exception handling logic for multiple exception types
    // Access the caught Exception using the variable 'e'
}

Algorithm:

Step 1: Create a Scanner object named scanner for user input.

Step 2: Use a try block to encapsulate the Code that might throw exceptions.

Step 3: Inside the try block: Attempt to parse user input as an integer using Integer.parseInt(scanner.nextLine()).

Step 4: Check if the entered number is a factor of 99. If true, print a message indicating that the entered number is a factor of 99.

Step 5: Use a catch block to handle exceptions (NumberFormatException or ArithmeticException).

Catch both exceptions using a multi-catch statement (|).
Print a message indicating an exception, along with the Exception, was encountered.

Implementation:

Filename: MultiCatchExample.java

import java.util.Scanner;

public class MultiCatchExample {

    public static void main(String args[]) {
        // Create a Scanner object for user input
        Scanner scanner = new Scanner(System.in);

        try {
            // Attempt to parse user input as an integer
            int userInput = Integer.parseInt(scanner.nextLine());

            // Check if the entered number is a factor of 99
            if (99 % userInput == 0) {
                System.out.println(userInput + " is a factor of 99");
            }

        } catch (NumberFormatException | ArithmeticException ex) {
            // Handle NumberFormatException or ArithmeticException using a single catch block
            System.out.println("Exception encountered: " + ex);

        }
    }
}

Output 1:

Javatpoint
Exception encountered: java.lang.NumberFormatException: For input string: "Javatpoint"

Output 2:

0
Exception encountered: java.lang.ArithmeticException: / by zero

Advantages of Multiple catch block:

1. When dealing with exceptions that belong to the same class hierarchy, it is advisable to catch the base exception type. However, separate catch blocks are required if the goal is to handle each exception type individually.

2. While a single catch block can handle more than one type of Exception using the multi-catch feature, it's important to note that catching both a base (ancestor) class and its subclass (descendant) exceptions in the same statement is not allowed in Java. For example:

// Not Valid as Exception is an ancestor of 
// NumberFormatException
catch(NumberFormatException | Exception ex)

3. When using the multi-catch feature, the vertical bar (|) symbol must separate all the exception types.

4. Explicitly catching each exception type enhances code clarity, making it easier for developers to understand and maintain the error-handling logic.

Next TopicFind all Palindromic Sub-Strings of a given String in Java

← prev next →