30+ Exception Handling Interview Questions and Answers in 2025 [Freshers & Experienced]

Exception handling interview questions are a common focus in technical interviews, often covering key areas such as try-catch-finally usage, custom exceptions, and  exception propagation. Interviewers may also explore your familiarity with real-time monitoring and logging tools like Sentry, Log4j, or Stackdriver, which are essential for maintaining stability in production systems.

However, many candidates struggle to deliver clear, structured answers, especially to scenario-based questions that test both conceptual clarity and practical application.

In this blog, you'll find 30+ Java's exception handling interview questions and answers for 2025, carefully selected to help freshers and experienced professionals build a strong understanding of core concepts.

Exception Handling Interview Questions and Answers: Freshers

Understanding exception handling is essential for freshers aiming to succeed in technical interviews. Employers expect candidates to be familiar with core concepts such as try-catch in Java, exception hierarchy, custom exceptions, and the distinction between checked and unchecked exceptions. They also value a clear understanding of how to handle exceptions gracefully to ensure code stability and user-friendly error reporting.

If you want to strengthen your skills and stand out in competitive software development roles, consider these top-rated upGrad programs. Each course is designed to build in-demand expertise that employers seek in today's tech field:

• AI-Powered Full-stack Development Course by IIITB
• Executive Programme in Generative AI for Leaders
• Executive Diploma in Machine Learning & AI

To make your interview preparation easier, we’ve compiled a comprehensive list of frequently asked exception handling interview questions and answers. It includes practical examples and tips to help you demonstrate strong problem-solving skills and write reliable code.

1. What does Exception Handling mean in programming and what are its types?

How to Answer:

• Define exception handling in programming.
• Explain its purpose to handle runtime errors without breaking the application.
• Mention key components in Java (try, catch, finally, throw, throws).
• Highlight its importance in application stability.

Sample Answer:

Exception handling in Java is a reliable mechanism to manage runtime errors so that the normal flow of the application is not disrupted. It enables developers to write error-resilient code by catching and handling exceptions gracefully. Java provides five key constructs for exception handling:

• try: defines a block of code to be tested for errors
• catch: handles the exception
• finally: block that always executes (for cleanup)
• throw: explicitly throws an exception
• throws: declares exceptions a method might throw

There are two main types of exceptions in Java:

• Checked exceptions: Checked at compile-time (e.g., IOException)
• Unchecked exceptions: Subclasses of RuntimeException, not checked at compile-time (e.g., NullPointerException)

Exception handling improves application reliability, maintainability, and user experience, especially in production environments like APIs, file systems, or database operations.

Code Example:

public class Example {
    public static void main(String[] args) {
        try {
            int result = 10 / 0; // ArithmeticException
        } catch (ArithmeticException e) {
            System.out.println("Error: " + e.getMessage());
        } finally {
            System.out.println("Finally block executed");
        }
    }
}

Code Explanation:

• public class Example: This declares a class named Example which contains the main method.
• public static void main(String[] args): The entry point of the Java application.
  • try block:
  • This block contains the risky code. In this case:
     int result = 10 / 0; This will throw an ArithmeticException because division by zero is not allowed in Java.
• catch (ArithmeticException e):
  • This block catches the specific exception that occurs (in this case, ArithmeticException) and prevents the program from crashing.
  • e.getMessage() retrieves the system-defined error message (/ by zero).
• finally block:
  • This block always executes regardless of whether an exception is thrown or not.
  • Typically used for resource cleanup (like closing files, releasing database connections, etc.).
  • In this case, it just prints a message.

Output:
Error: / by zero
Finally block executed

Output Explanation:

• Line 1: Error: / by zero
  • This is printed by the catch block.
  • e.getMessage() returns the specific message for ArithmeticException, which is / by zero.
  • The System.out.println prepends "Error: " to it, resulting in the full message.
• Line 2: Finally block executed
• This is printed by the finally block.
• Since the finally block runs regardless of whether the exception is caught or not, this message is always shown.

2. What is the Difference Between Error and Exception?

How to Answer:

• Begin by defining Error vs Exception and mention that both are subclasses of Throwable.
• Explain the purpose of each Errors and Exceptions
• Break down types: Exceptions → Checked and Unchecked, Errors → Mostly unchecked, e.g., StackOverflowError
• Give clear examples for both categories.
• Mention when and why you should handle Exceptions but not Errors.
• Wrap up by demonstrating a common exception in code (ArrayIndexOutOfBoundsException) and how it is handled using try-catch.

Sample Answer:

In Java, both Error and Exception are subclasses of the Throwable class, but they serve very different purposes. An Error represents serious issues that are beyond the control of the application, typically related to system-level failures like JVM crashes or memory overflow. These are not meant to be caught or handled in code because recovery is usually not possible.

For example, something like an OutOfMemoryError or a StackOverflowError falls under this category.

On the other hand, an Exception represents conditions that the application can handle and recover from. Exceptions are part of the normal program flow when something goes wrong. Exceptions are further divided into two main types:

• Checked exceptions like IOException, which the compiler forces you to either handle or declare using throws.
• Unchecked exceptions like NullPointerException, which are runtime exceptions and typically result from bugs in the code.

So, in short:

• Errors are critical and typically unrecoverable.
• Exceptions are expected issues in a program's logic that we should handle properly to maintain robustness.

Code Example:

public class ErrorVsException {
    public static void main(String[] args) {
        try {
            int[] arr = new int[2];
            System.out.println(arr[5]); // This line throws ArrayIndexOutOfBoundsException
        } catch (Exception e) {
            System.out.println("Handled Exception: " + e);
        }
    }
}

Code Explanation:

• int[] arr = new int[2]; - Creates an array of size 2 (arr[0] and arr[1] are valid).
• Arr[5] - Attempts to access an out-of-bounds index, which throws an ArrayIndexOutOfBoundsException, a runtime (unchecked) exception.
• catch (Exception e) - This catches the exception and prints the exception message instead of crashing the program.

Output Explanation: The output confirms that the exception was caught and handled.

Handled Exception: java.lang.ArrayIndexOutOfBoundsException: 5

• The Exception is a subclass of Throwable, and ArrayIndexOutOfBoundsException is an unchecked exception.
• The index 5 is invalid, and the exception message reflects the specific cause (5 being out-of-bounds).

3. What are Checked and Unchecked Exceptions?

How to Answer:

• Start by defining exceptions as part of Java's exception hierarchy.
• Explain that all exceptions are subclasses of Exception, which itself is a subclass of Throwable.
• Differentiate based on when they're detected:
  • Checked: Caught at compile time.
  • Unchecked: Detected at runtime.
• Mention that checked exceptions require explicit handling, while unchecked exceptions don't.
• Give practical examples for each.
• Conclude with a short code example or explanation.

Sample Answer:

In Java, exceptions are categorized into checked and unchecked based on when they are detected by the compiler.

• Checked exceptions are checked at compile time. The compiler forces you to either handle them using a try-catch block or declare them using the throws keyword. These are typically used for conditions outside the program’s control, like file handling or database access.
  Examples: IOException, SQLException.
• Unchecked exceptions are checked at runtime. These are usually due to programming mistakes like accessing a null object or an invalid array index.
  Examples: NullPointerException, ArithmeticException, ArrayIndexOutOfBoundsException.

In short, checked exceptions ensure that the programmer thinks about error handling during compilation, while unchecked exceptions are more flexible but can crash the application if not handled properly.

Code Example:

import java.io.*;

public class CheckedUnchecked {
    public static void main(String[] args) {
        try {
            FileReader fr = new FileReader("abc.txt"); // Checked Exception
        } catch (FileNotFoundException e) {
            System.out.println("Checked Exception: " + e);
        }

        int[] a = new int[2];
        System.out.println(a[5]); // Unchecked Exception
    }
}

Code Explanation:

• FileReader fr = new FileReader("abc.txt");
  • This attempts to open a file that may not exist.
  • FileNotFoundException is a checked exception, the compiler forces you to handle it.
