Java Exception Handling Interview Questions and Answers

Java exception handling interview questions for beginners

Question 1 : What is an exception in Java?

In Java, an exception is an event that disrupts the normal flow of the program’s execution. It occurs when an abnormal condition arises during the execution of a program, such as a division by zero, invalid input, or a file not found.

Question 2 : What are the types of exceptions in Java?

There are two types of exceptions in Java:

• Checked exceptions: These are exceptions that are checked at compile time. Examples include IOException, FileNotFoundException, SQLException.
• Unchecked exceptions (Runtime exceptions): These are exceptions that are not checked at compile time. Examples include NullPointerException, ArrayIndexOutOfBoundsException, ArithmeticException.

Question 3 : What is the purpose of exception handling in Java?

The purpose of exception handling in Java is to gracefully handle runtime errors and abnormal conditions that may occur during the execution of a program. It allows developers to write code that can detect, handle, and recover from errors, preventing the program from crashing or terminating abruptly.

Question 4 : What is the try-catch block in Java?

The try-catch block is used in Java to handle exceptions. The code that may throw an exception is placed inside the try block, and the catch block is used to catch and handle the exception if it occurs. If an exception occurs within the try block, the control is transferred to the catch block, where the exception can be handled.

Question 5 : Can a try block exist without a catch block in Java?

Yes, a try block can exist without a catch block in Java, but it must be followed by either a catch block or a finally block. The finally block is used to execute code that should always be executed, regardless of whether an exception occurs or not.

Question 6 : What is the output of the below code ?

public class ExceptionExample {
    public static void main(String[] args) {
        try {
            int result = divide(10, 0);
            System.out.println("Result: " + result);
        } catch (ArithmeticException e) {
            System.out.println("Caught ArithmeticException: " + e.getMessage());
        }
    }

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

Output :- Caught ArithmeticException: / by zero

Java exception handling interview questions for experienced

Question 7: Explain the difference between checked and unchecked exceptions in Java.

Checked exceptions are those that are checked at compile-time, meaning the compiler forces you to handle them using try-catch or declare them in the method signature.
Examples include IOException and SQLException.

Unchecked exceptions, on the other hand, are not checked at compile-time and can occur at runtime.
Examples include NullPointerException and ArrayIndexOutOfBoundsException.

Question 8: How do you handle multiple exceptions in a single catch block?

You can use a multi-catch block introduced in Java 7 to handle multiple exceptions in a single catch block.

For example:

   try {
       // Code that may throw exceptions
   } catch (IOException | SQLException e) {
       // Handle IOException or SQLException
   }

Question 9: What is the purpose of the finally block in exception handling?

The finally block is used to execute code that should always be run regardless of whether an exception occurs or not. It is often used for resource cleanup operations such as closing files or releasing database connections.

Question 10: Explain the concept of exception propagation in Java ?

Exception propagation refers to the process by which an exception is passed from method to method in the call stack until it is handled or reaches the top-level caller. If an exception is not caught and handled within a method, it is propagated to the calling method, and so on until it is caught or the program terminates.

Question 11: What is the difference between throw and throws in Java exception handling?

The throw keyword is used to explicitly throw an exception within a method. For example:

   throw new IOException("File not found");

The throws keyword, on the other hand, is used in a method signature to declare that the method may throw certain types of exceptions. It indicates to the caller of the method that they need to handle or propagate the specified exception.

For example:

   public void readFile() throws IOException {
       // Code that may throw IOException
   }

Question 12: Explain the difference between Error and Exception in Java ?

Errors are exceptional conditions that are not expected to be caught or handled by the program, as they usually indicate serious problems that should not be recovered from. Examples include OutOfMemoryError and StackOverflowError.

Exceptions, on the other hand, are exceptional conditions that can be caught and handled by the program. They are further divided into checked and unchecked exceptions.

Question 13: What is the purpose of the try-with-resources statement in Java ?

The try-with-resources statement is used to automatically close resources (such as streams, files, or database connections) that implement the AutoCloseable interface. It ensures that the resources are closed properly, even if an exception occurs within the try block.

Question 14: Can you explain the concept of custom exceptions in Java ?

Custom exceptions, also known as user-defined exceptions, are exceptions that are created by the programmer to represent specific error conditions in their applications. They are typically subclasses of the Exception class or one of its subclasses and allow for more meaningful error handling and reporting in the application.

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

Question 15: What is the difference between final, finally, and finalize in Java ?

• final: It is a keyword used to declare a constant variable, a method that cannot be overridden, or a class that cannot be subclassed.
• finally: It is a block used in exception handling to execute code that should always be executed, regardless of whether an exception occurs or not.
• finalize: It is a method called by the garbage collector before reclaiming the memory occupied by an object. It is used for cleanup operations before an object is garbage collected.

Question 16: Explain the hierarchy of exceptions in Java ?

In Java, all exceptions and errors are subclasses of the Throwable class. The two main subclasses of Throwable are Exception and Error. Exceptions are further divided into checked exceptions (subclass of Exception) and unchecked exceptions (subclass of RuntimeException). Checked exceptions must be caught or declared in the method signature, while unchecked exceptions do not have this requirement.

Throwable
├── Error
│   ├── AssertionError
│   ├── OutOfMemoryError
│   ├── StackOverflowError
│   └── ...
├── Exception
│   ├── RuntimeException
│   │   ├── NullPointerException
│   │   ├── IndexOutOfBoundsException
│   │   ├── IllegalArgumentException
│   │   ├── ClassCastException
│   │   └── ...
│   ├── IOException
│   │   ├── FileNotFoundException
│   │   ├── SocketException
│   │   └── ...
│   ├── SQLException
│   └── ...
└── ...

Question 17 : What is the purpose of the getMessage() method in the Throwable class?

The getMessage() method in the Throwable class is used to retrieve the error message associated with an exception. It returns a string containing the error message specified when the exception was thrown or the default error message if no message was specified.

Question 18 : What is the purpose of the printStackTrace() method in Java?

The printStackTrace() method in Java is used to print the stack trace of an exception to the standard error stream. It prints the sequence of method calls that led to the exception, along with the line numbers and class names of the methods in the call stack.

Question 19 : What is the purpose of the suppressWarnings annotation in Java?

The @SuppressWarnings annotation in Java is used to suppress compiler warnings for specific types of warnings. It is typically used to suppress unchecked or deprecated warnings that may occur in code that cannot be easily fixed or updated.

Question 20 : Guess the output of following question ?

public class FinallyBlockExample {
    public static void main(String[] args) {
        try {
            System.out.println("Try block executed");
            System.exit(0);
        } finally {
            System.out.println("Finally block executed");
        }
    }
}

Output :-
Try block executed
Finally block executed

Java exception handling interview questions for 10 years experience

Question 21 : How can you handle exceptions in Java 8 Streams?

• Answer: In Java 8 Streams, you can use the try-catch block within the map, flatMap, or other intermediate operations to handle checked exceptions.

myList.stream()
    .map(item -> {
        try {
            return doSomething(item);
        } catch (MyException e) {
            throw new RuntimeException(e);
        }
    })
    .forEach(System.out::println);

Question 22 : How does Java handle exceptions in a multithreaded environment?

• Answer: In a multithreaded environment, each thread has its own call stack and handles exceptions independently. If an exception occurs in a thread and is not caught and handled within that thread, it will propagate up the call stack of that thread until it is caught or the thread terminates. Other threads are not affected by exceptions that occur in separate threads.

Question 23 : Can you explain the concept of exception chaining in Java?

• Answer: Exception chaining, also known as exception wrapping, is the practice of encapsulating one exception within another exception. This allows for more detailed error reporting and preserves the original exception’s stack trace. Java provides constructors for exceptions that take a cause parameter, allowing you to chain exceptions. For example:

try { 
// Code that may throw an IOException 
} catch (IOException e) {
 throw new MyCustomException("An error occurred while processing the file", e); 
}

Question 24 : How do you handle exceptions in Java 8 CompletableFuture?

• Answer: In Java 8 CompletableFuture, you can use the exceptionally() method to handle exceptions asynchronously. This method allows you to provide a function that transforms an exception into a new result or another exception. Additionally, you can use the exceptionallyCompose() method to handle exceptions by asynchronously executing another CompletableFuture.

In this example:

• We create a CompletableFuture that may throw a random exception.
• We use the handle() method to handle exceptions and process the result.
• The exceptionally() method is used to handle exceptions and provide a default value.
• The whenComplete() method is used to perform an action whether an exception occurs or not.

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExceptionHandling {
    public static void main(String[] args) {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            // Simulating a method that may throw an exception
            if (Math.random() < 0.5) {
                throw new RuntimeException("Random exception occurred!");
            }
            return 42;
        });

