1. What is Exception Handling in Java?

Answer: Exception handling in Java is a mechanism that helps manage runtime errors,
ensuring the smooth flow of program execution. It allows a program to catch and handle
exceptions (abnormal events) that occur during the execution of a program. Without proper
exception handling, the program may terminate unexpectedly. Java provides try, catch,
finally, throw, and throws keywords to handle exceptions.
2. What are the types of exceptions in Java?
Answer:
• Checked Exceptions: These are exceptions that are checked at compile-time. The
Java compiler ensures that these exceptions are handled or declared in the method
signature using the throws keyword. Examples include IOException, SQLException,
and ClassNotFoundException.
• Unchecked Exceptions: These exceptions are checked at runtime, meaning the
compiler does not enforce handling them. They typically occur due to programming
errors, such as logical bugs or improper use of API methods. Examples include
NullPointerException, ArrayIndexOutOfBoundsException, and ArithmeticException.
3. What is the difference between throw and throws?
Answer:
• throw: Used to explicitly throw an exception from any block of code. You can throw
both checked and unchecked exceptions using throw. Example:
throw new NullPointerException("This is a null pointer exception");
• throws: Used in the method declaration to indicate that a method might throw one
or more exceptions. The calling method must handle or declare the exception(s).
Example:
public void readFile() throws IOException {
// Code that may throw IOException
}
4. Explain the try-catch block.
Answer: The try-catch block is used to handle exceptions. Code that might throw an
exception is enclosed in the try block, and the code to handle the exception is placed in the
catch block. This prevents the program from crashing and allows it to continue running or
exit gracefully.
try {
// Risky code
} catch (ExceptionType e) {

Java exception handling interview questions answered by @bit.size.theory

 // Handle the exception
}
If an exception is thrown inside the try block, control is passed to the corresponding catch
block.
5. What is the finally block in Java?
Answer: The finally block contains code that is always executed, regardless of whether an
exception occurred or not. It is typically used for cleanup activities like closing file streams,
releasing resources, or database connections. The finally block will execute after the try and
catch blocks, even if an exception is thrown or a return statement is encountered.
try {
// Code that might throw an exception
} catch (Exception e) {
// Handle the exception
} finally {
// Cleanup code
}

6. Can a finally block be skipped?

Answer: Generally, the finally block is always executed, except in a few cases:
• If the JVM exits (e.g., System.exit(0) is called) during the execution of the try or catch
blocks.
• If a fatal error like OutOfMemoryError or StackOverflowError occurs.
• If the thread executing the try block is interrupted or killed.
7. What is the use of the throw keyword?
Answer: The throw keyword is used to explicitly throw an exception. It can be used to throw
both checked and unchecked exceptions. It is often used for creating custom exceptions or
propagating an exception from one part of the program to another. Example:
throw new IllegalArgumentException("Invalid argument passed");
8. What is the difference between Error and Exception in Java?
Answer:
• Error: These are serious issues that usually indicate a problem with the JVM itself.
Errors are unchecked exceptions and typically represent conditions that a program

Java exception handling interview questions answered by @bit.size.theory

 cannot recover from (e.g., OutOfMemoryError, StackOverflowError). Programs
should not attempt to catch or handle errors.
• Exception: These are conditions that an application can catch and handle. Exceptions
can be checked (e.g., IOException) or unchecked (e.g., NullPointerException).
Checked exceptions must be explicitly handled or declared.
9. What is a custom exception in Java?
Answer: A custom exception is a user-defined exception that extends either the Exception
class (for checked exceptions) or the RuntimeException class (for unchecked exceptions).
Custom exceptions are used to create specific exception types tailored to the needs of the
application. Example:
public class InvalidAgeException extends Exception {
public InvalidAgeException(String message) {
super(message);
}
}
Custom exceptions can be thrown using the throw keyword and caught like any other
exception.
10. How do you create a custom exception?
Answer: To create a custom exception, you need to extend the Exception or
RuntimeException class and provide constructors to initialize the exception message.
Example:
public class InvalidInputException extends Exception {
public InvalidInputException(String message) {
super(message);
}
}
This custom exception can be thrown in code:
java
Copy code
throw new InvalidInputException("Invalid input provided");
11. How can we handle multiple exceptions in a single catch block?