• catch (FileNotFoundException e)
  • Handles the checked exception and prints a message.
• int[] a = new int[2]; System.out.println(a[5]);
  • This tries to access an invalid array index.
  • ArrayIndexOutOfBoundsException is an unchecked exception, no compiler warning, but crashes at runtime.

Output Explanation (Assuming abc.txt doesn’t exist):

• The first line is printed by the catch block handling the checked exception.
• The second line is thrown by the JVM at runtime due to the unchecked exception, and since it's not caught, it terminates the program.

Checked Exception: java.io.FileNotFoundException: abc.txt (No such file or directory)
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 2

Checked exceptions improve reliability by enforcing error handling at compile time. However, overusing them may clutter the code. Use checked exceptions for recoverable conditions and unchecked for programming logic errors.

4. What is the use of a try-catch block?

How to Answer:

• Start with what a try-catch block is in Java and where it's used.
• Explain its main purpose: to handle exceptions gracefully at runtime.
• Emphasize that it helps prevent application crashes by letting the program recover.
• Mention how the block works:
  • Code that might throw an exception goes inside try.
  • catch handles specific exceptions.
• Optionally mention: You can have multiple catch blocks, and it's commonly used with finally.

Sample Answer: 

The try-catch  is used to handle exceptions that may occur during program execution, particularly at runtime. The goal is to prevent the application from crashing by gracefully handling errors and allowing the program to continue or exit safely.

Here’s how it works:

• The try block contains code that might throw an exception.
• If an exception occurs, control jumps to the catch block, where we can handle it.
• This makes the application more robust, user-friendly, and less likely to fail unexpectedly.

For example, dividing a number by zero would normally crash the program. But with try-catch, we can intercept that and respond accordingly

Code Example:

public class TryCatchExample {
    public static void main(String[] args) {
        try {
            int a = 10 / 0; // Throws ArithmeticException
        } catch (ArithmeticException e) {
            System.out.println("Handled: " + e.getMessage());
        }
    }
}

Code Explanation:

• try block: Attempts to divide 10 by 0, which throws an ArithmeticException.
• catch (ArithmeticException e): Catches the exception and prints a friendly error message.
• Prevents the program from crashing and allows safe recovery.

Output: The exception is caught and the message "/ by zero" (from e.getMessage()) is displayed. If not handled, this would have caused the program to terminate abnormally.

Handled: / by zero

Always catch the most specific exceptions first. Avoid catching generic Exception unless absolutely necessary. This improves clarity and error resolution.

5: What is the purpose of the finally block?

How to Answer:

• Start by defining what the finally block is and where it fits in Java’s exception handling structure.
• Explain its main purpose: to ensure critical code runs no matter what (exception or not).
• Mention that it is often used for resource cleanup like closing files, releasing connections, etc.
• Clarify that it executes after try and catch, regardless of whether an exception occurred.
• Optional: Mention that finally still executes even if there is a return in the try or catch block (except on System.exit()).

Sample Answer:

In Java, the finally block is used to write code that should always be executed, regardless of whether an exception is thrown or caught. It is typically placed after the try and catch blocks and is most commonly used for cleaning up resources, like closing file streams, releasing database connections, or unlocking locks.

One of the key advantages of finally is that it guarantees execution, even if the code in the try or catch block includes a return statement. The only exception to this behavior is if the JVM shuts down abruptly using System.exit() or due to a fatal error.

So, finally block ensures your program leaves resources in a clean state, which is crucial for avoiding memory leaks or corrupted states.

Code Example:

public class FinallyExample {
    public static void main(String[] args) {
        try {
            int a = 10 / 0; // Will throw ArithmeticException
        } catch (ArithmeticException e) {
            System.out.println("Caught: " + e);
        } finally {
            System.out.println("Finally executed");
        }
    }
}

Code Explanation:

• try block: Causes an ArithmeticException by dividing by zero.
• catch block: Catches the exception and prints an error message.
• finally block: Runs after the catch block, no matter what, guaranteeing that the message "Finally executed" is printed.

Output: The first line of the output indicates that the ArithmeticException was successfully caught in the catch block and its details were printed. The second line confirms that the finally block was executed immediately afterward, demonstrating that it runs regardless of whether an exception was thrown or not.

This ensures any cleanup code placed in finally will always be executed, maintaining application stability.

Caught: java.lang.ArithmeticException: / by zero
Finally executed

Use finally to release system resources. It runs even if return is used in try/catch, making it ideal for cleanup logic like file or socket closing.

6. What is the difference between throw and throws?

How to Answer:

• Begin by stating that both Throw and Throws are related to exception handling but serve different purposes.
• throw is used to explicitly throw an exception from a block of code.
• throws is used to declare exceptions a method might throw.
• Mention syntax differences:
  • throw is followed by an exception object.
  • throws is followed by one or more exception class names in the method signature.
• Clarify with a real-life scenario or simple use case

Sample Answer:

throw and throws are both used in exception handling, but they serve different roles.

upGrad’s Exclusive Software and Tech Webinar for you –

SAAS Business – What is So Different?

• throw is used to explicitly throw an exception in your program logic. It is followed by an instance of an exception, and is typically used inside methods or blocks where a specific condition requires interrupting the flow.
• throws is used in a method declaration to indicate that the method might throw one or more exceptions. It serves as a signal to the caller that they should handle or propagate those exceptions.

For example, if a method checks user age and wants to stop execution for underage input, it can throw an exception. That same method may use throws to declare the exception it might throw.

Code Example:

public class ThrowThrows {
    static void validate(int age) throws ArithmeticException {
        if (age < 18) {
            throw new ArithmeticException("Not valid age");
        }
    }

    public static void main(String[] args) {
        try {
            validate(15);
        } catch (ArithmeticException e) {
            System.out.println("Caught: " + e.getMessage());
        }
    }
}

Code Explanation:

• throws ArithmeticException in validate(int age) tells the compiler that this method might throw that exception.
• Inside the method, throw new ArithmeticException(...) is used to actually trigger the exception if the condition is met.
• The main() method wraps the call in a try-catch block to handle that exception.

Output: The output prints the message from the thrown exception: "Caught: Not valid age". This confirms that the exception was explicitly thrown using throw, and properly declared in the method using throws, then caught and handled in the catch block.

Caught: Not valid age

Use throw to trigger exceptions conditionally inside code, and throws to notify the calling method that it must handle or further declare the exception.

Also Read: Top 10 Free Java Courses with Certificates for In-Demand Java Jobs

7. What is a try-with-resources statement?

How to Answer:

• Start by introducing the feature: say it was added in Java 7.
• Explain that it's used for automatic resource management.
• Clarify what “resource” means: any object that implements AutoCloseable (like streams, readers, DB connections).
• Mention that with try-with-resources, resources are closed automatically, avoiding memory leaks and boilerplate finally code.
• Point out that it's safer, cleaner, and preferred over manual closing in finally

Sample Answer:

The try-with-resources statement was introduced in Java 7 to simplify resource management and ensure resources are closed automatically. In Java, a resource refers to an object like a BufferedReader, FileInputStream, or Connection, basically anything that implements the AutoCloseable interface.

When you use such resources inside a try block using try-with-resources, Java guarantees that they will be closed automatically once the try block finishes, whether it ends normally or due to an exception. This eliminates the need for manual finally blocks and helps prevent resource leaks, especially in file handling or database operations.

Code Example:

import java.io.*;

public class TryWithResources {
    public static void main(String[] args) {
        try (BufferedReader br = new BufferedReader(new FileReader("test.txt"))) {
            System.out.println(br.readLine());
        } catch (IOException e) {
            System.out.println("Error: " + e);
        }
    }
}

Code Explanation:

• BufferedReader br = new BufferedReader(...) is declared inside the try() block.
• Since BufferedReader implements AutoCloseable, it will be automatically closed when the block exits.
• No need for a finally block to close the reader manually.
• If test.txt doesn’t exist or any I/O error occurs, the catch block handles it.

