Java Exception Handling: Essential Tips for Interview Preparation

Java Exception Handling is an essential part of the language. Understanding how to handle exceptions and how to design resilient code can help you prepare for interviews. Here's a guide to help you:

Key Concepts

1. What are exceptions?

   • Exceptions are unexpected events that occur during the execution of a program, disrupting its normal flow. They are objects in Java and are instances of the Throwable class.

2. Types of Exceptions:

   • Checked Exceptions: These are exceptions that the compiler forces you to handle (e.g., IOException, SQLException).
   • Unchecked Exceptions: These are runtime exceptions that don't need to be declared or caught (e.g., NullPointerException, ArrayIndexOutOfBoundsException).
   • Error: These are severe problems that typically can't be handled by the application, such as OutOfMemoryError.

3. The Exception Hierarchy:

   • Throwable is the parent class.
     • Error and Exception are its subclasses.
     • Exception has two main categories:
       • Checked Exceptions (e.g., IOException).
       • Unchecked Exceptions (e.g., RuntimeException and its subclasses).

4. Keywords in Exception Handling:

   • try: A block of code that might throw an exception.
   • catch: A block that catches the exception thrown from the try block.
   • finally: A block that executes code regardless of whether an exception occurs or not.
   • throw: Used to explicitly throw an exception.
   • throws: Declares exceptions that a method might throw.

Simple Interview Questions on Exception Handling

1. What is the difference between throw and throws?

   • throw is used to explicitly throw an exception from a method or block of code. Example: throw new Exception("Something went wrong");
   • throws is used in the method signature to declare that a method may throw one or more exceptions. Example: public void myMethod() throws IOException {}

2. What is the difference between checked and unchecked exceptions?

   • Checked exceptions: These are exceptions that must be handled (caught or declared). They are checked at compile time (e.g., IOException, SQLException).
   • Unchecked exceptions: These exceptions don't require explicit handling. They are checked at runtime and inherit from RuntimeException (e.g., NullPointerException, ArithmeticException).

3. Can a finally block be skipped?

   • The finally block is always executed after the try block, unless:
     • The JVM exits due to System.exit() being called.
     • The thread executing the code is interrupted or killed.

4. What happens if an exception is not caught?

   • If an exception is not caught within a method, it is propagated to the caller method. If no method catches it, the exception is propagated to the JVM, which terminates the program if uncaught.

5. What is a NullPointerException?

   • A NullPointerException occurs when you try to use a reference variable that points to null. Example: String s = null; s.length();

6. Explain the use of the finally block with an example.

   • The finally block is used to execute cleanup code, such as closing resources (files, database connections) after the try-catch block. It is executed whether or not an exception occurs.

   Example:

   try {
       int result = 10 / 0;  // ArithmeticException
   } catch (ArithmeticException e) {
       System.out.println("Error: " + e.getMessage());
   } finally {
       System.out.println("Finally block executed.");
   }

   Output:

   Error: / by zero
   Finally block executed.

7. What is the purpose of catch block?

   • The catch block is used to handle exceptions that occur in the try block. It specifies the type of exception it is designed to handle. If the type matches, the catch block will execute.

   Example:

   try {
       int[] arr = new int[2];
       arr[3] = 10;  // ArrayIndexOutOfBoundsException
   } catch (ArrayIndexOutOfBoundsException e) {
       System.out.println("Index out of bounds.");
   }
   

8. What is the Exception class in Java?

   • The Exception class is the superclass for all exceptions in Java (except Error). It is used to represent errors that can be handled and recovered from.

9. What is an example of custom exception creation in Java?

   • You can create your own exceptions by extending the Exception class.

   Example:

   class MyCustomException extends Exception {
       public MyCustomException(String message) {
           super(message);
       }
   }
   
   public class TestCustomException {
       public static void main(String[] args) {
           try {
               throw new MyCustomException("This is a custom exception");
           } catch (MyCustomException e) {
               System.out.println(e.getMessage());
           }
       }
   }
   

10. Is it possible to catch multiple exceptions in one catch block?

• Yes, in Java 7 and above, you can catch multiple exceptions in one catch block using the pipe (|) operator.

Example:

try {
    // some code
} catch (IOException | SQLException e) {
    e.printStackTrace();
}

Best Practices:

• Always handle exceptions where it makes sense, and avoid catching generic exceptions (like Exception or Throwable) unless absolutely necessary.
• Ensure that resources (like files and database connections) are properly closed by using the finally block or try-with-resources statement.
• Use custom exceptions when you need specific error handling for your application logic.