10 Exceptions in Java Interview Questions and Answers

Exceptions in Java are a fundamental aspect of the language’s robust error-handling capabilities. They provide a structured way to handle runtime errors, ensuring that programs can manage unexpected conditions gracefully without crashing. Mastery of exception handling is crucial for writing reliable and maintainable Java applications, making it a key area of focus for developers.

This article offers a curated selection of interview questions centered around Java exceptions. By exploring these questions and their detailed answers, you will gain a deeper understanding of how to effectively manage errors in Java, enhancing your readiness for technical interviews and your overall coding proficiency.

Exceptions in Java Interview Questions and Answers

1. What is an Exception?

An exception in Java is an event that disrupts the normal flow of a program’s execution. It is an object thrown at runtime when an error or unexpected event occurs, allowing the program to handle errors in a controlled manner. Exceptions are categorized into three types: Checked Exceptions (e.g., IOException), Unchecked Exceptions (e.g., NullPointerException), and Errors (e.g., OutOfMemoryError).

2. Describe the syntax and usage of try-catch blocks in Java.

In Java, try-catch blocks handle exceptions. The try block contains code that might throw an exception, while the catch block handles the exception. Multiple catch blocks can handle different exceptions, and an optional finally block can execute code regardless of exceptions.

Example:

public class ExceptionExample {
    public static void main(String[] args) {
        try {
            int division = 10 / 0;
        } catch (ArithmeticException e) {
            System.out.println("Cannot divide by zero.");
        } finally {
            System.out.println("This block is always executed.");
        }
    }
}

3. Can you explain the use of the ‘finally’ block?

The ‘finally’ block in Java executes code that must run regardless of whether an exception is thrown or caught, useful for resource management tasks like closing files.

Example:

public class FinallyExample {
    public static void main(String[] args) {
        try {
            int data = 25 / 0;
        } catch (ArithmeticException e) {
            System.out.println("Exception caught: " + e);
        } finally {
            System.out.println("This block is always executed.");
        }
    }
}

4. How do you create a custom exception?

Custom exceptions handle specific error conditions not covered by standard Java exceptions. To create one, extend the Exception class and add custom fields or methods if needed.

Example:

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

public class Main {
    public static void main(String[] args) {
        try {
            validateAge(15);
        } catch (CustomException e) {
            System.out.println("Caught custom exception: " + e.getMessage());
        }
    }

    public static void validateAge(int age) throws CustomException {
        if (age < 18) {
            throw new CustomException("Age must be 18 or older.");
        }
    }
}

5. Explain the use of the throws keyword in method declarations.

The throws keyword in Java method declarations indicates that a method can throw one or more exceptions, particularly checked exceptions. It informs the caller about potential exceptions, allowing them to handle these appropriately.

Example:

import java.io.IOException;

public class FileManager {
    public void readFile(String filePath) throws IOException {
        // Code that might throw an IOException
    }
}

6. Can you describe the hierarchy of exception classes in Java?

In Java, exceptions are organized hierarchically, with Throwable as the base class. Its subclasses are Error and Exception, with Exception further divided into RuntimeException (unchecked) and checked exceptions.

7. How would you handle multiple exceptions in a single catch block?

Java allows handling multiple exceptions in a single catch block using the pipe (|) operator, introduced in Java 7. This makes the code more concise and easier to read.

Example:

try {
    int[] numbers = {1, 2, 3};
    System.out.println(numbers[5]);
    String text = null;
    System.out.println(text.length());
} catch (ArrayIndexOutOfBoundsException | NullPointerException e) {
    System.out.println("An exception occurred: " + e.getMessage());
}

8. Write a method that demonstrates the use of try-with-resources.

The try-with-resources statement in Java ensures that resources are closed at the end of the statement, useful for managing resources like files or database connections.

Example:

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class TryWithResourcesExample {
    public static void main(String[] args) {
        try (BufferedReader br = new BufferedReader(new FileReader("test.txt"))) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

9. What is the difference between throw and throws?

In Java, throw and throws serve different purposes in exception handling. throw explicitly throws an exception, while throws declares that a method can throw exceptions.

Example:

public class ExceptionExample {

    public static void main(String[] args) {
        try {
            checkAge(15);
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }

    public static void checkAge(int age) throws Exception {
        if (age < 18) {
            throw new Exception("Age must be 18 or older.");
        }
    }
}

10. Can you explain the use of the try-catch-finally block?

The try-catch-finally block in Java handles exceptions and executes cleanup code. The try block contains code that might throw an exception, the catch block handles it, and the finally block executes code regardless of exceptions.

Example:

public class ExceptionExample {
    public static void main(String[] args) {
        try {
            int result = 10 / 0;
        } catch (ArithmeticException e) {
            System.out.println("Caught an ArithmeticException: " + e.getMessage());
        } finally {
            System.out.println("This will always execute.");
        }
    }
}