Output Explanation (Assuming test.txt has one line "Hello"):

The program reads and prints the first line of the file. The file stream is closed automatically after the try block.

Hello

8. Can we have multiple catch blocks in Java?

How to Answer:

• Start by confirming that Java does support multiple catch blocks.
• Explain that multiple catch blocks allow handling different types of exceptions separately.
• Mention the importance of handling exceptions in order, with the most specific exceptions placed before the more general ones.
• Discuss the purpose of each catch block in catching specific types of exceptions, followed by a general Exception block as a fallback.
• Make sure to explain that the first matching catch block that occurs will be executed, and the others are skipped.

Sample Answer:

Yes, Java allows multiple catch blocks to handle different types of exceptions. This feature is helpful when you need to handle distinct exceptions differently within the same try-catch structure.

The order of the catch blocks is crucial, the most specific exceptions (e.g., ArithmeticException) should come first, followed by the more general exceptions (e.g., Exception), as Java will stop at the first block that matches the thrown exception type.

Code Example:

public class MultiCatch {
    public static void main(String[] args) {
        try {
            int[] arr = new int[5];         // Creates an array of size 5
            arr[5] = 10 / 0;                // ArithmeticException (division by zero) and ArrayIndexOutOfBoundsException (accessing index 5)
        } catch (ArithmeticException e) {
            System.out.println("Arithmetic Exception");  // Handles the division by zero exception
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Array Index Exception");  // Handles the array index out-of-bounds exception
        } catch (Exception e) {
            System.out.println("Generic Exception");      // Handles any other exceptions
        }
    }
}

Code Explanation:

• try Block: The code within the try block is trying two things:
  • Creating an array arr with 5 elements, with valid indices ranging from 0 to 4.
  • Then, it tries to assign a value to arr[5], which is out of bounds (this causes an ArrayIndexOutOfBoundsException), while also trying to divide by zero (10 / 0), which triggers an ArithmeticException.
• catch Blocks:
  • The first catch block catches the ArithmeticException caused by division by zero. This block prints "Arithmetic Exception".
  • The second catch block would catch the ArrayIndexOutOfBoundsException (if it were thrown), but it is skipped in this case because the ArithmeticException was already caught first.
  • The final catch block acts as a fallback for any other exceptions that don't match the previous blocks, but it isn't reached here since the specific exceptions were already caught.

Output Explanation: The program prints "Arithmetic Exception" because the first exception that occurs is the division by zero, which is caught by the catch (ArithmeticException e) block.

Arithmetic Exception

• The ArrayIndexOutOfBoundsException block is not executed because the ArithmeticException is already handled before.
• The general Exception block is also not triggered because the specific exception blocks were matched and handled first.

9. What is the base class of all exceptions in Java?

How to Answer:

• Begin by stating the root of Java’s exception hierarchy: Throwable.
• Explain its two major subclasses: Exception and Error.
• Clarify the purpose of each subclass:
  • Exception: for recoverable issues.
  • Error: for serious problems that should not be caught.
• Emphasize that all exception-handling mechanisms stem from this base

Sample Answer:

In Java, the base class for all exceptions and errors is Throwable. It defines everything that can be thrown using throw and caught using catch.

Throwable has two direct subclasses:

• Exception: Used for all application-level and recoverable issues. These can and should be handled in the code using try-catch blocks.
  Example: IOException, SQLException.
• Error: Represents serious system-level problems that are generally outside the program's control and are not meant to be caught.
  Example: OutOfMemoryError, StackOverflowError.

So while Exception is the base class for most handled exceptions in Java, it's actually Throwable that sits at the top of the hierarchy and is essential for Java's exception handling mechanism.

Class Hierarchy Diagram (Text View):

java.lang.Object
  ↳ java.lang.Throwable
        ↳ java.lang.Exception
            ↳ IOException, SQLException, etc.
        ↳ java.lang.Error
            ↳ OutOfMemoryError, StackOverflowError, etc.

Explanation:

• java.lang.Object
  • The root class of all classes in Java.
  • Every Java class either directly or indirectly inherits from Object.
• java.lang.Throwable
  • The base class for everything that can be thrown or caught in Java.
  • Only subclasses of Throwable can be used with throw and catch.
• Throwable has two main branches:
  • Exception: Application-level issues (can be recovered).
  • Error: Serious problems related to the JVM or system resources (usually unrecoverable)

Real-World Analogy:

• Throwable is like a general category of problems.
• Exception is like a user error: missing input, wrong file, etc., you can catch and fix it.
• Error is like a system crash, your program shouldn’t be responsible for fixing this.

This is important because only classes that extend Throwable can be thrown using the throw keyword and caught using a catch block. The Java compiler enforces this rule to ensure only valid exception types are handled.

10. What happens if there is no catch block and an exception occurs?

How to Answer:

• Start by explaining the default behavior of Java when exceptions are unhandled.
• Mention that the exception will propagate up the call stack.
• State that if no method handles it, the JVM terminates the program.
• Emphasize the role of the exception stack trace for debugging.

Sample Answer:

If an exception occurs and there's no catch block to handle it, Java's runtime environment will try to propagate the exception up the call stack. If none of the calling methods handle it either, the exception eventually reaches the JVM, which then:

• Prints a detailed stack trace showing where the exception occurred.
• Terminates the program abruptly, skipping any code after the point of failure.

This is why it's important to handle exceptions properly to ensure smooth and predictable application behavior.

Code Example:

public class NoCatchBlock {
    public static void main(String[] args) {
        int a = 5 / 0; // no catch block to handle ArithmeticException
        System.out.println("After exception"); // this line will not execute
    }
}

Code Explanation: 

• The division by zero (5 / 0) throws an ArithmeticException.
• Since there’s no try-catch block, the JVM handles it.
• The program prints the stack trace and terminates.
• The JVM terminates the program, skipping the line System.out.println("After exception");, so this line is never executed.

Output: The output shows the exception details:

• The thread name (main).
• The type of exception (ArithmeticException).
• The message (/ by zero).
• The specific location where the exception occurred (NoCatchBlock.java:3).

Exception in thread "main" java.lang.ArithmeticException: / by zero
   at NoCatchBlock.main(NoCatchBlock.java:3)

This demonstrates the importance of properly handling exceptions in order to prevent the abrupt termination of the program and allow for smoother execution.

11. Can we write only a try block without catch or finally?

How to Answer:

• Start by explaining the basic rule: A try block cannot stand alone.
• Clarify that it must be followed by either a catch, a finally, or both.
• Explain the valid combinations.
• Mention the purpose of using try-finally without a catch.

Sample Answer:

No, in Java, you cannot write a try block by itself. A try block must be followed by:

• At least one catch block or
• A finally block or
• Both catch and finally.

If you write a try block without either, the code will result in a compile-time error. However, using try with just a finally block is legal and often used when you want to guarantee resource cleanup even if an exception occurs and you don't want to handle it directly.

Code Example:

public class TryWithoutCatch {
    public static void main(String[] args) {
        try {
            int result = 10 / 0; // Exception occurs
        } finally {
            System.out.println("Finally block executed");
        }
    }
}

Code Explanation: 

• 10 / 0 throws an ArithmeticException.
• There's no catch, so the exception is not handled.
• The finally block still executes.
• Once finally block executes, the JVM terminates the program with the unhandled exception.

Output: 

• First line ("Finally block executed"): The finally block is executed regardless of the exception. This ensures that any necessary cleanup code runs before the program terminates.
• Second part (stack trace): The program prints the details of the exception (ArithmeticException: / by zero), which shows:
• The type of exception (ArithmeticException).
• The specific error message (/ by zero).
• The exact line number in the code (TryWithoutCatch.java:3) where the exception occurred.
• Program termination: Since the exception is unhandled (no catch block), the program terminates, and no further code (such as System.out.println("After exception");) is executed.

Finally block executed
Exception in thread "main" java.lang.ArithmeticException: / by zero

