Java Exception Handling With Real-life Examples

Exploring real-life situations helps grasp the essence of Java Exception Handling.

Scenario 1: Imagine a rare event that occurs only once every hundred years. You’ve eagerly booked a flight to witness this spectacle event. But as fate would have it, your flight gets delayed. This unexpected flight delay (exception) can be frustrating and disappointing, causing inconvenience and throwing your travel plans off course. Because you never thought, that how will you handle this exception (delay) in your plan, there is a high chance that you miss the event.

Scenario 2: Imagine you’ve been preparing for a high-paying product-based company interview for months (By the way you can check out Geekster to build your career in the Software Development field). The big day arrives, and you log into the video conferencing platform, ready to impress. But just as you’re about to start, an Internet service outage strikes! The screen froze, and your heart sank. Since you didn’t think to handle this exception (outage) earlier, there is a high chance that you may lose this lifetime opportunity.

Let’s see what you can do to tackle the above exceptions:

Solution 1: You can monitor weather conditions and prepare for potential delays before moving out for the event and plan ahead with alternative travel options and accommodations.

Solution 2: You can prepare in advance by having a backup internet connection, such as a mobile hotspot or alternative ISP, or inform the interviewers about the potential for internet issues and discuss alternative communication methods.

As a solution, you handled those exceptions before or during the happening of the exception. Exceptions in Java programming are similar to exceptions encountered in real-life situations. They represent unexpected events or errors that disrupt the normal flow of a program. 

What Is An Exception In Java?

In Java, an exception is like an alarm that goes off when something unexpected or unusual happens in a program. It’s a way for the program to say, “Hey, something went wrong!”

In Java, when your program encounters an exception, it means something unexpected occurred, such as trying to divide a number by zero or accessing a variable that doesn’t exist. These exceptions disrupt the normal flow of your program and need to be handled properly. To handle exceptions, you need to be prepared for these unexpected situations. It’s like having a backup plan or an alternative solution when things don’t go as expected. By handling exceptions, you can make sure your program doesn’t crash and can recover from these issues without causing confusion or frustration.

Exception VS Error  

Now, many of you may be confused between Exceptions and Errors in Java. Let’s have a clear look at how they differentiate. Exceptions occur within the program’s scope and can be recovered from, while Errors are severe and often beyond the program’s control, resulting in program termination. 

Exceptions	Errors
Exceptions are abnormal or unexpected conditions that occur during program execution.	Errors represent severe problems that occur at runtime and are typically beyond the control of the program.
They are caused by factors such as invalid input, resource unavailability, or logical errors in code.	They indicate significant failures or issues that usually cannot be recovered from.
Exceptions are recoverable and can be handled through exception-handling mechanisms.	Errors are unrecoverable and may result in the termination of the program.
The code of the program is accountable for exceptions.	The system in which the program is running is responsible for errors.

Reasons why Exceptions occur in Java

• Invalid input: When a program receives unexpected or incorrect data.
• Resource limitations: When there is a lack of available resources like memory or files.
• Programming errors: Mistakes or issues in the code itself.
• External dependencies: Problems with connected systems or services.
• Unexpected conditions: Situations that cannot be predicted or controlled during program execution.

Why should you handle Exceptions in Java?

Java Exception Handling is vital to ensure seamless and dependable code execution. Discover the significance of handling Java exceptions effectively.

• Prevent Program Crashes:
  By handling exceptions, you can prevent your program from crashing or abruptly terminating due to unexpected errors.

• Improve User Experience:
  Proper exception handling provides meaningful error messages to users, enhancing their experience and helping them understand and resolve issues.

• Easy Troubleshooting:
  Exception handling assists in identifying and addressing errors, making troubleshooting and debugging more manageable.

• Maintainable Code:
  Well-implemented exception handling leads to code that is easier to understand, modify, and maintain over time.

For example,

Code:

public class Example {
    public static void main(String[] args) {
        int numerator = 10;
        int denominator = 0;
        System.out.println("Performing division...");
        int result = numerator / denominator;
        System.out.println("Result: " + result);
    }
}

