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

Which of the following is true about Error in Java?

Error indicates serious problems that a reasonable application should catch

Error is a subclass of Exception

Error is a subclass of Throwable

Error is a checked exception

2 / 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

No, Java does not support this feature

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

Yes, by chaining multiple catch blocks together

3 / 50

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

It is executed whether an exception occurs or not

It is executed only if no exception occurs

It is executed before the catch block

It is executed only if an exception occurs

4 / 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”);
        }
    }
}

Compilation error

Finally block executed

Runtime error

No output

5 / 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”);
    }

}

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

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

6 / 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

The original exception will be propagated

Both exceptions will be propagated

7 / 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 caught in testMethod Finally block in testMethod

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

Exception in testMethod Finally block in testMethod

8 / 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”);
        }
    }

}

Compilation error

Exception caught

No output

Runtime error

9 / 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 Exception caught in main Finally block in method1

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

Exception in method2 Finally block in method1 Exception caught in main

Finally block in method1 Exception in method2 Exception caught in main

10 / 50

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

To handle exceptions more efficiently

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

11 / 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 Resource closed Finally block Catch block: Exception in try block

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

Try block Catch block: Exception in try block Finally block

Try block Finally block Catch block: Exception in try block

12 / 50

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

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

The original exception will be suppressed

The exception will be ignored

The program will execute normally

13 / 50

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

catch

throws

throw

try

14 / 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 for throwing exceptions manually

Both are used to declare exceptions

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

15 / 50

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

No, a try block must always be followed by at least one 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

16 / 50

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

Yes, by separating each exception with a comma

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

Yes, but only if the exceptions are subclasses of RuntimeException

No, a method can only declare one exception using throws

17 / 50

Which of the following statements is true about checked exceptions?

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

All exceptions are checked exceptions

Checked exceptions do not need to be declared or caught

Checked exceptions are ignored by the compiler

18 / 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

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

Finally block executed

19 / 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”);
        }
    }
}

Custom Exception Finally block executed

Compilation error

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

No output

20 / 50

What is the correct way to rethrow an exception?

catch (Exception e) { throw e; }

catch (Exception e) { throw new e; }

rethrow e;

throw e;

21 / 50

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

ClassCastException

NullPointerException

IllegalArgumentException

IndexOutOfBoundsException

22 / 50

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

getStackTrace()

printStackTrace()

traceException()

printException()

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”);
        }
    }
}

No output

Finally block executed

Compilation error

Array Index Out Of Bounds Exception caught Finally block executed

24 / 50

Can a finally block be used without a try block?

Yes, a finally block can exist on its own

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

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

Yes, but only if a catch block is also present

25 / 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”);
        }
    }
}

No output

Exception caught

NullPointerException caught

Compilation error

26 / 50

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

The finally block will not execute

The program will terminate immediately

The method will throw the exception to its caller

The exception is ignored

27 / 50

What is the primary use of the throws keyword?

To handle exceptions within a method

To throw an exception manually

To declare that a method can throw one or more exceptions

To catch an exception

28 / 50

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

The program will run without any issues

The program will compile with errors

The program will run but skip the catch block

The program will terminate immediately

29 / 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

Finally block executed

No output

Compilation error

30 / 50

Which of the following is true about exceptions in Java?

RuntimeException is a subclass of Exception

Error is a subclass of Exception

RuntimeException is a subclass of Error

Exception is a subclass of Error

31 / 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;
    }

}

Arithmetic Exception caught Finally block executed

Finally block executed

No output

Compilation error

32 / 50

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

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

Yes, but only if the exceptions are related by inheritance

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

No, Java does not support multi-catch blocks

33 / 50

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

The method terminates, and the program terminates

The method terminates and the exception is propagated to the caller

The program continues executing the next line

The exception is ignored

34 / 50

What is the use of the throw keyword in Java?

To declare that a method can throw an exception

To throw an exception manually

To handle an exception within a method

To catch an exception

35 / 50

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

throws

throw

catch

try

36 / 50

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

Throwable > Exception > RuntimeException > Error

Throwable > Error > Exception > IOException

Throwable > Error > Exception > RuntimeException

Throwable > Exception > Error > RuntimeException

37 / 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”);
        }
    }
}

Arithmetic Exception caught

Arithmetic Exception caught Finally block executed

No output

Finally block executed

38 / 50

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

The new exception will suppress the original exception

The original exception will be propagated

Both exceptions will be propagated

The program will terminate immediately

39 / 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());
        }
    }
}

Custom message

Runtime error

No output

NullPointerException

40 / 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”);
        }
    }
}

Finally block executed

Runtime error

No output

Compilation error

41 / 50

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

NumberFormatException

ClassCastException

IllegalStateException

IllegalArgumentException

42 / 50

What is the purpose of the try block in Java?

To throw an exception

To declare an exception

To handle code that may cause an exception

To catch an exception

43 / 50

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

RuntimeException

Error

SerializableException

Throwable

44 / 50

Which of the following exceptions is a checked exception?

FileNotFoundException

ArrayIndexOutOfBoundsException

ArithmeticException

NullPointerException

45 / 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

46 / 50

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

public class MyException extends Throwable {}

public class MyException implements Throwable {}

public class MyException extends Exception {}

public class MyException implements Exception {}

47 / 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 before the return statement in the try block

The finally block will not execute

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

48 / 50

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

getCause()

printStackTrace()

getLocalizedMessage()

getMessage()

49 / 50

Which statement about the catch block is true?

A catch block must be followed by a finally block

Multiple catch blocks cannot follow a single try block

The catch block can only catch checked exceptions

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

50 / 50

Which of the following is true about the StackOverflowError?

It is caused by an infinite loop in the code

It is a runtime exception

It is a checked exception

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

Your score is

The average score is 0%

You Might Also Like

Top 50 Java Collections Framework Quiz

Java Control Flow Statements code Quiz

Java 50: OOP Quiz Challenge

Leave a Reply Cancel reply