        future
            .handle((result, ex) -> {
                if (ex != null) {
                    System.out.println("Exception occurred: " + ex.getMessage());
                    return -1; // Default value in case of exception
                }
                return result;
            })
            .thenAccept(result -> System.out.println("Result: " + result));

        future
            .exceptionally(ex -> {
                System.out.println("Exception occurred: " + ex.getMessage());
                return -1; // Default value in case of exception
            });

        future
            .whenComplete((result, ex) -> {
                if (ex != null) {
                    System.out.println("Exception occurred: " + ex.getMessage());
                } else {
                    System.out.println("Result: " + result);
                }
            });
    }
}

Question 25 : Can you give an example of how you would handle an exception in Java using the Optional class ?

Optional<String> optionalValue = Optional.ofNullable(someValue);
optionalValue.orElseThrow(() -> new CustomException("Value is null"));

Question 26 : Describe the role of the Throwable class in Java exception handling. How does it relate to the Exception and Error classes ?

The Throwable class serves as the foundation of Java’s exception handling mechanism. It defines the common behavior and methods that are shared by both exceptions and errors. By extending directly from Throwable, the Exception and Error classes form the two main branches of the Java exception hierarchy, representing conditions that can be caught and handled by application code and conditions that should typically not be handled by application code, respectively.

The Throwable class defines several methods that are common to both exceptions and errors. These include methods like getMessage(), printStackTrace(), getCause(), getStackTrace(),

Question 27 : Discuss the use of the Thread.UncaughtExceptionHandler interface in Java exception handling. When and how would you implement custom uncaught exception handlers ?

In Java, the Thread.UncaughtExceptionHandler interface is used to handle uncaught exceptions that occur within threads. When a thread terminates due to an uncaught exception, the JVM looks for an uncaught exception handler associated with the thread. If no handler is found, the default behavior is to print the stack trace to the standard error stream and terminate the program.

Here’s how the Thread.UncaughtExceptionHandler interface is used in Java exception handling:

Implementing the Interface:

• To create a custom uncaught exception handler, you need to implement the Thread.UncaughtExceptionHandler interface. This interface has a single method, uncaughtException(Thread t, Throwable e), which is called when an uncaught exception occurs in a thread.

Setting the Handler:

• Once you’ve implemented the interface, you can associate an instance of your custom uncaught exception handler with a thread by calling the setUncaughtExceptionHandler() method on the thread object.
• Alternatively, you can set a default uncaught exception handler for all threads in the JVM by calling the static setDefaultUncaughtExceptionHandler() method on the Thread class.

Handling Uncaught Exceptions:

• When an uncaught exception occurs in a thread, the uncaughtException() method of the associated uncaught exception handler is invoked. Inside this method, you can implement custom logic to handle the exception.
• Common actions performed in the uncaughtException() method include logging the exception, sending an error report to a monitoring service, gracefully shutting down the application, or performing cleanup operations.

Here’s an example of how you can implement a custom uncaught exception handler:

import java.lang.Thread.UncaughtExceptionHandler;

public class CustomUncaughtExceptionHandler implements UncaughtExceptionHandler {