12. Can we catch multiple exceptions in a single catch block?

How to Answer:

• Mention that this feature was introduced in Java 7.
• Explain the use of the pipe (|) operator.
• Note that all caught exceptions must be unrelated types (i.e., not part of the same inheritance path).

Sample Answer:

Yes, from Java 7 onwards, you can catch multiple exceptions in a single catch block using the pipe (|) symbol. This is known as multi-catch and is useful when different exceptions require the same handling logic. For example: catch (IOException | SQLException e)

• The exception types must be unrelated (no parent-child relationship).
• The exception variable (e) is effectively final, you can’t assign a new value to it inside the block.

This approach helps reduce code duplication and makes the code cleaner."

Code:

public class MultiCatchBlock {
    public static void main(String[] args) {
        try {
            String text = null;
            System.out.println(text.length()); // NullPointerException
        } catch (NullPointerException | ArithmeticException e) {
            System.out.println("Caught Exception: " + e);
        }
    }
}

Code Explanation: 

• text.length() throws a NullPointerException.
• Since the exception matches one of the specified types in the multi-catch, it's handled properly.
• The pipe operator allows multiple exception types to be grouped together with shared logic.

Output:

“Caught Exception: java.lang.NullPointerException”: The NullPointerException is thrown because we try to invoke the length() method on a null reference. The catch block successfully catches the exception and prints the message "Caught Exception: " followed by the exception's class name (java.lang.NullPointerException).

Caught Exception: java.lang.NullPointerException

The multi-catch block catches the NullPointerException and executes the logic, printing the exception details. If an ArithmeticException had occurred, it would also be caught by the same block, but here, only the NullPointerException is thrown and handled.

Looking to excel in exception handling in JavaScript? Begin with upGrad's JavaScript Basics from Scratch Course. You'll lay a strong base in key concepts like variables, data types and functions. Enroll now and acquire the core skills to succeed in coding!

13. What is exception propagation?

How to Answer:

• Define exception propagation.
• Explain how exceptions move up the call stack if not handled.
• Mention that the JVM terminates the program if no method handles it.
• Use an example with multiple method calls.

Sample Answer:

Exception propagation refers to the process where an exception moves up the method call stack until it is caught or reaches the JVM.

• If a method throws an exception and doesn't handle it with a try-catch, the exception is automatically passed to the caller.
• This continues until the exception is either caught or reaches the main method.
• If still unhandled, the JVM will print the stack trace and terminate the program.

This is useful when you want to handle exceptions at a higher level instead of in every method.

Code: 

public class ExceptionPropagation {
    static void methodA() {
        int result = 10 / 0; // Throws ArithmeticException
    }

    static void methodB() {
        methodA(); // Doesn't handle
    }

    public static void main(String[] args) {
        methodB(); // Doesn't handle
    }
}

Code Explanation:

• Line 3 (methodA()): The methodA() method performs a division by zero (10 / 0), which throws an ArithmeticException.
• Line 7 (methodB()): The methodB() method calls methodA() but doesn't handle the exception.
• Line 11 (methodB() in main()): The main() method calls methodB(), which in turn calls methodA(). Since no method handles the exception (no catch block), the exception propagates up the call stack.
• Exception Propagation: The ArithmeticException starts in methodA() and is passed to methodB(), then to main(), and finally, since no one handles it, the exception reaches the JVM.
• JVM handles it: The JVM prints the stack trace and terminates the program.

Output:

• ArithmeticException: / by zero: The exception message specifies the type of error (ArithmeticException) and the cause (/ by zero).
• Stack Trace: The stack trace provides detailed information about the call stack:
  • The exception occurred in methodA() at line 3.
  • It propagated to methodB() at line 7.
  • Finally, it reached main() at line 11.
• Program termination: Since no method caught the exception, the JVM terminates the program after printing the stack trace.

Exception in thread "main" java.lang.ArithmeticException: / by zero
   at ExceptionPropagation.methodA(ExceptionPropagation.java:3)
   at ExceptionPropagation.methodB(ExceptionPropagation.java:7)
   at ExceptionPropagation.main(ExceptionPropagation.java:11)

Also Read: Exception Handling in Python: Handling Exception Using Try Except

14. Can we rethrow an exception in Java? If so, how?

How to Answer:

• Yes, you can rethrow exceptions after catching them.
• Useful when you want to log, wrap, or modify the exception before rethrowing.
• You can either rethrow the same exception or a new one.

Sample Answer:

Yes, Java allows rethrowing an exception from a catch block. This means after catching and possibly logging or processing an exception, you can pass it on for further handling. You can rethrow the same exception, or throw a new custom exception (often wrapping the original).

This is often used in layered applications where exceptions are caught in lower layers but should be handled by upper layers.

Code: 

public class RethrowExample {
    public static void main(String[] args) {
        try {
            throw new NullPointerException("Original exception");
        } catch (NullPointerException e) {
            System.out.println("Logging: " + e.getMessage());
            throw e; // Rethrowing
        }
    }
}

Code Explantion:

• Line 3 (throw new NullPointerException("Original exception");): A NullPointerException is explicitly thrown with the message "Original exception".
• Line 6 (catch (NullPointerException e)): The catch block catches the NullPointerException.
• Line 7 (System.out.println("Logging: " + e.getMessage());): The exception message is logged by printing "Logging: Original exception".
• Line 8 (throw e;): The exception e is rethrown after logging. This sends the exception back up the call stack, allowing higher layers to handle it or further process it if necessary.
• Rethrowing: Rethrowing is useful when you want to perform some action (like logging) and then allow the exception to propagate further for handling at a higher level.

Output:

• "Logging: Original exception": This message is printed because the exception is caught and its message is logged.
• NullPointerException thrown again: After logging, the exception is rethrown, and it causes the program to terminate. The stack trace includes the rethrown NullPointerException, showing where the exception originated (main method), with the message "Original exception".

Logging: Original exception
Exception in thread "main" java.lang.NullPointerException: Original exception

This demonstrates how the exception is propagated after being rethrown.

Also Read: 50 Java Projects With Source Code in 2025: From Beginner to Advanced 

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

How to Answer:

• Clarify that these are three different constructs with distinct purposes.
• Give simple definitions and typical use cases.
• Add one-line code hints for illustration.

Sample Answer:

In Java, final, finally, and finalize are three distinct concepts, and here's how they differ:

• Final: It's a keyword used for different purposes:
  • To define constants (e.g., final int MAX = 100;).
  • To prevent method overriding (e.g., public final void myMethod() {}).
  • To prevent class inheritance (e.g., public final class MyClass {}).
  • Example:

final int x = 10;  // x cannot be reassigned

• Finally: It's a block used in exception handling. The finally block always executes, whether an exception is thrown or not, and is typically used for resource cleanup (like closing files or database connections).
  • Example:

try {
    // Code that might throw an exception
} finally {
    // Always runs, for cleanup
    System.out.println("This will always execute.");
}

• finalize(): This is a method in the Object class that was meant to be called by the garbage collector before an object is reclaimed. It’s rarely used now and was deprecated starting from Java 9 due to better resource management techniques like try-with-resources.
  • Example:

@Override
protected void finalize() throws Throwable {
    // Cleanup code before garbage collection
}

Each of these plays a very different role in Java, so it's important to understand when and why to use them in your code.

Code Snippet (Combined):

final int x = 10; // final keyword

try {
    int a = 5 / 0;
} finally {
    System.out.println("This always executes"); // finally block
}

@Override
protected void finalize() throws Throwable {
    System.out.println("Finalize called"); // finalize method
}

Code Explanation:

• final int x = 10;: The final keyword makes the variable x constant, so its value cannot be reassigned.
• try-catch-finally block: The try block throws an ArithmeticException (due to 5 / 0), but the finally block always executes, printing "This always executes".
• finalize() method: This method is called by the garbage collector before an object is destroyed. Here, it prints "Finalize called", but it won't be called unless garbage collection occurs, which is unlikely in this example.

