How many Try Blocks are in Java? & Why is Catch block used?

Try Blocks are in Java

An anomalous circumstance or occurrence that interferes with the regular flow of instructions while a program is running is called an exception. These events can range from user input failures, files not being found, network connection issues, or even the Java Virtual Machine (JVM) running out of memory. The core of Java’s exception handling system revolves around five keywords: try, catch, throw, throws, and finally.

Try Block

You put exception-generating code in the try block to monitor for faults. An exception is “thrown” in this block and control is instantly moved to a catch block (if one exists and fits the exception type). A try block completes normally without an exception, bypassing its catch blocks.

Try blocks must be followed by catch or finally blocks. Nested try blocks are supported in Java. Inner try exceptions are transmitted to outer try catch blocks.

Syntax:

try {
    // Code that might throw an exception
}

Catch Block

Catch blocks immediately follow try blocks and handle specific exceptions thrown in try blocks. The catch block receives an exception object.

Many catch blocks can be attached to a try block to handle different exceptions. Inspection order is maintained for multiple catch blocks. First catch block whose exception type matches (or is a superclass of) thrown exception will be performed; subsequent catch blocks will be skipped. From specific to generic, catch blocks must be ordered. If a superclass exception like Exception or Throwable is caught before its subclasses, compilation issues may result from unreachable code.

In JDK 7, Java introduces multi-catch, which lets a catch block handle multiple error kinds. Using this reduces code duplication when handling similar exceptions.

Syntax:

catch (ExceptionType1 exOb1) {
    // Handle ExceptionType1
} catch (ExceptionType2 exOb2) {
    // Handle ExceptionType2
}
// Multi-catch syntax (JDK 7+):
catch (ExceptionTypeA | ExceptionTypeB e) {
    // Handle both ExceptionTypeA and ExceptionTypeB
}

Example of try-catch: Let’s consider an example where we try to perform a division that might result in an ArithmeticException (division by zero).

public class TryCatchDemo {
    public static void main(String[] args) {
        System.out.println("Start of program.");
        int numerator = 10;
        int denominator = 0; // This will cause an ArithmeticException
        try {
            System.out.println("Attempting division...");
            int result = numerator / denominator;
            System.out.println("Result: " + result); // This line won't be executed
        } catch (ArithmeticException e) {
            // Catch block for ArithmeticException
            System.out.println("Caught an exception: Cannot divide by zero!");
            // Optionally, print the exception details
            System.err.println("Exception details: " + e.getMessage()); // Returns a description of the exception 
        }
        System.out.println("End of program, continues after handling the exception.");
    }
}

Output:

Start of program.
Attempting division...
Caught an exception: Cannot divide by zero!
Exception details: / by zero
End of program, continues after handling the exception.

This output shows how the program gracefully resolves the division-by-zero error, outputs a user-friendly message, and continues execution.

Finally Block

The finally block contains code that is guaranteed to execute whenever control leaves a try block, regardless of whether an exception was thrown, caught, or even if the try or catch block contains a return statement.

Finally blocks are ideal for shutting open files, network connections, and other system resources to prevent resource leakage.

Syntax:

try {
    // Code that might throw an exception
} catch (ExceptionType1 exOb1) {
    // Handle ExceptionType1
} finally {
    // Code that always executes
}

Example of try-catch-finally: Let’s modify the previous example to include a finally block.

public class FinallyDemo {
    public static void main(String[] args) {
        System.out.println("Program starting.");
        int data = 0;
        try {
            System.out.println("Inside try block...");
            int result = 10 / data; // Will throw ArithmeticException if data is 0
            System.out.println("Result: " + result);
        } catch (ArithmeticException e) {
            System.out.println("Caught ArithmeticException: " + e.getMessage());
        } finally {
            // This block will always execute
            System.out.println("Finally block executed. Performing cleanup...");
            // Example cleanup: ensuring a resource is closed
        }
        System.out.println("Program finished.");
    }
}

Output (if data is 0):

Program starting.
Inside try block...
Caught ArithmeticException: / by zero
Finally block executed. Performing cleanup...
Program finished.

Output (if data is, for example, 2, so no exception occurs):

Program starting.
Inside try block...
Result: 5
Finally block executed. Performing cleanup...
Program finished.

Both instances show the finally block running, demonstrating its importance in important activities.

For managing resources like file streams, Java 7 introduced the try-with-resources statement, which automates the closing of resources, often replacing the explicit cleanup in a finally block for AutoCloseable resources.

Throws Clause

Method signatures include the throws clause to indicate that the method may throw checked exceptions it does not handle. This instructs method callers to catch or declare these exceptions in their throws clause, spreading responsibility up the call stack.

There are two main exception categories in Java:

• Checked Exceptions: These subclasses of Exception (not RuntimeException) indicate conditions a sensible program should foresee and recover from. The compiler requires methods to catch or throw checked exceptions. IOException, SQLException, ClassNotFoundException.
• Unchecked Exceptions: Use RuntimeException and Error subclasses for unchecked exceptions. They are usually programming problems that cannot be fixed or external difficulties like JVM failures. Examples include ArithmeticException, NullPointerException, and ArrayIndexOutOfBoundsException. Throwable is the superclass of all exception classes.

Syntax:

public void myMethod() throws IOException, InterruptedException {
    // Method body
}

Example of throws clause: Let’s consider a method that performs file operations, which often throw IOException (a checked exception).

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class ThrowsClauseDemo {
    // This method declares that it might throw an IOException
    public static void readFileContent(String filePath) throws IOException {
        System.out.println("Attempting to read file: " + filePath);
        BufferedReader reader = null; // Initialize to null
        try {
            reader = new BufferedReader(new FileReader(filePath));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } finally {
            // Cleanup: Close the reader in a finally block
            if (reader != null) {
                reader.close(); // This close() can also throw IOException
                System.out.println("Reader closed in finally block.");
            }
        }
        System.out.println("File reading complete for " + filePath);
    }
    public static void main(String[] args) {
        String existingFile = "example.txt"; // Assume this file exists and has content
        String nonExistentFile = "nonexistent.txt"; // This file does not exist
        // Call the method with a throws clause; main must handle it
        try {
            // To run this code, create a simple 'example.txt' file in the same directory
            // with some text content.
            readFileContent(existingFile);
            System.out.println("\n--- Trying to read a non-existent file ---\n");
            readFileContent(nonExistentFile); // This call will throw IOException
        } catch (IOException e) {
            System.out.println("Caught IOException in main: " + e.getMessage());
            e.printStackTrace(); // Print stack trace for debugging 
        }
        System.out.println("Main method finished.");
    }
}

Example example.txt content:

This is a line in example.txt.
Another line here.

Output (assuming example.txt exists):

Attempting to read file: example.txt
This is a line in example.txt.
Another line here.
Reader closed in finally block.
File reading complete for example.txt
--- Trying to read a non-existent file ---
Attempting to read file: nonexistent.txt
Caught IOException in main: nonexistent.txt (No such file or directory)
java.io.FileNotFoundException: nonexistent.txt (No such file or directory)
	at java.base/java.io.FileInputStream.open0(Native Method)
	at java.base/java.io.FileInputStream.<init>(FileInputStream.java:150)
	at java.base/java.io.FileReader.<init>(FileReader.java:60)
	at ThrowsClauseDemo.readFileContent(ThrowsClauseDemo.java:12)
	at ThrowsClauseDemo.main(ThrowsClauseDemo.java:27)
Main method finished.

In this example, readFileContent declares IOException with throws, shifting the responsibility of handling it to the main method. The main method then uses a try-catch block to handle IOException when attempting to read both files.