Java Exceptions: 19 MCQs with answers

throw

The `throw` keyword is used to explicitly throw an exception, while `throws` declares exceptions in a method signature.

Throwable

`Throwable` is the root class for the exception hierarchy; `Exception` and `Error` both extend it.

The program terminates abruptly

An uncaught exception propagates up the call stack and causes the program to terminate with an error message.

finally

The `finally` block is designed to execute cleanup code and always runs after the `try`/`catch` blocks, unless the JVM exits.

To enclose code that might throw an exception

The `try` block wraps code that may throw an exception, allowing it to be caught and handled by a `catch` block.

Compile-time exception

Java categorizes exceptions into checked and unchecked (runtime) exceptions; there is no 'compile-time exception' category.

ArrayIndexOutOfBoundsException

`ArrayIndexOutOfBoundsException` is thrown when accessing an array with an illegal index (negative, equal to size, or greater).

To return a detailed message about the exception

`getMessage()` returns the detail message string of the exception, which often provides information about the cause.

True

A `finally` block is not required; you can have a try-catch without it. However, if present, it always executes.

False

Checked exceptions are checked at compile time; the compiler ensures they are either caught or declared. Runtime exceptions are unchecked.

ArithmeticException

`ArithmeticException` is a subclass of `RuntimeException`, making it unchecked. The others are checked exceptions.

public void readFile() throws IOException

The `throws` keyword is used in the method signature to declare that the method may throw a checked exception like IOException.

FileNotFoundException

`FileNotFoundException` is a subclass of `IOException`, which is a checked exception. The others are unchecked runtime exceptions.

That cleanup code runs

The `finally` block is used for cleanup activities like closing resources, and it runs regardless of whether an exception is thrown or caught.

Exception

`RuntimeException` extends `Exception`, which in turn extends `Throwable`.

Caught Finally

The `ArithmeticException` is caught, printing "Caught", and then the `finally` block runs, printing "Finally".

|

Java 7+ allows catching multiple exception types in one catch block using the pipe symbol `|`, e.g., `catch (IOException | SQLException e)`.

`throw` is used to throw an exception, `throws` declares exceptions in a method signature

`throw` is a statement that actually throws an exception object, while `throws` is a clause in the method signature indicating which exceptions the method may throw.

The return value from the finally block overrides the try block's return

If a `finally` block has a `return`, it will override any return value from the `try` or `catch` blocks, which can be surprising.