Top 50 Java Exception Handling Quiz

Java Exception Handling Quiz

Hello guys!

You’ve been learning a lot about Java, and now it’s time to test yourself with our Exception Handling Quiz. This quiz is a great way to check your knowledge and skills in handling exceptions in Java. If you’re new to this, don’t worry—this quiz will help you understand these important concepts better.

We’ve already covered many Java quizzes before, so if you haven’t checked them out, be sure to test your skills in those too. This quiz focuses on exception handling, which is crucial for writing robust and error-free code. Let’s see how well you know it!

1 / 50

What happens if an exception is thrown in the finally block?

The original exception will be suppressed

The exception will be thrown, and the program will terminate if not caught

The program will execute normally

The exception will be ignored

2 / 50

Can a try block be followed directly by a finally block without a catch block?

Only if the try block does not throw any exceptions

No, a try block must always be followed by both catch and finally blocks

Yes, a try block can be followed directly by a finally block

No, a try block must always be followed by at least one catch block

3 / 50

What will be the output of the following code?

public class Test {
    public static void main(String[] args) {
        try {
            testMethod();
        } catch (Exception e) {
            System.out.println(“Exception caught in main”);
        }
    }
    public static void testMethod() throws Exception {
        try {
            throw new Exception(“Exception in testMethod”);
        } catch (Exception e) {
            System.out.println(“Exception caught in testMethod”);
            throw e;
        } finally {
            System.out.println(“Finally block in testMethod”);
        }
    }
}

Compilation error

Exception in testMethod Finally block in testMethod

Exception caught in testMethod Finally block in testMethod Exception caught in main

Exception caught in testMethod Finally block in testMethod

4 / 50

What will happen if a catch block handles an exception and then throws a new exception?

The program will terminate immediately

The new exception will be propagated up the call stack

Both exceptions will be propagated

The original exception will be propagated

5 / 50

What is the correct way to rethrow an exception?

throw e;

catch (Exception e) { throw new e; }

rethrow e;

catch (Exception e) { throw e; }

6 / 50

What is the output of the following code snippet?

public class Test {
    public static void main(String[] args) {
        try {
            int[] arr = new int[5];
            arr[5] = 10;
        } catch (ArrayIndexOutOfBoundsException | NullPointerException e) {
            System.out.println(“Exception caught”);
        }
    }

}

No output

Exception caught

Compilation error

Runtime error

7 / 50

Which of the following best describes the hierarchy of exception handling classes in Java?

Throwable > Error > Exception > IOException

Throwable > Error > Exception > RuntimeException

Throwable > Exception > RuntimeException > Error

Throwable > Exception > Error > RuntimeException

8 / 50

What will be the output of the following code snippet?

public class Test {
    public static void main(String[] args) {
        try {
            int result = divide(10, 0);
            System.out.println(result);
        } catch (ArithmeticException e) {
            System.out.println(“Arithmetic Exception caught”);
        } finally {
            System.out.println(“Finally block executed”);
        }
    }
    public static int divide(int a, int b) {
        return a / b;
    }

}

Finally block executed

No output

Arithmetic Exception caught Finally block executed

Compilation error

9 / 50

Which of the following exceptions is a checked exception?

ArrayIndexOutOfBoundsException

NullPointerException

FileNotFoundException

ArithmeticException

10 / 50

What is the output of the following code snippet?

public class Test {
    public static void main(String[] args) {
        try (AutoCloseableResource resource = new AutoCloseableResource()) {
            System.out.println(“Try block”);
            throw new RuntimeException(“Exception in try block”);
        } catch (Exception e) {
            System.out.println(“Catch block: ” + e.getMessage());
        } finally {
            System.out.println(“Finally block”);
        }
    }
}
class AutoCloseableResource implements AutoCloseable {
    @Override
    public void close() {
        System.out.println(“Resource closed”);
    }
}

Try block Catch block: Exception in try block Finally block

Try block Finally block Catch block: Exception in try block

) Try block Resource closed Catch block: Exception in try block Finally block

Try block Resource closed Finally block Catch block: Exception in try block

11 / 50

Which exception is thrown when an application attempts to use null in a case where an object is required?

IndexOutOfBoundsException

IllegalArgumentException

NullPointerException

ClassCastException

12 / 50

What happens if a return statement is encountered in a try block and a finally block is also present?

The finally block will execute, and then the program will terminate

The finally block will execute after the return statement in the try block

The finally block will not execute

The finally block will execute before the return statement in the try block

13 / 50

Which method from the Throwable class is used to get the cause of an exception?

getLocalizedMessage()

getCause()

printStackTrace()

getMessage()

14 / 50

Which of the following is true about Error in Java?

Error is a checked exception

Error is a subclass of Throwable

Error indicates serious problems that a reasonable application should catch

Error is a subclass of Exception