Output:

• “This always executes": The finally block executes no matter what, even if an exception occurs.
• "Finalize called": The finalize() method is not triggered in this example since garbage collection does not occur.

This always executes

This concludes our exploration of essential exception handling interview questions and answers, relevant for freshers  aiming to strengthen their technical proficiency.

Level up your coding and programming skills with upGrad’s Generative AI Mastery Certificate for Software Development. Learn to integrate generative AI into your projects, build smarter apps, and gain in-demand skills through hands-on learning.

Let’s now move on to advanced exception handling concepts with questions designed specifically for experienced professionals and practical scenarios.

Exception Handling Interview Questions and Answers for Experienced 

Exception handling is a key skill in software development interviews, especially for roles involving Java, Python, or C#. Interviewers often test your understanding of concepts like custom exceptions, exception propagation, and error handling patterns.

Here are a few exception handling interview questions and answers for experienced candidates. It covers advanced topics with clear code examples, outputs, and detailed explanations to help you prepare effectively.

16. How do you handle exceptions in a layered architecture?

How to Answer:

• Explain how exceptions are handled at different layers (Controller, Service, DAO).
• Describe propagation vs handling strategies.
• Mention use of global exception handlers.

Sample Answer: 

In a layered architecture (like MVC), follow a bottom-up exception propagation strategy where exceptions thrown in lower layers (e.g., DAO) bubble up to higher layers (e.g., Service, Controller). Each layer can either handle the exception or propagate it further wrapped in a custom exception.

At the controller level (especially in Spring Boot), use @ControllerAdvice to globally handle exceptions and return structured error responses using @ExceptionHandler.

This keeps the controller clean and separates concerns while ensuring consistent error responses.

Code Example:

@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(ResourceNotFoundException.class)
    public ResponseEntity<ErrorResponse> handleNotFound(ResourceNotFoundException ex) {
        ErrorResponse error = new ErrorResponse("NOT_FOUND", ex.getMessage());
        return new ResponseEntity<>(error, HttpStatus.NOT_FOUND);
    }
}

Code Explanation:

• @RestControllerAdvice marks this class as a centralized exception handler for all controllers.
• The @ExceptionHandler annotation maps specific exceptions (like ResourceNotFoundException) to handler methods.
• The method constructs a custom ErrorResponse object and returns it with an appropriate HTTP status.

Output:

• If a controller throws a ResourceNotFoundException, the exception is intercepted by the GlobalExceptionHandler.
• The handler returns a consistent JSON response with an error code and message instead of exposing internal stack traces.
• This improves user experience and maintains security by hiding internal exception details.

{
  "errorCode": "NOT_FOUND",
  "message": "Resource with ID 123 not found"
}

17. What is exception chaining in Java, and how does it help in propagating and translating exceptions across layers?

How to Answer:

• Start by defining exception chaining.
• Explain when and why to use it.
• Describe how to preserve the original stack trace.

Sample Answer:

Exception chaining is a technique in Java where an exception is wrapped or "chained" inside another exception. This allows you to propagate the original exception's cause while throwing a new, more specific exception. It preserves the root cause and stack trace, making it easier to debug the issue later.

Exception chaining is useful when you want to translate lower-level exceptions (like SQLException) into higher-level domain-specific exceptions (like DataAccessException) while still keeping the original exception information for debugging.

• When and Why to Use It:
  • In layered systems, different layers might throw different types of exceptions, and the higher layers might not understand lower-level exceptions. In such cases, exception chaining helps by wrapping the lower-level exceptions into more meaningful exceptions for the upper layers.
  • It preserves the original exception details, helping developers track down the root cause of issues.
• How to Preserve the Original Stack Trace: The original exception is passed as the second argument when creating the new exception, ensuring that the stack trace and cause are preserved.

Code Example:

public class ServiceLayer {
    public void process() {
        try {
            dao.fetchData();
        } catch (SQLException e) {
            throw new DataAccessException("Error fetching data", e);
        }
    }
}

Code Explanation:

• dao.fetchData(): This line calls a method from the Data Access Object (DAO) class to fetch data from the database. If a SQLException occurs, it is caught in the catch block.
• catch (SQLException e): When an exception like SQLException is caught, it is not directly rethrown. Instead, a new, more meaningful exception (DataAccessException) is thrown with a custom message "Error fetching data".
• throw new DataAccessException("Error fetching data", e): The SQLException (e) is passed as the second argument to the constructor of DataAccessException.
• DataAccessException constructor: The constructor of DataAccessException accepts a message and the original exception (cause).
• It passes them to the superclass (Exception) to maintain the original stack trace and cause.

Output Explanation:

• DataAccessException: The new exception (DataAccessException) is thrown, with its own message "Error fetching data".
• Caused by: The Caused by section shows the original exception (SQLException), and the stack trace for it. The SQLException details help pinpoint the root cause of the problem, in this case, something related to the database connection.
• Stack Trace: The stack trace shows both exceptions (DataAccessException and SQLException), which provides a clear path for debugging the problem.

DataAccessException: Error fetching data
   at ServiceLayer.process(ServiceLayer.java:5)
   Caused by: java.sql.SQLException: Database connection error
   at Dao.fetchData(Dao.java:10)
   at ServiceLayer.process(ServiceLayer.java:4)

18. How do you log exceptions in a scalable system?

How to Answer:

• Mention structured logging.
• Use of tools like Log4j, SLF4J, or centralized systems like ELK, Sentry.

Sample Answer:

In scalable systems, exception logging should be structured, centralized, and efficient. Instead of plain text logs, structured logging (often in JSON format) is used to include rich metadata like timestamps, log levels, request IDs, and exception types. This makes it easier to aggregate and analyze logs across distributed services.

• Use frameworks like SLF4J with Logback or Log4j2 for consistent logging.
• Apply log levels appropriately: ERROR for exceptions, INFO for key business actions, and DEBUG for detailed traces.
• Integrate with centralized logging systems like ELK (Elasticsearch, Logstash, Kibana), Sentry, or Fluentd for real-time monitoring and alerting.

To maintain performance and observability, logs should be non-blocking, sanitized, and traceable across services. Asynchronous appenders can prevent logging from slowing down the application. Including correlation IDs helps trace logs through microservices during debugging or incident analysis.

• Avoid logging sensitive data; use masking or redaction.
• Use correlation IDs to trace requests across services.
• Enable log rotation and set retention policies to manage storage efficiently.

Code Example:

private static final Logger logger = LoggerFactory.getLogger(MyService.class);

try {
    // some logic
} catch (Exception e) {
    logger.error("Error occurred while processing orderId={} ", orderId, e);
    throw e;
}

19. Explain the use of custom exception hierarchies.

How to Answer:

• Explain grouping related exceptions using inheritance.
• Improves code readability and exception handling logic.

Sample Answer: 

Custom exception hierarchies are used to group related exceptions by extending a common base class. This approach improves code clarity, simplifies error handling, and supports both broad exception catching and fine-grained control. It also allows higher layers of the application to handle categories of errors uniformly while still supporting specific behaviors.

• Define a base exception (e.g., ApplicationException) for the application domain.
• Extend it to create specific types like ValidationException, AuthorizationException, BusinessRuleException, etc.
• Catch the base type when general handling is enough, or catch the specific type for custom responses or logging.

Code Example:

public class ApplicationException extends RuntimeException {
    public ApplicationException(String message) {
        super(message);
    }
}

public class ValidationException extends ApplicationException {
    public ValidationException(String message) {
        super(message);
    }
}

Code Explanation:

The provided Java code defines a simple custom exception hierarchy:

• ApplicationException: This is the base custom exception class. It extends Java's built-in RuntimeException, making it an unchecked exception. It has a single constructor that accepts an error message.
• ValidationException: This is a more specific exception that extends ApplicationException. It represents an error related to data validation. It also has a constructor that passes the error message up to its parent, ApplicationException.