Output:

Performing division...
Exception in thread "main" java.lang.ArithmeticException: / by zero
    at Example.main(Example.java:7)

As soon as the division by zero operation is encountered (int result = numerator / denominator;), an ArithmeticException is thrown. This exception interrupts the normal flow of execution. In the output, you can see that the print statement before the exception is successfully executed (Performing division…). However, the program terminates abruptly due to the unhandled exception. The stack trace shows the exception message (/ by zero) and specifies that the exception occurred in the main method of the Example class at line 7 (Example.java:7).

How does the JVM handle Exceptions?

Let’s understand how JVM handles exceptions to provide insights into the behind-the-scenes process of handling exceptions and errors in Java applications. 

Step 1. Exception Occurrence:

• When an exceptional condition occurs during program execution, such as a runtime error or unexpected behavior, an exception is thrown.

Step 2. Exception Propagation:

• The JVM identifies the location where the exception occurred and propagates it up the call stack, searching for an appropriate exception handler.

Step 3. Exception Handler Search:

• The JVM looks for a suitable exception handler that can handle the specific type of exception thrown.
• The search begins within the current method, moving up through the call stack until an appropriate handler is found.

Step 4. Exception Handling:

• Once an exception handler is found, the JVM transfers control to the handler block, which contains the necessary code to handle the exception.
• The handler may perform actions like logging the exception, displaying an error message, or taking corrective measures.

Step 5. Exception Resolution:

• After executing the exception handler, the JVM determines the further course of action.
• If the exception is successfully handled, the program continues execution from the point immediately after the exception block.
• If the exception remains unhandled, it may lead to program termination and display a stack trace.

Hierarchy Of Exception Class 

As Java is an object-oriented language every class extends the Object class. All exceptions and errors are subclasses of the class Throwable. The java.lang.Throwable class is the root class of the Java Exception hierarchy inherited by two subclasses: Exception and Error. The hierarchy of Java Exception classes is given below:

Types Of Exceptions In Java

Exceptions in Java can be categorized into two ways i.e. 

1. Built-In Exceptions.

• Checked Exceptions.
• Unchecked Exceptions.

2. Customized Exceptions.

Built-in Exceptions

Built-in exceptions, also known as standard exceptions, are predefined exception classes provided by Java. These exceptions cover a wide range of common errors and exceptional situations that can occur during program execution. Built-in exceptions are part of the Java standard library and provide a standardized way to handle common exceptional scenarios.

Built-In Exceptions can be further classified into two categories – 

1. Checked Exceptions
2. Unchecked Exceptions

Checked Exceptions

Checked exceptions are exceptions that the Java compiler requires you to handle explicitly in your code. These exceptions are checked at compile-time, and if not handled properly, the code will not compile. Checked exceptions are subclasses of the Exception class but not subclasses of the RuntimeException class.

Unchecked Exceptions

Unchecked exceptions, also known as runtime exceptions, are exceptions that do not need to be explicitly handled in the code. These exceptions are subclasses of the RuntimeException class or its subclasses. Unlike checked exceptions, unchecked exceptions are not required to be declared or caught explicitly.

User-defined Exceptions

User-defined exceptions are created by extending the base Exception class or its subclasses. By creating customized exceptions, you can handle application-specific exceptional conditions that are not covered by the built-in exceptions. They are handled using keywords like `try`, `catch`, `finally`, `throw`, and `throws`. Let’s take a look at some of the important exception-related keywords in Java:

• `try`: The try block is used to enclose a set of statements that might throw an exception. It is followed by one or more catch blocks or a finally block.
• `catch`: The catch block is used to catch and handle specific exceptions that occur within the corresponding try block. It contains the code that executes when a particular exception is thrown.

• `finally`: The finally block is used to define a block of code that always executes, regardless of whether an exception is thrown or not. It is typically used to perform cleanup operations or release resources.

• `throw`: The throw keyword is used to explicitly throw an exception. It is followed by an instance of the Throwable class or one of its subclasses. This allows developers to manually trigger exceptions based on certain conditions.