15 / 50

Which of the following keywords is used to indicate that a method might throw an exception?

throw

try

throws

catch

16 / 50

Which of the following is true about the StackOverflowError?

It is caused by an infinite loop in the code

It is a checked exception

It is an error that indicates a stack overflow in the Java Virtual Machine (JVM)

It is a runtime exception

17 / 50

Which of the following is true about exceptions in Java?

Exception is a subclass of Error

RuntimeException is a subclass of Exception

RuntimeException is a subclass of Error

Error is a subclass of Exception

18 / 50

Can a catch block catch multiple exceptions in Java 7 and later?

Yes, but only if the exceptions are related by inheritance

No, Java does not support multi-catch blocks

No, each catch block can only catch one type of exception

Yes, using a multi-catch parameter separated by the pipe (|) symbol

19 / 50

What is the primary use of the throws keyword?

To handle exceptions within a method

To catch an exception

To declare that a method can throw one or more exceptions

To throw an exception manually

20 / 50

Which of the following statements is true about the finally block?

It is executed only if no exception occurs

It is executed before the catch block

It is executed whether an exception occurs or not

It is executed only if an exception occurs

21 / 50

Which of the following statements is true about checked exceptions?

All exceptions are checked exceptions

Checked exceptions are ignored by the compiler

Checked exceptions must be either caught or declared in the method signature

Checked exceptions do not need to be declared or caught

22 / 50

What will happen if the exception is thrown in both the try and finally blocks?

The program will terminate immediately without propagating any exceptions

Both exceptions will be propagated

The exception from the finally block will suppress the exception from the try block

The exception from the try block will suppress the exception from the finally block

23 / 50

Consider the following code. What will be the output?

public class Test {
    public static void main(String[] args) {
        try {
            int[] arr = new int[5];
            arr[5] = 10;
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println(“Array Index Out Of Bounds Exception caught”);
        } finally {
            System.out.println(“Finally block executed”);
        }
    }
}

Compilation error

Finally block executed

Array Index Out Of Bounds Exception caught Finally block executed

No output

24 / 50

Consider the following code. What will be the output?

public class Test {
    public static void main(String[] args) {
        try {
            String s = null;
            s.length();
        } catch (NullPointerException e) {
            System.out.println(“NullPointerException caught”);
        } finally {
            System.out.println(“Finally block executed”);
        }
    }
}

NullPointerException caught Finally block executed

No output

Finally block executed

Compilation error

25 / 50

Can a finally block be used without a try block?

Yes, but only if a catch block is also present

No, a finally block must always be associated with a try block

Yes, a finally block can be used anywhere in the code

Yes, a finally block can exist on its own

26 / 50

What happens if an exception is thrown and not caught in a catch block inside a method?

The program will terminate immediately

The finally block will not execute

The method will throw the exception to its caller

The exception is ignored

27 / 50

What will be the output of the following code?

public class Test {
    public static void main(String[] args) {
        try {
            int a = 10 / 0;
        } catch (NullPointerException e) {
            System.out.println(“NullPointerException caught”);
        } catch (Exception e) {
            System.out.println(“Exception caught”);
        }
    }
}

Compilation error

Exception caught

No output

NullPointerException caught

28 / 50

What will happen if an exception is thrown inside the finally block?

The original exception will be propagated

Both exceptions will be propagated

The program will terminate immediately

The new exception will suppress the original exception

29 / 50

What is the output of the following code snippet?

public class Test {
    public static void main(String[] args) {
        try {
            return;
        } finally {
            System.out.println(“Finally block executed”);
        }
    }
}

Compilation error

Finally block executed

No output

Runtime error

30 / 50

What is the correct way to define a custom exception in Java?

public class MyException implements Throwable {}

public class MyException extends Exception {}

public class MyException implements Exception {}

public class MyException extends Throwable {}

31 / 50

What is the primary difference between throw and throws in Java?

throw is used for throwing an exception manually, while throws is used to declare exceptions

Both are used to declare exceptions

throws is used for throwing an exception manually, while throw is used to declare exceptions

Both are used for throwing exceptions manually

32 / 50

Can a catch block be written to handle multiple exception types in Java?

No, a catch block can only handle one type of exception

Yes, by using a multi-catch parameter separated by the pipe (|) symbol

Yes, by chaining multiple catch blocks together

No, Java does not support this feature

33 / 50

What is the output of the following code snippet?

public class Test {
    public static void main(String[] args) {
        try {
            throw new Exception(“Custom Exception”);
        } catch (Exception e) {
            System.out.println(“Exception caught: ” + e);
        } finally {
            System.out.println(“Finally block executed”);
        }
    }
}

Exception caught: java.lang.Exception: Custom Exception Finally block executed

Custom Exception Finally block executed

No output

Compilation error

34 / 50