Output: When the Main class is run, the createUser method will be called with an empty string. This triggers the ValidationException. The try-catch block will then catch this specific exception.

Validation Error: Username cannot be empty.

If another type of error inheriting from ApplicationException were thrown, and there wasn't a specific catch for it, the more general catch (ApplicationException e) block would handle it. This structure provides both specific and general error-handling capabilities.

20. How is exception handling different in Java compared to Python or C++?

How to Answer:

• Compare compile-time vs runtime exception models.
• Mention checked exceptions in Java.
• Explain Python’s dynamic nature.

Sample Answer: 

• Java has both checked and unchecked exceptions, enforcing compile-time handling for certain exception types. This can improve robustness but adds verbosity.
• Python, on the other hand, only has runtime exceptions, there’s no enforcement at compile-time. Developers must be disciplined in using try-except blocks.
• C++ allows exceptions but discourages their use in performance-critical code. It also uses RAII for resource management rather than finally blocks or try-with-resources.

21. How to handle exceptions in REST APIs (Spring Boot, etc.)

How to Answer:

• State why exception handling is important, to provide clear, consistent error responses to RESTful APIs clients.
• Mention controller-level and global exception handling, custom resolvers, and error controllers.
• Stress the importance of structured responses and appropriate HTTP status codes.
• Focus on the most common and effective approaches (global handlers with @RestControllerAdvice).

Sample Answer:

Exception handling in Spring Boot REST APIs is crucial for delivering consistent, informative error messages to clients. Use @ExceptionHandler for controller-specific logic, and @RestControllerAdvice (or @ControllerAdvice) for global handling, allowing centralized management of exceptions across all controllers.

This approach wraps exceptions in structured responses (e.g., JSON), includes relevant HTTP status codes, and helps clients understand and resolve issues efficiently. For advanced scenarios, extend ResponseEntityExceptionHandler or implement custom resolvers and error controllers

Code:

@RestControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler(ResourceNotFoundException.class)
    @ResponseStatus(HttpStatus.NOT_FOUND)
    public ErrorResponse handleResourceNotFound(ResourceNotFoundException ex) {
        return new ErrorResponse("Not Found", ex.getMessage());
    }
}

Code Explanation: This global exception handler catches all ResourceNotFoundException thrown by any controller and returns a 404 status with a custom error message.

Output Example: The client receives a structured JSON response with clear error information, making it easier to handle errors programmatically.

{
  "error": "Not Found",
  "message": "Resource was not found"
}

22. What is the impact of exception handling on performance?

How to Answer:

• Briefly explain why exception handling is important in Java and Spring Boot applications.
• Discuss how exceptions impact application performance, focusing on the cost of creating and handling exceptions, especially with stack traces.
• Emphasize that exceptions disrupt normal control flow, which can be expensive for the JVM and CPU.
• Recommend not using exceptions for control flow and highlight when to use checked vs. unchecked exceptions.
• Keep the answer focused and to the point, suitable for an interview.

Sample Answer:

Exception handling is essential for robust applications, but it can impact performance. In Java, creating exception objects, especially with stack traces, is expensive because it gathers and stores detailed execution information. Handling exceptions also disrupts the normal control flow, which can reduce CPU efficiency and slow down execution.

For optimal performance, avoid using exceptions for control flow; instead, use them only for truly exceptional conditions. Prefer unchecked exceptions for business logic and checked exceptions for external API or I/O operations. Logging stack traces should be limited to critical errors to minimize overhead.

23. How do you design a reliable exception handling strategy?

How to Answer:

• Emphasize that reliable exception handling ensures system reliability, clear error communication, and graceful recovery.
• Highlight structured planning, separation of concerns, and use of design patterns.
• Explain systematic approaches like failure hypothesis specification, handler design, and error recovery.
• Stress specificity in exceptions, avoiding silent failures, and leveraging modern techniques.

Sample Answer:

Designing a reliable exception handling strategy involves several key steps:

• Identify potential points of failure in the application, such as invalid input, network issues, or database errors, and document these scenarios.
• Use specific exception types rather than generic exceptions to enable targeted and precise error handling.
• Separate exception handling logic from business logic by using dedicated classes or aspects, which helps keep code clean and maintainable.
• Apply design patterns where appropriate, for example, the Special Case pattern can be used to return default objects instead of throwing exceptions for common cases.
• Implement cleanup and retry mechanisms, such as using try-with-resources for resource management and retrying transient errors automatically.
• Log errors and monitor them to track recurring issues and support ongoing system improvements.

This approach helps ensure the application remains reliable, user-friendly, and easy to maintain.

Example Implementation:

// Special Case Pattern: Handle missing users gracefully  
public class UserRepository {  
    public User findUser(String id) {  
        User user = fetchFromDB(id);  
        return (user != null) ? user : new NullUser();  
    }  
}  

Code Explanation: This code demonstrates the Special Case Pattern.

• UserRepository is responsible for fetching user data.
• findUser method checks if a user exists in the database.
• If the user is not found (null), it returns a NullUser object instead of throwing an exception.
• NullUser is a subclass or implementation of User that provides default or safe behavior, preventing NullPointerException and allowing the application to continue running smoothly.

Output: Clients receive a NullUser object (with default values) instead of encountering a NullPointerException, ensuring uninterrupted flow.

24. What is the role of exception handling in multithreading?

How to Answer:

• Briefly explain what multithreading is and why exception handling is important within it.
• Clarify how exception handling ensures stability and reliability in concurrent environments.
• Point out specific issues in multithreaded contexts, such as thread termination and synchronization.

Sample Answer:

• Multithreading enables concurrent execution of tasks, improving application performance and responsiveness.
• Exception handling in multithreaded environments ensures that errors in one thread do not crash the entire application, maintaining overall stability and reliability.
• If an exception is uncaught in a thread, that thread may terminate, but other threads continue running. This can affect application state or resource consistency if not managed properly.
• Special attention is needed for synchronization, exception handling must coordinate with thread management to prevent race conditions and ensure shared resources are not left in an inconsistent state.

Code:

ExecutorService executor = Executors.newFixedThreadPool(2);
executor.submit(() -> {
    try {
        // Simulate error
        int result = 10 / 0;
    } catch (Exception e) {
        // Log and handle exception
        System.out.println("Exception in thread: " + e.getMessage());
    }
});

Code Explanation:

• ExecutorService executor = Executors.newFixedThreadPool(2); : Creates a thread pool with 2 threads to execute tasks concurrently.
• executor.submit(() -> { ... }); : Submits a task (as a lambda) to be executed by one of the threads in the pool.
• try { ... } catch (Exception e) { ... }
  • The task code is wrapped in a try-catch block.
  • int result = 10 / 0; : Simulates an error by attempting to divide by zero, which throws an ArithmeticException.
• System.out.println("Exception in thread: " + e.getMessage()); Catches the exception, prints the error message, and handles it gracefully within the thread. This prevents the thread from terminating unexpectedly and keeps the thread pool alive.

Output and Explanation:

• The output shows that an exception occurred inside the thread.
• The thread catches the exception and prints the error message, allowing the application to continue running other tasks.
• This approach ensures robust exception handling in multithreaded environments, maintaining application stability even when individual tasks fail.

Exception in thread: / by zero

25. What are suppressed exceptions in Java, and how are they handled during resource cleanup?

How to Answer:

• Briefly explain what suppressed exceptions are.
• Mention when suppressed exceptions typically occur, such as in try-with-resources or finally blocks.
• Clarify why suppressed exceptions are useful in Java.
• Mention how to access them: Note the methods available to retrieve suppressed exceptions.

Sample Answer:

• Suppressed exceptions are exceptions that occur but are not thrown directly because another exception is already being thrown.
• They typically happen when:
  • An exception is thrown inside a try block.
  • Another exception occurs in a finally block or during resource closing (for example, with try-with-resources).
• Instead of losing the secondary exception, Java records it as a suppressed exception within the primary exception.
• This feature is especially useful for working with resources that implement AutoCloseable, ensuring cleanup errors do not hide the original problem.
• Suppressed exceptions can be accessed using the getSuppressed() method on the primary exception, allowing for detailed error analysis and logging.

