Try Catch and Finally Block in Java

Last Updated on December 8, 2023 by Ankit Kochar

In Java programming, error handling is crucial to ensure robust and reliable code. The try, catch, and finally blocks constitute an essential mechanism for managing exceptions and executing cleanup code. The try block allows you to encapsulate code that might throw exceptions, while the catch block enables the handling of these exceptions, providing a way to recover from errors gracefully. Additionally, the finally block allows the execution of essential cleanup code, irrespective of whether an exception is thrown or not, ensuring resources are properly managed.

In this article, we delve into the concepts of try, catch, and finally blocks in Java. We explore their syntax, functionality, and best practices, illustrating how they work together to handle exceptions, maintain code integrity, and manage resources efficiently. Understanding these blocks is fundamental to writing robust Java applications, ensuring proper error handling and resource cleanup in various scenarios.

What is an Exception?

Let us begin with an example. Let’s divide two numbers, x, and y. We know that if y is 0, the final value is not defined, therefore this is an exception. An exception in Java is an unexpected condition that can occur during code execution. It is the situation that disrupts the flow of code and causes the program to terminate. Exceptions can cause the program to crash if they are not handled properly. Returning to our previous example, thankfully, by default Java handles this exception with the ArithmeticException class.

How to Handle Exceptions?

Exception Handling is used to deal with exceptions. To manage exceptions, try-and-catch blocks can be used. The try block is used to specify the scope within which an exception can occur. If an exception occurs, the catch block handles it. In the following section, we will learn about the Try Catch block in java.

Try Block in Java

A try block in Java is used to specify a piece of code that may throw an exception. The code within the try block is checked for exceptions, and if an exception is thrown, it is captured by a corresponding catch block. The syntax for a try block in Java is as follows:

Syntax of Try Block in Java:

try 
{
    // Statements which might contain Exceptions
}

Catch Block in Java

A catch block in Java is used to handle an exception that was thrown within a corresponding try block. The catch block is only executed if an exception is thrown within the try block. A catch block in Java has the following syntax:

Syntax of Catch Block in Java:

catch(Exception e) 
{
    // Code to handle possible exceptions
}

The catch block defines the type of exception that can be handled. The catch block is invoked when an exception of the specified type is thrown within the corresponding try block.

To handle different types of exceptions, we can have multiple catch blocks following a try block. The order of the catch blocks is critical because the first catch block that matches the type of the thrown exception gets performed. If no matching catch block is detected, the exception is propagated up the call stack to the next available catch block, or to the default exception handler if none is found.

Some Examples of Try Catch Block in Java

Here are some examples of how to use the try catch block in Java:

Example 1 – Handling Arithmetic Exception

try {
    int result = 15 / 0; // throws ArithmeticException
} catch (ArithmeticException e) {
    System.out.println("An arithmetic exception occurred: " + e.getMessage());
}

Explanation: In this example, we have a try block that contains code that might throw an Arithmetic Exception. The code attempts to divide the integer 15 by 0, which is not allowed and will throw an Arithmetic Exception. The catch block specifies that it can handle this type of exception, and prints an error message to the console that includes the exception message obtained by calling the getMessage() method on the exception object.

Example – 2 Handling NullPointer Exception

try {
    String s = null;
    System.out.println(s.length()); // NullPointerException
} catch (NullPointerException e) {
    System.out.println("A null pointer exception occurred: " + e.getMessage());
}

Explanation: In this example, we have a try block that contains code that might throw a NullPointerException. The code attempts to get the length of a null string, which will throw a NullPointerException. The catch block clearly specifies that it can handle this type of exception, and prints an error message to the console that includes the exception message obtained by calling the getMessage() method on the exception object.

Nested Try Catch Block in Java

We can have a try catch block inside another try catch block in java. This is known as a "nested try catch block". The purpose of using nested try catch block is to handle exceptions in a more specific way.

Syntax of Nested Try Catch Block in Java

try {
    // code that may throw an exception
    try {
        // code that may throw an exception
    } catch (Exception e) {
        // code to handle the exception
    }
} catch (Exception e) {
    // code to handle the exception
}

In this syntax, we have an outer try block that contains an inner try block. The code inside the inner try block may possibly throw an exception, which is caught by the catch block inside the inner try block. If the inner try block does not catch the exception, it is propagated up to the catch block inside the outer try block.

The catch block inside the outer try block catches the exception if it is not caught by the inner catch block. This catch block handles the exception and provides appropriate error messages or corrective actions.

One important thing to note is that we can have multiple catch blocks for a single try block, and we can also have multiple nested try-catch blocks in a Java program. The goal of using nested try-catch blocks is to handle exceptions in a more specific and controlled way.

Example of Nested Try Catch in Java