Which method is used to print the stack trace of an exception?

printStackTrace()

traceException()

getStackTrace()

printException()

35 / 50

What is the output of the following code snippet?

public class Test {
    public static void main(String[] args) {
        try {
            int a = 10 / 0;
        } catch (ArithmeticException e) {
            System.out.println(“Arithmetic Exception caught”);
        } finally {
            System.out.println(“Finally block executed”);
        }
    }
}

Finally block executed

Arithmetic Exception caught

No output

Arithmetic Exception caught Finally block executed

36 / 50

What is the purpose of the try block in Java?

To declare an exception

To handle code that may cause an exception

To throw an exception

To catch an exception

37 / 50

What is the use of the throw keyword in Java?

To catch an exception

To declare that a method can throw an exception

To throw an exception manually

To handle an exception within a method

38 / 50

What will happen if an exception is not caught in a try block?

The program will run without any issues

The program will terminate immediately

The program will compile with errors

The program will run but skip the catch block

39 / 50

What is the output of the following code snippet?

public class Test {
    public static void main(String[] args) {
        try {
            method1();
        } catch (Exception e) {
            System.out.println(“Exception caught in main: ” + e.getMessage());
        }
    }
    public static void method1() throws Exception {
        try {
            method2();
        } finally {
            System.out.println(“Finally block in method1”);
        }
    }
    public static void method2() throws Exception {
        throw new Exception(“Exception in method2”);
    }

}

Exception caught in main: Exception in method2 Finally block in method1

Finally block in method1 Exception in method2

Finally block in method1 Exception caught in main: Exception in method2

Exception in method2 Finally block in method1 Exception caught in main: Exception in method2

40 / 50

What is the purpose of the try-with-resources statement in Java?

To declare that a method can throw an exception

To catch multiple exceptions in a single catch block

To manage resources such as file streams automatically

To handle exceptions more efficiently

41 / 50

What will be the output of the following code snippet?

public class Test {
    public static void main(String[] args) {
        try {
            method1();
        } catch (Exception e) {
            System.out.println(“Exception caught in main”);
        }
    }
    public static void method1() throws Exception {
        try {
            method2();
        } finally {
            System.out.println(“Finally block in method1”);
        }
    }
    public static void method2() throws Exception {
        throw new Exception(“Exception in method2”);
    }
}

Exception in method2 Finally block in method1 Exception caught in main

Finally block in method1 Exception caught in main a) Exception in method2 Finally block in method1 Exception caught in main

Exception in method2 Exception caught in main Finally block in method1

Finally block in method1 Exception in method2 Exception caught in main

42 / 50

Consider the following code. What will be the output?

public class Test {
    public static void main(String[] args) {
        try {
            return;
        } finally {
            System.out.println(“Finally block executed”);
        }
    }
}

No output

Runtime error

Compilation error

Finally block executed

43 / 50

Which exception is thrown when a method receives an argument formatted differently than expected?

IllegalArgumentException

NumberFormatException

ClassCastException

IllegalStateException

44 / 50

What will be the output of the following code?

public class Test {
    public static void main(String[] args) {
        try {
            throw new NullPointerException(“Custom message”);
        } catch (NullPointerException e) {
            System.out.println(e.getMessage());
        }
    }
}

Runtime error

No output

Custom message

NullPointerException

45 / 50

Can the throws clause be used with multiple exceptions in a method declaration?

No, throws can only be used with one exception type at a time

Yes, by separating each exception with a comma

No, a method can only declare one exception using throws

Yes, but only if the exceptions are subclasses of RuntimeException

46 / 50

What is the output of the following code snippet?

public class Test {
    public static void main(String[] args) {
        try {
            int a = 10 / 0;
        } finally {
            System.out.println(“Finally block executed”);
        }
    }

}

No output

Finally block executed Exception in thread "main" java.lang.ArithmeticException: / by zero

Finally block executed

Exception in thread "main" java.lang.ArithmeticException: / by zero

47 / 50

Which keyword is used to manually throw an exception in Java?

throws

throw

try

catch

48 / 50

Which statement about the catch block is true?

Multiple catch blocks cannot follow a single try block

The catch block can only catch checked exceptions

A catch block must be followed by a finally block

A catch block can handle multiple types of exceptions using a multi-catch parameter

49 / 50

What happens if an exception is thrown in a method and there is no catch block to handle it?

The program continues executing the next line

The method terminates, and the program terminates

The exception is ignored

The method terminates and the exception is propagated to the caller

50 / 50

Which of the following is not a type of exception in Java?

Error

Throwable

SerializableException

RuntimeException

Your score is

The average score is 0%

You Might Also Like

Top 50 Java Collections Framework Quiz

Top Java Libraries and APIs Quiz

Java 50: OOP Quiz Challenge

Leave a Reply Cancel reply