26. Why do you use the printStackTrace() method?

How to Answer:

• Begin by stating the purpose of printStackTrace().
• Clarify why and when this method is typically used.
• Mention what kind of information it provides and how it helps developers.
• Emphasize its value in debugging and error resolution.

Sample Answer:

• The printStackTrace() method prints the stack trace of an exception to the standard error stream.
• It is used primarily for debugging, as it provides detailed information about where an exception occurred, including:
  • The exception type and message.
  • The sequence of method calls leading to the error.
  • The class name, method name, and line number where the exception was thrown.
• This detailed output helps developers quickly identify the root cause of an error and fix it efficiently.
• In summary, printStackTrace() is a crucial tool for diagnosing exceptions and improving application reliability during development and troubleshooting.

Code:

public class ExceptionExample {
    public static void main(String[] args) {
        try {
            int result = 10 / 0;
        } catch (ArithmeticException e) {
            e.printStackTrace();
        }
    }
}

Code Explanation: 

• The code creates a simple Java class named ExceptionExample.
• Inside the main method: The code attempts to divide 10 by 0, which throws an ArithmeticException.
• The exception is caught in a catch block.
• The printStackTrace() method is called on the caught exception object.
• This method prints the stack trace to the standard error stream, showing the sequence of method calls that led to the exception.

Output:

• The output starts with the exception type and message:
  • java.lang.ArithmeticException: / by zero
  • This tells you what kind of error occurred and why.
• The next line shows the stack trace:
  • at ExceptionExample.main(ExceptionExample.java:4)
  • This indicates the method and line number where the exception was thrown.
• The stack trace helps developers quickly locate the source of the error in their code, making debugging much easier.

java.lang.ArithmeticException: / by zero
   at ExceptionExample.main(ExceptionExample.java:4)

27. Which class is defined as a super class for all types of errors and exceptions in Java?

How to Answer:

• Start with the definition of superclass for all errors and exceptions in Java.
• Briefly explain its role in the Java exception hierarchy.
• Mention the main types of subclasses (Error and Exception).
• Summarize importance by emphasize why this class is foundational for exception handling.

Sample Answer:

• The superclass for all errors and exceptions in Java is the java.lang.Throwable class. It serves as the root of the Java exception hierarchy, meaning every exception and error type inherits from Throwable either directly or indirectly.
• Throwable sits at the root of the Java exception hierarchy, that means every error and exception in Java is a subclass of Throwable. It has two main subclasses:
  • Error: Represents serious problems that applications should not try to catch.
  • Exception: Represents conditions that applications might want to catch.
• This structure allows Java programs to handle and manage errors and exceptions in a consistent and organized way.

Code Example:

try {
    int result = 30 / 0;
} catch (Throwable e) {
    System.out.println("Caught: " + e.getClass().getName());
    e.printStackTrace();
}

Code Explanation: 

This code catches any error or exception (since all are subclasses of Throwable) and prints its class name and stack trace.

Output: The output shows that an ArithmeticException was caught, demonstrating that all exceptions extend from Throwable.

Caught: java.lang.ArithmeticException
java.lang.ArithmeticException: / by zero
   at Main.main(Main.java:8)

28. Is it okay to ignore exceptions? What are the risks and best practices?

How to Answer:

• Begin with a direct response and state whether exceptions can be ignored or not.
• Describe what happens if exceptions are ignored.
• Highlight why ignoring exceptions is discouraged and how to handle them properly.
• Emphasize the importance of handling exceptions for application stability.

Sample Answer:

Technically, exceptions can be ignored by catching them and not taking any action, but this is strongly discouraged. Ignoring exceptions can lead to hidden bugs, inconsistent application state, and unpredictable behavior. In practical scenarios, ignoring exceptions can lead to data corruption, lost transactions, or issues that are difficult to debug.

Best practices include:

• Logging exceptions so developers are aware of issues.
• Recovering from exceptions when possible, or rethrowing them to let higher-level code decide how to handle them.
• Using static code analysis tools to detect and warn about ignored exceptions.
• Conducting code reviews to ensure exceptions are properly handled.

Proper exception handling improves application reliability, maintainability, and helps in debugging.

Code Example:

try {
    int result = 10 / 0;
} catch (ArithmeticException e) {
    // Exception ignored - not recommended
}

Code Explanation: 

• The code attempts to perform a division:
  • The line int result = 10 / 0; tries to divide 10 by 0, which is mathematically undefined and will throw an ArithmeticException in Java.
• Exception handling:
  • The try block contains the risky operation that could throw an exception.
  • The catch block catches the ArithmeticException if it occurs.
• Ignoring the exception:
  • Inside the catch block, there is no code to log, print, or handle the exception.
  • This means the exception is effectively ignored, and the program continues execution without any indication that an error occurred.

Output: There is no output or error message displayed.

Since the exception is caught but not handled or reported, the program does not show any indication that an error occurred. This can make it difficult to detect and diagnose problems during development or in production environments.

29. What are the best practices for implementing global exception handling in Java applications?

How to Answer:

• Start by explaining why global exception handling is important for reliable Java applications.
• Highlight key strategies and tools available for global exception handling.
• Describe how to implement these practices using Java features or frameworks.
• Emphasis the value of providing clear, consistent error responses and not exposing internal details.

Sample Answer:

Global exception handling is essential for maintaining application stability and providing consistent error responses to users or clients.

Best practices for global exception handling include:

• Use a global exception handler: Implement a central handler using annotations like @ControllerAdvice in Spring or by defining a class that implements Thread.UncaughtExceptionHandler for uncaught exceptions.
• Log exceptions appropriately: Ensure all exceptions are logged for debugging and monitoring, but avoid logging sensitive data.
• Provide meaningful error messages: Return clear, informative, and user-friendly error messages without exposing internal implementation details.
• Maintain consistent error responses: Structure error responses uniformly across the application, especially in REST APIs, to make error handling predictable for clients.
• Avoid manual resource closing: Use try-with-resources for automatic resource management, reducing the risk of resource leaks and simplifying exception handling.
• Handle checked and unchecked exceptions: Ensure both are addressed, either by catching or by providing a fallback mechanism in the global handler.

These practices help ensure the application is robust, maintainable, and user-friendly, even in the face of unexpected errors.

Code Example:

@ControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler(Exception.class)
    public ResponseEntity<String> handleException(Exception ex) {
        return new ResponseEntity<>("An error occurred: " + ex.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
    }
}

Code Explanation: 

• @ControllerAdvice Annotation:
  • This annotation marks the class as a global exception handler for all controllers in a Spring application.
  • It ensures that any exception thrown by any controller method can be intercepted and handled here.
• @ExceptionHandler(Exception.class) Method:
  • This annotation specifies that the method should handle all exceptions of type Exception (or its subclasses).
  • It acts as the central point for catching exceptions that are not handled elsewhere in the application.
• Method Logic:
  • The method takes the caught exception as a parameter.
  • It constructs a ResponseEntity object, which is used in Spring to represent an HTTP response.
  • The response includes a user-friendly error message and sets the HTTP status code to INTERNAL_SERVER_ERROR (500).

Output: All unhandled exceptions are intercepted and converted into a consistent JSON error response, making it easier for clients to understand and handle errors.

{
  "message": "An error occurred: NullPointerException: null",
  "status": "INTERNAL_SERVER_ERROR"
}

30. Real-time scenario: How did you handle a production issue caused by an uncaught exception?

How to Answer:

• Begin with context: Briefly describe the situation or application where the issue occurred.
• Explain the problem: State what went wrong and how the uncaught exception manifested.
• Detail your response: Outline the steps taken to diagnose and resolve the issue.
• Highlight improvements: Mention any changes made to prevent future occurrences.
• Summarize the impact: Emphasize the value of the solution and lessons learned.

Sample Answer:

Follow these simple steps to answer the question:

• Context: While working on a production Java web application, a sudden crash was reported.
• Problem:
  • The application terminated unexpectedly during a critical operation.
  • Investigation revealed an uncaught exception was thrown, bypassing all local exception handlers.
• Response:
  • Reviewed logs and stack traces to identify the root cause and the specific method where the exception originated.
  • Implemented a global exception handler using @ControllerAdvice to catch and log all unhandled exceptions, preventing application crashes.
  • Added detailed logging to capture exceptions, including relevant context and user actions.
• Improvements:
  • Updated the codebase to catch exceptions closer to the source where possible.
  • Enhanced monitoring and alerting to notify the team of unhandled exceptions in real time.
• Impact:
  • The application became more robust and reliable, with clear visibility into errors.
  • Downtime was reduced, and future issues could be diagnosed and fixed more quickly.

31. How do tools like Sentry, Log4j, or ELK help in exception tracking and alerting?

How to Answer:

• Start by explaining why tools like Sentry, Log4j, and ELK are important for exception tracking and alerting.
• Briefly state what each tool does and how it fits into the monitoring and alerting workflow.
• Mention how these tools can be integrated and what specific features they offer for error tracking.
• Emphasize the value these tools bring to application stability and developer productivity.

Sample Answer:

Sentry, Log4j, and ELK are widely used tools that help teams track exceptions and receive alerts when errors occur.

• Sentry:
  • Provides real-time error tracking and alerting for application-level issues.
  • Captures detailed context, stack traces, and user actions for each error, making it easier to diagnose and fix problems.
  • Integrates with various platforms and sends alerts via email, Slack, or other channels.
• Log4j:
  • Is a flexible logging framework for Java applications.
  • Can be configured to log exceptions with different severity levels and send logs to various destinations.
  • Supports integrations with monitoring tools like Sentry via appenders, so logged exceptions are automatically sent for tracking and alerting.
• ELK (Elasticsearch, Logstash, Kibana):
  • Aggregates logs from multiple sources and provides powerful search and visualization capabilities.
  • Enables teams to set up custom alerts and dashboards to monitor application health and detect exceptions in real time.

These tools complement each other:

• Sentry focuses on actionable error tracking and alerting for developers.
• Log4j provides robust logging at the application level.
• ELK offers centralized log management and analytics for infrastructure and application logs.
• Using these tools together improves exception visibility, speeds up troubleshooting, and enhances application reliability.

Code Example:

<!-- Log4j2 configuration for Sentry integration -->
<Configuration status="warn">
  <Appenders>
    <Sentry name="SentryAppender" dsn="https://examplePublicKey@o0.ingest.sentry.io/0">
      <PatternLayout pattern="%m%n"/>
    </Sentry>
  </Appenders>
  <Loggers>
    <Root level="error">
      <AppenderRef ref="SentryAppender"/>
    </Root>
  </Loggers>
</Configuration>

Code Explanation: 

• Log4j2 Configuration: This XML file configures Log4j2, a popular Java logging framework.
• Sentry Appender:
  • The <Sentry> tag defines an appender that sends log events to Sentry, an error tracking service.
  • The dsn attribute contains the unique URL (Data Source Name) for your Sentry project.
  • The <PatternLayout> specifies how log messages should be formatted before being sent to Sentry.
• Logger Setup:
  • The <Root> tag sets the minimum log level to error, so only error-level logs (including exceptions) are sent to Sentry.
  • The <AppenderRef ref="SentryAppender"/> links the Sentry appender to the root logger.

This setup ensures that any exception or error logged in the application is automatically forwarded to Sentry for centralized tracking and alerting.

Output Example:

• When an exception occurs in the application:

ERROR [main] Exception in thread "main" java.lang.NullPointerException: null
   at com.example.Main.main(Main.java:10)

• In Sentry dashboard:
  • Event Summary: NullPointerException: null
  • Stack Trace:

Exception in thread "main" java.lang.NullPointerException: null
    at com.example.Main.main(Main.java:10)

• Application Log: The application logs the exception with the ERROR level.
• Sentry Integration: Log4j2 forwards this log entry to Sentry as an event.
• Sentry Dashboard:
  • Sentry aggregates the error, displays the stack trace, and provides context such as user, request, and environment.
  • Alerts can be configured to notify the team via email, Slack, or other channels.

By integrating tools like Sentry with Log4j, the team gains immediate awareness of production issues. Detailed error context enables rapid diagnosis and resolution, while centralized tracking enhances overall application reliability and minimizes downtime.

32. Is it possible to throw an exception manually? If yes, explain how.

How to Answer:

• State whether it is possible to throw an exception manually in Java.
• Describe how to throw an exception using the correct keyword and syntax.
• Show a simple code snippet that demonstrates the process.
• Summarize the purpose: Briefly explain why manual exception throwing is useful.

Sample Answer:

• It is possible to throw an exception manually in Java by using the throw keyword along with an exception object.
• To throw an exception:

throw new ExceptionType("Error message");

For example:

throw new IllegalArgumentException("Invalid input value");

• The throw statement signals the JVM that an error condition has occurred and should be handled by the nearest exception handler or propagated up the call stack.
• Manual exception throwing is useful for enforcing business rules, validating user input, or signaling error conditions that the application should handle.

Code Example:

public void checkPositive(int number) {
    if (number <= 0) {
        throw new IllegalArgumentException("Number must be positive.");
    }
}

Code Explanation: 

• Method Purpose: The method checkPositive is designed to validate that an input integer is strictly positive.
• Check for Non-positive Input: The if statement checks if the provided number is less than or equal to zero.
• Manual Exception Throwing:
  • If the condition is met (i.e., the number is not positive), the throw keyword is used to create and throw a new IllegalArgumentException.
  • The exception is constructed with a descriptive error message: "Number must be positive."

Output: When this exception is thrown, it interrupts normal program flow and propagates up to the nearest exception handler. This forces the calling code to either catch and handle the exception or let it propagate further, ensuring that invalid input is not silently ignored.

Exception in thread "main" java.lang.IllegalArgumentException: Number must be positive.
   at Example.checkPositive(Example.java:3)

Output Explanation: 

• The output shows the exception type, message, and stack trace.
• This makes it clear where and why the error occurred, helping developers quickly identify and fix issues related to invalid input.
• By throwing exceptions for invalid conditions, the application maintains robust error handling and prevents unsafe or unexpected behavior.

With this, we conclude our comprehensive collection of exception handling interview questions and answers customized for both beginners and experienced professionals. Reviewing these will enhance your technical understanding and interview readiness.

Also Read: Introduction to Exception Hierarchy in Java: A Comprehensive Guide

Advance Your Tech Skills and Stay Ahead With upGrad!

This blog covers top 32 exception handling interview questions and answers, including topics like how to handle exceptions in Java and Python, common exception handling best practices, checked and unchecked exceptions. However, excelling in tech interviews demands more than theoretical knowledge; it requires the ability to effectively apply exception handling principles to scenario-based challenges.

As you take the next step in your journey, consider upGrad's specialized courses. They offer the structured learning, expert guidance, and personalized support needed to bridge skill gaps and accelerate your growth.

Here are a few additional upGrad courses to help you build a strong foundation:

• Fundamentals of Cloud Computing
• Learn Basic Python Programming
• AI-Driven Full-Stack Development
• Data Structures & Algorithms
• Advanced JavaScript for All

Boost your career with our popular Software Engineering courses, offering hands-on training and expert guidance to turn you into a skilled software developer.

Explore our Popular Software Engineering Courses

Master in-demand Software Development skills like coding, system design, DevOps, and agile methodologies to excel in today’s competitive tech industry.

In-Demand Software Development Skills

Stay informed with our widely-read Software Development articles, covering everything from coding techniques to the latest advancements in software engineering.

Read our Popular Articles related to Software

Reference:
https://interviewing.io/blog/technical-interview-performance-is-kind-of-arbitrary-heres-the-data