Java Exception Handling Interview Questions

Interview Questions on Exception handling can be very tricky. One need very good understanding of the hierarchy of Exception classes and the try catch finally blocks. In this interview guide, we take a deep look into exception handling with a lot of examples.

1. Explain about Exception Handling with an example?
2. What is the use of finally block in Exception Handling?
3. In what kind of scenarios, a finally block is not executed?
4. Is a finally block executed even when there is a return statement in the try block?
5. Is a try block without corresponding catch block allowed?
6. Explain the hierarchy of Exception related classes in Java?
7. What is difference between an Error and an Exception?
8. What is the difference between a Checked Exception and an Un-Checked Exception?
9. How do you throw a Checked Exception from a Method?
10. How do you create a Custom Exception Classes?
11. How should the Exception catch blocks be ordered ?
12. What are the new features related to Exception Handling introduced in Java7?
13. Can you explain some Exception Handling Best Practices?

Explain about Exception Handling with an example?

Exception Handling helps us to recover from an unexpected situations – File not found or network connection is down. The important part in exception handling is the try – catch block. Look at the example below. When exception is handled in a method, the calling methods will not need worry about that exception. Since Exception Handling is added in the method method2, the exception did not propogate to method1 i.e. method1 does not know about the exception in method2.

    public static void main(String[] args) {
        method1();
        System.out.println("Line after Exception - Main");
    }

    private static void method1() {
        method2();
        System.out.println("Line after Exception - Method 1");
    }

    private static void method2() {
        try {
            String str = null;
            str.toString();
            System.out.println("Line after Exception - Method 2");
        } catch (Exception e) {
            // NOT PRINTING EXCEPTION TRACE- BAD PRACTICE
            System.out.println("Exception Handled - Method 2");
        }
    }

Program Output

Exception Handled - Method 2

Line after Exception - Method 1

Line after Exception - Main

Few important things to remember from this example.

• If exception is handled, it does not propogate further.
• In a try block, the lines after the line throwing the exception are not executed.

What is the use of finally block in Exception Handling?

When an exception happens, the code after the line throwing exception is not executed. If code for things like closing a connection is present in these lines of code, it is not executed. This leads to connection and other resource leaks.

Code written in finally block is executed even when there is an exception.

Consider the example below. This is code without a finally block . We have Connection class with open and close methods. An exception happens in the main method. The connection is not closed because there is no finally block.Connection that is opened is not closed. This results in a dangling (un-closed) connection.Finally block is used when code needs to be executed irrespective of whether an exception is thrown.

class Connection {
    void open() {
        System.out.println("Connection Opened");
    }

    void close() {
        System.out.println("Connection Closed");
    }
}

public class ExceptionHandlingExample1 {

    public static void main(String[] args) {
        try {
            Connection connection = new Connection();
            connection.open();

            // LOGIC
            String str = null;
            str.toString();

            connection.close();
        } catch (Exception e) {
            // NOT PRINTING EXCEPTION TRACE- BAD PRACTICE
            System.out.println("Exception Handled - Main");
        }
    }
}

Output

Connection Opened
Exception Handled - Main

Let us now move connection.close(); into a finally block. Also connection declaration is moved out of the try block to make it visible in the finally block. Connection is closed even when exception is thrown. This is because connection.close() is called in the finally block. Finally block is always executed (even when an exception is thrown). So, if we want some code to be always executed we can move it to finally block.

    public static void main(String[] args) {
        Connection connection = new Connection();
        connection.open();
        try {
            // LOGIC
            String str = null;
            str.toString();

        } catch (Exception e) {
            // NOT PRINTING EXCEPTION TRACE - BAD PRACTICE
            System.out.println("Exception Handled - Main");
        } finally {
            connection.close();
        }
    }

Output

Connection Opened
Exception Handled - Main
Connection Closed

In what kind of scenarios, a finally block is not executed?

Code in finally is NOT executed only in two situations.

• If exception is thrown in finally.
• If JVM Crashes in between (for example, System.exit()).

Is a finally block executed even when there is a return statement in the try block?

Yes. In the example below, connection.close() method is called even though there is a return in the catch block.

private static void method2() {
        Connection connection = new Connection();
        connection.open();
        try {
            // LOGIC    
            String str = null;
            str.toString();
            return;
        } catch (Exception e) {
            // NOT PRINTING EXCEPTION TRACE - BAD PRACTICE
            System.out.println("Exception Handled - Method 2");
            return;
        } finally {
            connection.close();
        }
    }

Is a try block without corresponding catch block allowed?

Yes. try without a catch is allowed. Example below.

private static void method2() {
        Connection connection = new Connection();
        connection.open();
        try {
            // LOGIC
            String str = null;
            str.toString();
        } finally {
            connection.close();
        }
    }

However a try block without both catch and finally is NOT allowed until before Java 7. Below method would give a Compilation Error!! (End of try block).

    private static void method2() {
        Connection connection = new Connection();
        connection.open();
        try {
            // LOGIC
            String str = null;
            str.toString();
        }//COMPILER ERROR!!
    }

With Java 7, for try blocks doing automatic resource management - it is allowed not to have both catch and finally.

  try (FileInputStream input = new FileInputStream("file.txt")) {
   int data = input.read();
   while (data != -1) {
    System.out.print((char) data);
    data = input.read();
   }
  }