    @Override
    public void uncaughtException(Thread t, Throwable e) {
        System.err.println("Uncaught exception in thread: " + t.getName());
        e.printStackTrace();
        // Perform custom exception handling logic here
    }

    public static void main(String[] args) {
        // Create a new thread
        Thread thread = new Thread(() -> {
            // Simulate an uncaught exception
            throw new RuntimeException("Simulated uncaught exception");
        });

        // Set the custom uncaught exception handler for the thread
        thread.setUncaughtExceptionHandler(new CustomUncaughtExceptionHandler());

        // Start the thread
        thread.start();
    }
}

In this example, we create a custom uncaught exception handler by implementing the Thread.UncaughtExceptionHandler interface. We associate an instance of this custom handler with a thread using the setUncaughtExceptionHandler() method. When the thread throws an uncaught exception, the uncaughtException() method of the custom handler is called, where we can implement custom exception handling logic.

Question 28 : Discuss common anti-patterns or pitfalls in Java exception handling. How can you avoid these pitfalls and write robust exception handling code ?

Java exception handling is a critical aspect of writing robust and maintainable code, but there are several common pitfalls and anti-patterns that developers may encounter. Here are some of them, along with strategies for avoiding them:

Swallowing Exceptions:

• Pitfall: Catching an exception without handling it properly or logging it can lead to silent failures and make debugging difficult.
• Avoidance: Always handle exceptions appropriately by logging them, reporting them to the user if necessary, and taking corrective action. If an exception cannot be handled at a particular level, consider propagating it to a higher level where it can be handled effectively.

Catching Generic Exceptions:

• Pitfall: Catching generic exceptions like Exception or RuntimeException can mask specific types of exceptions and make error diagnosis challenging.
• Avoidance: Catch specific types of exceptions that your code may throw, rather than catching generic exceptions. This allows you to handle different types of exceptions differently and provide more meaningful error messages to users.

Empty Catch Blocks:

• Pitfall: Having empty catch blocks or catch blocks that do nothing can hide errors and make troubleshooting difficult.
• Avoidance: Always include meaningful code in catch blocks, such as logging the exception, rolling back transactions, closing resources, or notifying users about the error. If no action can be taken, consider whether catching the exception is necessary at all.

Overusing Checked Exceptions:

• Pitfall: Excessive use of checked exceptions can clutter the code with unnecessary try-catch blocks and make it harder to read and maintain.
• Avoidance: Use checked exceptions judiciously for recoverable errors that the caller can reasonably be expected to handle. For non-recoverable errors or conditions beyond the caller’s control, consider using unchecked exceptions instead.

Ignoring Resource Management:

• Pitfall: Failing to properly manage resources like files, streams, and database connections can lead to resource leaks and performance issues.
• Avoidance: Always use try-with-resources statements or ensure that resources are properly closed in finally blocks to guarantee their cleanup, even in the event of an exception. Alternatively, consider using libraries or frameworks that handle resource management automatically, such as Spring’s @Transactional annotation for database transactions.

Exception Misuse for Flow Control:

• Pitfall: Using exceptions for control flow, such as using exceptions to handle expected conditions or looping constructs, can degrade performance and readability.
• Avoidance: Use exceptions only for exceptional conditions, such as errors or unexpected situations. For expected conditions or routine control flow, prefer using conditional statements or looping constructs instead of relying on exceptions.

Ignoring InterruptedException:

• Pitfall: Ignoring or swallowing InterruptedException in multi-threaded code can prevent proper interruption and shutdown of threads.
• Avoidance: Handle InterruptedException appropriately by either rethrowing it, restoring the interrupted status of the thread, or taking appropriate action to terminate the thread or task gracefully.

Failing to Document Exceptions:

• Pitfall: Neglecting to document the exceptions thrown by a method or API can lead to confusion and uncertainty for users of the code.
• Avoidance: Document the exceptions thrown by a method or API in its Javadoc comments, including the conditions under which each exception may occur and any corrective actions that can be taken. This helps users understand how to handle exceptions and write robust code.