Java exception handling interview questions answered by @bit.size.theory

Answer: In Java 7 and later, you can handle multiple exceptions in a single catch block using
the pipe (|) operator. This reduces code duplication when multiple exceptions require the
same handling.
try {
// Risky code
} catch (IOException | SQLException e) {
// Handling code for both exceptions
}
The exception variable e will be of the common supertype, typically Exception.
12. What is the purpose of the try-with-resources statement?
Answer: The try-with-resources statement is used to automatically close resources (like file
streams, sockets, etc.) when they are no longer needed. It was introduced in Java 7 and
ensures that resources are closed automatically, even if an exception occurs. Resources used
in try-with-resources must implement the AutoCloseable interface.
try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
// Use the resource
} catch (IOException e) {
// Handle the exception
}
13. How can you re-throw an exception in Java?
Answer: You can re-throw an exception using the throw keyword inside a catch block. This
allows you to catch an exception, perform some actions (like logging), and then propagate
the same exception further up the call stack.
try {
// Code that may throw an exception
} catch (IOException e) {
// Log the exception
throw e; // Re-throw the exception
}
Re-throwing can help maintain exception flow while still providing some control over how
it’s handled at different points.
14. What is the purpose of the @SuppressWarnings annotation?

Java exception handling interview questions answered by @bit.size.theory

Answer: The @SuppressWarnings annotation is used to tell the compiler to ignore certain
warnings, such as unchecked operations, deprecation warnings, etc. It is commonly used in
situations where the programmer is aware of the issue but has a valid reason to suppress
the warning.
@SuppressWarnings("unchecked")
public void myMethod() {
// Code with unchecked warnings
}
15. Can we use multiple finally blocks?
Answer: No, Java does not allow multiple finally blocks for a single try block. You can only
have one finally block associated with a try block. However, a try block can be followed by
multiple catch blocks, each handling different types of exceptions, but there can only be one
finally block for final cleanup.
16. What Is the Difference Between an Exception and Error?
Answer: In Java, both exceptions and errors represent problems that occur during program
execution, but they differ in their nature, origin, and how they are handled. Here's a detailed
explanation of the differences between exceptions and errors:

1. Definition
• Exception: An exception is an event that occurs during the execution of a program
that disrupts its normal flow. Exceptions are typically conditions that a program can
catch and handle. They arise from issues that are expected, such as invalid input,
failed I/O operations, or arithmetic errors.
• Error: An error indicates serious problems that are typically outside the control of the
application. Errors usually represent conditions that cannot be recovered from, such
as system-level issues or critical resource failures (e.g., running out of memory).

17. What Is a Stacktrace and How Does It Relate to an Exception?

Answer: A stack trace provides the names of the classes and methods that were called, from
the start of the application to the point an exception occurred.
It’s a very useful debugging tool since it enables us to determine exactly where the
exception was thrown in the application and the original causes that led to it.
18. Why Would You Want to Subclass an Exception?
Answer: If the exception type isn’t represented by those that already exist in the Java
platform, or if you need to provide more information to client code to treat it in a more
precise manner, then you should create a custom exception.

Java exception handling interview questions answered by @bit.size.theory

Deciding whether a custom exception should be checked or unchecked depends entirely on
the business case. However, as a rule of thumb; if the code using your exception can be
expected to recover from it, then create a checked exception otherwise make it unchecked.
Also, you should inherit from the most specific Exception subclass that closely relates to the
one you want to throw. If there is no such class, then choose Exception as the parent.

Java exception handling interview questions answered by @bit.size.theory