• `throws`: The throws keyword is used in method signatures to declare that the method might throw one or more exceptions. It specifies the type of exceptions that the method can throw, allowing callers to handle those exceptions.

Custom Exceptions in Java

Custom Exceptions allow developers to define their own exception classes to represent application-specific errors or exceptional conditions.  By using custom exceptions, developers can enforce specific rules or requirements in their applications and provide tailored error handling for different scenarios. 

Example:

public class InsufficientFundsException extends Exception {
    public InsufficientFundsException(String message) {
        super(message);
    }
}

public class BankAccount {
    private double balance;

    public void withdraw(double amount) throws InsufficientFundsException {
        if (amount > balance) {
            throw new InsufficientFundsException("Insufficient funds in the account");
        }
        balance -= amount;
        System.out.println("Withdrawal successful. Remaining balance: " + balance);
    }
}

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

        try {
            account.withdraw(1500);
        } catch (InsufficientFundsException e) {
            System.out.println("Exception caught: " + e.getMessage());
        }
    }
}

Output:

Deposit: $1000
Withdraw: $1500
Error: Insufficient funds. Available balance: $1000

The code demonstrates a custom exception called `InsufficientFundsException` that is thrown when attempting to withdraw an `amount` greater than the account `balance`. The `BankAccount` class has a withdraw method that throws this exception. In the `Main` class, we create a `BankAccount` instance, deposit funds, and then try to withdraw an amount greater than the balance. If the exception is thrown, it is caught in a `catch` block, and an error message is printed. Otherwise, a success message and the remaining balance are displayed.

To learn about the type of exceptions in detail, you can refer to the blog “Types of Exceptions in Java”.

Exception Handling In Java: Best Practices 

• Always catch only those exceptions that can be handled.
• Null values should not be returned in catch block rather than handling an exception, it consumes the exception and the error fails permanently, and the program crashes.
• Don’t get the exception class instead catch particular subclasses.
• Never throw an exception from the finally block, because even if any exception is not raised in the try block, finally block will throw the exception, after the execution of try-catch blocks.
• Use finally blocks instead of catch blocks if you are not going to handle the exception.
• Always use the finally block to close the used resources.

Advantages Of Exception Handling In Java

• Error Management: Exception handling helps manage errors and exceptional situations effectively.
• Robustness: It makes your code more resilient and prevents crashes or unpredictable behavior.
• Code Readability: Exception handling improves code organization and readability.
• Debugging: It assists in troubleshooting by providing error messages and stack traces.
• Graceful Error Recovery: Exception handling enables the graceful handling of errors with alternative actions.
• Maintainability: It centralizes error-handling code, making it easier to update and maintain.
• Scalability: Exception handling allows for the addition of custom exception classes as your application grows.
• Application Stability: Proper exception handling improves overall application stability.
• Graceful Termination: It facilitates a clean program termination in exceptional cases.
• User Experience: Exception handling provides meaningful error messages for better user understanding.

Conclusion

1. Exception handling in Java is crucial for managing unwanted terminations, exceptions, and exceptional situations in a program.
2. Errors, such as OutOfMemoryError and StackOverflowError, are distinct from exceptions and indicate critical problems that cannot be easily recovered from.
3. Java exceptions are classified into built-in exceptions and user-defined exceptions.
4. Built-in exceptions include checked exceptions and unchecked exceptions.
5. Checked exceptions require explicit handling using try-catch blocks or the throws keyword.
6. Unchecked exceptions do not require explicit handling and are typically caused by programming errors.
7. Exception handling in Java involves using keywords like try, catch, finally, throw, and throws.
8. The try block is used to enclose the code that may potentially throw an exception.
9. The catch block is used to catch and handle specific exceptions that occur within the try block.
10. The finally block is used to execute code that should always run, regardless of whether an exception is thrown or not.
11. The throw keyword is used to manually throw a specific exception.
12. The throws keyword is used to declare the exceptions that a method may throw.
13. Proper use of these exception keywords ensures effective error management and reliable program execution.
14. Adhering to exception handling best practices leads to more robust, readable, and maintainable Java code.

Happy handling!