Java Part 10: Exception Handling in Java

Java Part 10: Exception Handling in Java

Please Subscribe Youtube| Like Facebook | Follow Twitter

Exception Handling in Java

In this article, we will provide a detailed overview of Exception Handling In Java and provide examples of how they are used in Java programming.

Exception handling is a fundamental aspect of Java programming that allows developers to handle and manage errors or exceptional conditions that may occur during program execution. By implementing effective exception handling techniques, you can ensure the stability and reliability of your Java applications. In this detailed guide, we will explore the concepts of exception handling in Java, including checked and unchecked exceptions, the usage of the finally block, and provide practical examples to illustrate the concepts in action.

Exception Types in Java

In Java, exceptions are categorized into two types: checked exceptions and unchecked exceptions. Understanding these types is crucial for proper exception handling.

Checked Exceptions

Checked exceptions are exceptions that must be declared in a method’s signature using the throws keyword or handled explicitly using try-catch blocks. These exceptions are typically anticipated and recoverable. Examples of checked exceptions include IOException, SQLException, and ClassNotFoundException.

Unchecked Exceptions

Unchecked exceptions, also known as runtime exceptions, do not require explicit handling or declaration. They are usually caused by programming errors or unforeseen circumstances. Examples of unchecked exceptions include NullPointerException, ArrayIndexOutOfBoundsException, and IllegalArgumentException.

Best Practices for Exception Handling

Catch Specific Exceptions:
Catch specific exception types instead of using generic exception handlers. This allows you to handle different exceptions differently based on their specific circumstances and improves code readability.

Use the Finally Block:
The finally block is used to define code that should always be executed, regardless of whether an exception occurs or not. It is commonly used for releasing resources or cleaning up operations. Ensure that you close files, release database connections, or perform necessary cleanup tasks within the finally block.

Provide Meaningful Error Messages:
When throwing or catching exceptions, provide descriptive error messages. Meaningful error messages help in identifying the cause of the exception and aid in troubleshooting and debugging. Include relevant information such as the context, inputs, and expected behavior.

Log Exceptions:
Implement logging mechanisms to capture and log exceptions along with additional contextual information. Logging assists in error tracking, identifying patterns, and providing valuable insights for debugging and maintenance.

Graceful Error Recovery:
Design your code to handle exceptions gracefully whenever possible. Implement error recovery mechanisms to handle exceptions and provide alternative paths or fallback strategies. Graceful error recovery improves the resilience of your application and enhances the user experience.

Exception Handling Syntax in Java

In Java, exception handling syntax consists of the following components:

try: The try block contains the code that may throw an exception.

catch: The catch block catches and handles specific exceptions. It follows the try block and specifies the exception type to catch.

finally: The optional finally block follows the catch block and contains code that is always executed, regardless of whether an exception occurs.

throw: The throw statement is used to explicitly throw an exception.

Here’s a concise example showcasing the syntax:

try {
    // Code that may throw an exception
} catch (ExceptionType exception) {
    // Exception handling code
} finally {
    // Optional cleanup code

In this example, ExceptionType represents the type of exception to catch. Multiple catch blocks can be used to handle different exception types. The finally block is used for cleanup operations. The throw statement is used to throw a specific exception.

Exception Handling Examples

Example 1: Handling Checked Exceptions

import java.util.Scanner;

public class FileProcessor {
    public static void main(String[] args) {
        try {
            File file = new File("example.txt");
            Scanner scanner = new Scanner(file);
            while (scanner.hasNextLine()) {
        } catch (FileNotFoundException e) {
            System.err.println("Error: File not found.");


Error: File not found.

If the file “example.txt” does not exist or is not accessible, a FileNotFoundException will be thrown. In such cases, the code will catch the exception and print the error message “Error: File not found.” to the error stream using System.err.println().

Example 2: Using the Finally Block

public class FinallyBlockExample {
    public static void main(String[] args) {
        try {
            // Perform some operations that may throw exceptions
            int result = divideNumbers(10, 0);
            System.out.println("Result: " + result);
        } catch (ArithmeticException e) {
            System.err.println("Error: Division by zero.");
        } finally {
            // Code that will always be executed
            System.out.println("Finally block executed.");

    public static int divideNumbers(int dividend, int divisor) {
        return dividend / divisor;


Error: Division by zero.
Finally block executed.

The provided code demonstrates the usage of the finally block in Java. It performs the following steps:

The code defines a class named FinallyBlockExample.

Inside the main method, the code attempts to perform some operations that may throw exceptions. It calls the divideNumbers method with the arguments 10 and 0.

The divideNumbers method performs the division operation and returns the result.

If an ArithmeticException occurs, specifically a division by zero, the code enters the catch block. It then prints the error message “Error: Division by zero.” to the error stream using System.err.println().

Regardless of whether an exception occurs or not, the code includes a finally block. This block is always executed. In this case, it prints the message “Finally block executed.” to the console using System.out.println().

To summarize, the code attempts to divide the number 10 by 0. If a division by zero occurs, an error message is printed. The finally block is executed regardless of whether an exception occurs or not, and it prints the corresponding message.

Example 3: Catching Multiple Exceptions

public class MultipleExceptionExample {
    public static void main(String[] args) {
        try {
            int[] numbers = { 1, 2, 3 };
            System.out.println(numbers[5]);  // ArrayIndexOutOfBoundsException

            String text = null;
            System.out.println(text.length());  // NullPointerException
        } catch (ArrayIndexOutOfBoundsException e) {
            System.err.println("Error: Invalid index.");
        } catch (NullPointerException e) {
            System.err.println("Error: Null reference detected.");


Error: Invalid index.

In this example, we have an array of numbers, and we attempt to access an element at an invalid index (index 5), which results in an ArrayIndexOutOfBoundsException. Additionally, we assign null to the text variable and try to invoke the length() method on it, leading to a NullPointerException.

By using separate catch blocks, we can handle each exception type individually. In this case, the ArrayIndexOutOfBoundsException is caught first, and the corresponding error message is printed to the console.

Example 4: Rethrow an Exception in Java

In Java, rethrowing an exception is the process of catching an exception in one part of the code and then throwing the same exception to be handled by an outer scope or caller. This allows for propagating the exception up the call stack or providing additional information about the exception.

To rethrow an exception in Java, you can use the throw statement within a catch block. Here’s an example that demonstrates how to rethrow an exception:

public class RethrowExceptionExample {
    public static void main(String[] args) {
        try {
        } catch (Exception e) {
            System.out.println("An exception occurred: " + e.getMessage());

    public static void someMethod() throws Exception {
        try {
            // Code that may throw an exception
            throw new IllegalArgumentException("Some error occurred.");
        } catch (IllegalArgumentException e) {
            System.out.println("Handling the exception: " + e.getMessage());
            throw e; // Rethrow the exception


Handling the exception: Some error occurred.
An exception occurred: Some error occurred.

In this example, the someMethod() method throws an IllegalArgumentException within the try block. It then catches the exception, performs some handling or logging, and rethrows the same exception using the throw statement.

The rethrown exception is then caught in the catch block within the main() method, where it is displayed as a message. This allows you to handle the exception at a higher level or perform further actions if needed.


In conclusion, exception handling plays a crucial role in Java programming to manage and handle unexpected or exceptional situations that may arise during program execution. By using try-catch blocks, developers can effectively handle and recover from these exceptions, preventing the program from crashing and providing better user experience.

Java Beginner Tutorial Series

Please Subscribe Youtube| Like Facebook | Follow Twitter

2 Replies to “Java Part 10: Exception Handling in Java”

    1. Impact on Design and Implementation for Checked Exceptions

        Developers are forced to explicitly handle or acknowledge possible exceptions, which promotes better code quality by ensuring error scenarios are considered.
        Code becomes more readable as exception handling logic is clearly visible.
        It encourages developers to document the exceptional conditions their methods might throw, improving code documentation and making it easier for other developers to understand how to interact with the code.

      Impact on Design and Implementation for Unchecked Exceptions

        Unchecked exceptions can lead to unexpected program termination if not properly handled, making them a source of application instability.
        Developers need to be cautious when writing code that can throw unchecked exceptions, as they might not be caught by typical exception handling mechanisms.
        It’s crucial to design methods and classes in a way that minimizes the likelihood of unchecked exceptions occurring, by validating inputs and avoiding common programming mistakes.

Leave a Reply

Your email address will not be published. Required fields are marked *