By avoiding these common pitfalls and following best practices for exception handling, developers can write more robust, reliable, and maintainable Java code that gracefully handles errors and unexpected conditions.

Question 29 : Is it possible to override a super class method that throws an unchecked exception with checked exceptions in the sub class?

No, it is not possible to override a superclass method that throws an unchecked exception with checked exceptions in the subclass. This is because checked exceptions are subject to compile-time checking, and the signature of the overriding method in the subclass must be compatible with the overridden method in the superclass.

However, the opposite is allowed: a subclass method can override a superclass method that throws a checked exception with a subclass of that exception or with no exception at all (i.e., a method that does not declare any checked exceptions).

class Superclass {
    // Superclass method throws unchecked exception
    void method() throws NullPointerException {
        // Some implementation
    }
}

class Subclass extends Superclass {
    // This is not allowed: overriding method cannot throw checked exception
    // void method() throws IOException { }
    
    // This is allowed: overriding method does not throw exception
    void method() { }
}

Question 30 : Describe your approach to testing exception handling code in Java applications. What strategies do you use to ensure that exception handling code behaves correctly under different error conditions and edge cases?

Testing exception handling code in Java applications is crucial to ensure that the application behaves correctly and gracefully handles errors and exceptional conditions. Here’s an approach to testing exception handling code along with strategies to ensure comprehensive test coverage:

Unit Testing:

• Write unit tests for each method or code block that contains exception handling logic. Test cases should cover both the normal execution path and various error conditions that may trigger exceptions.
• Use testing frameworks like JUnit or TestNG to automate the execution of unit tests and assert the expected behavior of the exception handling code.

Boundary Testing:

• Test boundary conditions and edge cases where exceptions are likely to occur. This includes testing scenarios such as passing null or empty values, exceeding maximum input sizes, or hitting resource limits.
• Ensure that exception handling code behaves correctly when inputs are at the boundaries of valid ranges or when unusual conditions are encountered.

Negative Testing:

• Conduct negative testing to verify that the application handles invalid inputs and unexpected conditions appropriately. Intentionally inject errors or faults into the system to simulate exceptional scenarios and validate the behavior of the exception handling code.
• Test error conditions such as network timeouts, database connection failures, file system errors, and invalid user input to ensure that exceptions are caught and handled gracefully.

Mocking and Stubbing:

• Use mocking frameworks like Mockito or EasyMock to create mock objects or stubs for external dependencies (e.g., databases, APIs) that may throw exceptions.
• Mock external dependencies to simulate different error conditions and exception scenarios, allowing you to test the behavior of the application in isolation without relying on real external systems.

Code Coverage Analysis:

• Measure code coverage using tools like JaCoCo or Cobertura to ensure that exception handling code is adequately tested.
• Aim for high code coverage across exception handling code paths, including catch blocks, finally blocks, and exception propagation scenarios.

Exception Propagation Testing:

• Test exception propagation scenarios to verify that exceptions are propagated correctly through the call stack and that they are caught and handled appropriately at the appropriate levels of the application.
• Ensure that exceptions are logged or reported as necessary to facilitate error diagnosis and troubleshooting.

Integration Testing:

• Conduct integration tests to verify the interaction between different components of the application and to ensure that exceptions are handled correctly across module boundaries.
• Test exception handling code in conjunction with other application components to validate end-to-end error handling and recovery mechanisms.

Regression Testing:

• Include exception handling tests in your regression test suite to ensure that changes or updates to the codebase do not introduce new errors or break existing error handling logic.
• Run regression tests regularly to detect and address any regressions in exception handling behavior.

By following these strategies and approaches, you can ensure comprehensive testing of exception handling code in Java applications, thereby improving the reliability, stability, and robustness of the software.

If you are preparing for Java interviews then you can checkout these articles.

Conclusion :

Through this comprehensive guide to Java Exception Handling Interview Questions and answers, we’ve covered various aspects of exception handling, including the differences between checked and unchecked exceptions, best practices for handling exceptions, common pitfalls to avoid, and strategies for testing exception handling code effectively.