Exceptions in Java with Examples

In programming, an exception refers to an event that occurs during program execution, causing a disruption in the normal flow of instructions. Java offers a robust mechanism for handling exceptions, which is crucial for developing reliable and resilient programs.

When an exception occurs in Java, it throws an object of the corresponding exception class. These exceptions can be caught and managed by the program. Exception handling plays a vital role as it enables programs to gracefully recover from errors and prevent crashes or incorrect outcomes.

Java categorizes exceptions into two types: checked exceptions and unchecked exceptions. Checked exceptions require either catching them or declaring them in the method signature, while unchecked exceptions do not have this obligation.

Types of Java Exceptions

Exceptions are an integral part of Java programming and can’t be avoided. They represent errors that occur during the execution of a Java program. Java categorizes exceptions into three primary types: checked exceptions, unchecked exceptions, and errors.

Checked exceptions:

• Checked exceptions occur during compile time and are also known as compile-time exceptions.
• The compiler checks for these exceptions, and the code must either handle them using try-catch blocks or declare them in the method signature.
• Examples of checked exceptions include IOException, FileNotFoundException, and ClassNotFoundException.

Example of handling a checked exception:

import java.io.File;
import java.io.FileReader;
import java.io.FileNotFoundException;
import java.io.IOException;

public class Main {
    public static void main(String[] args) {
        try {
            File file = new File("example.txt");
            FileReader fileReader = new FileReader(file);
            int character;

            StringBuilder content = new StringBuilder();
            while ((character = fileReader.read()) != -1) {
                content.append((char) character);
            }

            System.out.println("File contents: \n" + content.toString());
            
            fileReader.close();
        } catch (FileNotFoundException e) {
            System.out.println("File not found: " + e.getMessage());
        } catch (IOException e) {
            System.out.println("Error reading file: " + e.getMessage());
        }
    }
}

Output:
File not found: example.txt (No such file or directory)

Unchecked exceptions:

• Unchecked exceptions, also referred to as runtime exceptions occur during program execution.
• The compiler does not enforce handling or declaring these exceptions in the method signature.
• Examples of unchecked exceptions include ArithmeticException, NullPointerException, and ArrayIndexOutOfBoundsException.

Example of handling an unchecked exception:

public class Main {
    public static void main(String[] args) {
        int a = 5;
        int b = 0;
        try {
            int result = a / b;
            System.out.println("Result: " + result);
        } catch (ArithmeticException e) {
            System.out.println("Cannot divide by zero: " + e.getMessage());
        }
    }
}

Output:
Cannot divide by zero: / by zero

Errors:

• Errors indicate serious problems that typically cannot be handled by the program.
• Unlike checked and unchecked exceptions, errors usually represent critical issues.
• Examples of errors include OutOfMemoryError and StackOverflowError.

Example of handling an error:

public class Main {
    public static void main(String[] args) {
        try {
            int[] array = new int[Integer.MAX_VALUE];
        } catch (OutOfMemoryError e) {
            System.out.println("Error: Out of memory");
        }
    }
}

Output:
Error: Out of memory

In the given example, an attempt is made to create an array with a size exceeding the maximum value of an integer, resulting in an OutOfMemoryError.

To summarize, Java exceptions are classified into checked exceptions, unchecked exceptions, and errors. Checked exceptions must be handled or declared, while unchecked exceptions do not require explicit handling. Errors indicate severe issues that cannot be typically resolved within the program.

Exception Handling in Java

Exception handling is a crucial aspect of Java programming that helps handle unexpected errors during program execution. Java provides various mechanisms for exception handling, including try-catch blocks, multiple-catch blocks, the final block, and throwing exceptions.

Try-Catch Blocks:

A try-catch block is used to handle exceptions that may occur within the program. The try block contains the code that might generate an exception, while the catch block contains the code to handle the exception.

Example:

try {
    BufferedReader reader = new BufferedReader(new FileReader("file.txt"));
    String line = reader.readLine();
    System.out.println(line);
} catch (IOException e) {
    System.out.println("Error reading file: " + e.getMessage());
}

If an IOException occurs while reading the file, the catch block will execute and display an error message.

Multiple Catch Blocks:

Java allows multiple catch blocks within a single try-catch statement, enabling different exceptions to be handled differently.
Example:

try {
    int result = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println("Divide by zero error: " + e.getMessage());
} catch (Exception e) {
    System.out.println("An error occurred: " + e.getMessage());
}

If an ArithmeticException is thrown, the first catch block will execute and display a specific error message. For other types of exceptions, the second catch block will execute and display a general error message.

The Finally Block:

The final block is used to execute code after a try-catch block, regardless of whether an exception was thrown or not. It is useful for releasing resources such as files or network connections.
Example:

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

public class Main {
    public static void main(String[] args) {
        BufferedReader reader = null;
        try {
            reader = new BufferedReader(new FileReader("file.txt"));
            String line = reader.readLine();
            System.out.println(line);
        } catch (IOException e) {
            System.out.println("Error reading file: " + e.getMessage());
        } finally {
            try {
                if (reader != null) {
                    reader.close();
                }
            } catch (IOException e) {
                System.out.println("Error closing file: " + e.getMessage());
            } finally {
                System.out.println("Finally block executed.");
            }
        }
    }
}

Output:
Error reading file: file.txt (No such file or directory)
Finally, the block is executed.

Whether an exception occurs or not, the final block will execute and attempt to close the BufferedReader.

Throwing Exceptions:

Java allows developers to manually throw exceptions using the throw keyword. This is useful for creating custom exceptions or handling errors that cannot be resolved automatically.
Example:

class InsufficientFundsException extends Exception {
    public InsufficientFundsException() {
        super("Insufficient funds in account");
    }
}

class BankAccount {
    private double balance;

    public void deposit(double amount) {
        balance += amount;
    }

    public void withdraw(double amount) throws InsufficientFundsException {
        if (amount > balance) {
            throw new InsufficientFundsException();
        }
        balance -= amount;
    }
}

public class Main {
    public static void main(String[] args) {
        BankAccount account = new BankAccount();
        account.deposit(100.0);

        try {
            account.withdraw(150.0);
            System.out.println("Withdrawal successful.");
        } catch (InsufficientFundsException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

Output:
Error: Insufficient funds in an account

If a user attempts to withdraw more money than they have in their account, the InsufficientFundsException will be thrown and must be caught by the calling method.

Best Practices for Exception Handling

Exception handling plays a critical role in developing resilient Java programs. By following recommended guidelines, programmers can effectively manage exceptions, identify and resolve errors, and enhance the overall dependability of their applications.

Consider the following best practices for exception handling in Java:

Appropriate Exception Handling Level:

Exceptions should be caught at a suitable level within the code. This ensures accurate error reporting. Catching exceptions too high up in the code hierarchy can lead to misleading error information while catching them too low can result in code duplication and unnecessary complexity.

Avoid Unnecessary Exception Catching:

It is important to avoid catching exceptions that cannot be handled or do not require catching. This helps prevent code redundancy and simplifies the debugging process. Only catch exceptions that can be effectively managed or are necessary for error reporting purposes.

Effective Exception Logging:

Logging exceptions is crucial for effective debugging and troubleshooting. When an exception occurs, logging the exception along with pertinent details like error messages and stack traces facilitates identifying the root cause of the issue and aids in finding a solution.

Custom Exception Creation:

There may be situations where the built-in Java exceptions do not adequately address specific application requirements. In such cases, developers can create custom exceptions by extending the Exception class. Custom exceptions enable the definition of unique error messages and error codes tailored to the specific needs of the application.

Here’s an example of a custom exception class in Java:

public class CustomException extends Exception {
   public CustomException(String errorMessage) {
      super(errorMessage);
   }
}

Adhering to these best practices empowers developers to improve their exception-handling skills in Java and create reliable and robust applications.

Conclusion

In conclusion, Java exceptions are a crucial aspect of Java programming as they enable programmers to handle unexpected events during program execution. It is important to have a good understanding of various types of exceptions, such as checked, unchecked, and errors, to effectively handle exceptions in Java.

Implementing best practices like handling exceptions at the appropriate level, avoiding unnecessary exception catching, logging exceptions for debugging purposes, and creating custom exceptions can significantly improve the exception-handling process in Java.

Mastering Java exception handling is an essential skill for every Java programmer. By following the recommended tips and best practices discussed in this article, programmers can develop more reliable and robust Java applications capable of handling unexpected events seamlessly.