Explain the hierarchy of Exception related classes in Java?

Throwable is the highest level of Error Handling classes.

Below class definitions show the pre-defined exception hierarchy in Java.

//Pre-defined Java Classes
class Error extends Throwable{}
class Exception extends Throwable{}
class RuntimeException extends Exception{}

Below class definitions show creation of a programmer defined exception in Java.

//Programmer defined classes
class CheckedException1 extends Exception{}
class CheckedException2 extends CheckedException1{}

class UnCheckedException extends RuntimeException{}
class UnCheckedException2 extends UnCheckedException{}

What is difference between an Error and an Exception?

Error is used in situations when there is nothing a programmer can do about an error. Ex: StackOverflowError, OutOfMemoryError. Exception is used when a programmer can handle the exception.

What is the difference between a Checked Exception and an Un-Checked Exception?

RuntimeException and classes that extend RuntimeException are called unchecked exceptions. For Example: RuntimeException,UnCheckedException,UnCheckedException2 are unchecked or RunTime Exceptions. There are subclasses of RuntimeException (which means they are subclasses of Exception also.)

Other Exception Classes (which don’t fit the earlier definition). These are also called Checked Exceptions. Exception, CheckedException1,CheckedException2 are checked exceptions. They are subclasses of Exception which are not subclasses of RuntimeException.

How do you throw a Checked Exception from a Method?

Consider the example below. The method addAmounts throws a new Exception. However, it gives us a compilation error because Exception is a Checked Exception.

All classes that are not RuntimeException or subclasses of RuntimeException but extend Exception are called CheckedExceptions. The rule for CheckedExceptions is that they should be handled or thrown. Handled means it should be completed handled - i.e. not throw out of the method. Thrown means the method should declare that it throws the exception

Example without throws: Does NOT compile

class AmountAdder {
    static Amount addAmounts(Amount amount1, Amount amount2) {
        if (!amount1.currency.equals(amount2.currency)) {
            throw new Exception("Currencies don't match");// COMPILER ERROR!                // Unhandled exception type Exception
        }
        return new Amount(amount1.currency, amount1.amount + amount2.amount);
    }
}

Example with throws definition

Let's look at how to declare throwing an exception from a method.

Look at the line "static Amount addAmounts(Amount amount1, Amount amount2) throws Exception". This is how we declare that a method throws Exception.

class AmountAdder {
    static Amount addAmounts(Amount amount1, Amount amount2) throws Exception {
        if (!amount1.currency.equals(amount2.currency)) {
            throw new Exception("Currencies don't match");
        }
        return new Amount(amount1.currency, amount1.amount + amount2.amount);
    }
}

How do you create a Custom Exception Classes?

We can create a custom exception by extending Exception class or RuntimeException class. If we extend Exception class, it will be a checked exception class. If we extend RuntimeException class, then we create an unchecked exception class.

Example

class CurrenciesDoNotMatchException extends Exception{
}

Let’s now create some sample code to use CurrenciesDoNotMatchException. Since it is a checked exception we need do two things a. throw new CurrenciesDoNotMatchException(); b. throws CurrenciesDoNotMatchException (in method declaration).

class AmountAdder {
    static Amount addAmounts(Amount amount1, Amount amount2)
            throws CurrenciesDoNotMatchException {
        if (!amount1.currency.equals(amount2.currency)) {
            throw new CurrenciesDoNotMatchException();
        }
        return new Amount(amount1.currency, amount1.amount + amount2.amount);
    }
}

How should the Exception catch blocks be ordered ?

Specific Exception catch blocks should be before the catch block for a Generic Exception. For example, CurrenciesDoNotMatchException should be before Exception. Below code gives a compilation error.

    public static void main(String[] args) {
        try {
            AmountAdder.addAmounts(new Amount("RUPEE", 5), new Amount("DOLLAR",
                    5));
        } catch (Exception e) { // COMPILER ERROR!!
            System.out.println("Handled Exception");
        } catch (CurrenciesDoNotMatchException e) {
            System.out.println("Handled CurrenciesDoNotMatchException");
        }
    }

What are the new features related to Exception Handling introduced in Java7?

Automatic resource management. JVM takes care of closing the connection when we use try with resources.

  try (FileInputStream input = new FileInputStream("file.txt")) {
   int data = input.read();
   while (data != -1) {
    System.out.print((char) data);
    data = input.read();
   }
  }

Multiple Repeated Exception Blocks not needed anymore. We can use a single exception block to catch multiple exception types.

catch (IOException|SQLException ex) {
    logger.log(ex);
    throw ex;
}

Can you explain some Exception Handling Best Practices?

Never Completely Hide Exceptions. At the least log them. printStactTrace method prints the entire stack trace when an exception occurs. If you handle an exception, it is always a good practice to log the trace.

    public static void main(String[] args) {
        try {
            AmountAdder.addAmounts(new Amount("RUPEE", 5), new Amount("RUPEE",
                    5));
            String string = null;
            string.toString();
        } catch (CurrenciesDoNotMatchException e) {
            System.out.println("Handled CurrenciesDoNotMatchException");
            e.printStackTrace();
        }
    }