Here’s an example of a nested try catch block in Java:

class PrepBytes{
    public static void main(String[] args) {
        try {
            try {
                int[] arr = new int[5];
                arr[7] = 10; // This will throw an ArrayIndexOutOfBoundsException
            } catch (ArrayIndexOutOfBoundsException e) {
                System.out.println("An array index out of bounds exception occurred: " + e.getMessage());
            }
            
            int a = 10 / 0; // This will throw an ArithmeticException
        } catch (ArithmeticException e) {
            System.out.println("An arithmetic exception occurred: " + e.getMessage());
        }
    }
}

Output:

An array index out of bounds exception occurred: Index 7 out of bounds for length 5
An arithmetic exception occurred: / by zero

Finally Block in Java

The finally block in Java is used to define a block of code that will be executed regardless of whether an exception is thrown or not. The finally block is optional, but it is often used in combination with a try-catch block to ensure that certain code is always executed, even if an exception is thrown.

Syntax of Finally Block in Java

try {
    // code that might throw an exception
} catch (ExceptionType1 e) {
    // handle ExceptionType1
} catch (ExceptionType2 e) {
    // handle ExceptionType2
} finally {
    // code that is always executed, regardless of whether an exception is thrown or not
}

In the above syntax, we can see that the finally block is placed after all the catch blocks. The code in the finally block will always be executed, whether or not an exception is thrown, and whether or not the catch block(s) execute.

Some important points to keep in mind about the finally block:

• The finally block is always executed, even if there is no matching catch block.
• If an exception is thrown and caught, the finally block is executed after the catch block.
• If there is a return statement in the try or catch block, the finally block is still executed before the method returns.
• If there is an unhandled exception in the try block, the finally block is still executed before the program terminates.

The finally block is typically used to close resources such as files or database connections that were opened in the try block. By doing so, we can ensure that these resources are always properly closed, regardless of whether an exception is thrown or not.

Example of Finally Block in Java

Here’s an example of how to use the finally block in Java:

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

class PrepBytes{
    public static void main(String[] args) {
        Scanner scanner = null;
        try {
            scanner = new Scanner(new File("input.txt"));
            while (scanner.hasNext()) {
                System.out.println(scanner.nextLine());
            }
        } catch (FileNotFoundException e) {
            System.out.println("File not found");
        } finally {
            if (scanner != null) {
                scanner.close();
            }
            System.out.println("Program completed");
        }
    }
}

In this example, we’re reading lines from a file named input.txt. We use a try-catch block to handle the case where the file isn’t found. In the finally block, we close the Scanner object whether or not an exception is thrown. We also print a message indicating that the program has completed. This ensures that the Scanner object is properly closed and any resources it was using are released, even if an exception is thrown.

Conclusion
The try, catch, and finally blocks in Java are pivotal constructs for managing exceptions and resources within code. The try block encapsulates code where exceptions may occur, while the catch block handles these exceptions, providing mechanisms for error recovery. Moreover, the finally block ensures essential cleanup tasks are executed, guaranteeing proper resource management, regardless of whether an exception occurs.

By mastering the usage of try, catch, and finally, Java developers can create more resilient applications, handle exceptions effectively, and maintain clean and efficient resource management practices. This leads to code that is more reliable, easier to maintain, and less prone to unexpected failures.

FAQs Related to Try Catch Finally in Java

Here are some frequently asked questions about try-catch-finally blocks in Java:

Q1: What is the purpose of the try block in Java?
The try block is used to encapsulate a block of code where exceptions might occur. It allows developers to write code that may throw exceptions, and if an exception occurs within the try block, it’s caught by the corresponding catch block.

Q2: When is the catch block executed in Java?
The catch block is executed when an exception of the specified type or its subclass is thrown within the associated try block. It allows for handling and responding to exceptions, providing a way to recover from errors.

Q3: What is the purpose of the finally block in Java?
The finally block is used to define code that needs to be executed whether an exception occurs or not. It ensures that essential cleanup tasks, such as releasing resources (closing files, database connections, etc.), are performed, promoting proper resource management.

Q4: Can finally block be used without a try block in Java?
No, the finally block must be associated with a try block. It follows the try and catch blocks and ensures that the defined cleanup code is executed, even if no exceptions were thrown in the try block.

Q5: What happens if an exception is thrown inside the finally block?
If an exception is thrown inside the finally block, it replaces any exception that was thrown in the try or catch block. This means that the exception that was thrown in the try or catch block is lost and only the exception thrown in the finally block is propagated up the call stack.

Q6: Can we have multiple catch blocks for the same exception in Java?
No, we cannot have multiple catch blocks for the same exception in Java. However, we can catch multiple types of exceptions in the same catch block by separating them with a vertical bar (|).