Exception Vs Error Basics Quiz

1. What is the main difference between an error and an exception?

Errors are always fatal; exceptions can be caught and handled

Errors occur in logic; exceptions occur in syntax

Errors are warnings; exceptions are critical failures

There is no difference; the terms are interchangeable

Errors represent serious issues that typically cause a program to crash and cannot be recovered from, while exceptions are conditions that can be anticipated and managed within the program's flow. This distinction allows developers to implement error-handling mechanisms for exceptions, enhancing the robustness of their applications.

Explanation

Errors represent serious issues that typically cause a program to crash and cannot be recovered from, while exceptions are conditions that can be anticipated and managed within the program's flow. This distinction allows developers to implement error-handling mechanisms for exceptions, enhancing the robustness of their applications.

2. Which of the following is an example of an exception?

Dividing by zero

Stack overflow

Accessing an out-of-bounds array index

Running out of memory

Accessing an out-of-bounds array index is an example of an exception because it occurs when a program attempts to access a memory location that is outside the limits of the array. This violates the rules of memory access and typically triggers an error, allowing the program to handle the situation gracefully.

Explanation

Accessing an out-of-bounds array index is an example of an exception because it occurs when a program attempts to access a memory location that is outside the limits of the array. This violates the rules of memory access and typically triggers an error, allowing the program to handle the situation gracefully.

3. What does a try-catch block do?

Prevents all errors from occurring

Catches exceptions so the program can handle them gracefully

Converts errors into exceptions automatically

Stops the program from running

A try-catch block allows a program to attempt executing code that may cause an error. If an error occurs, the catch section handles the exception, preventing the program from crashing and enabling it to respond appropriately, such as logging the error or providing user feedback. This promotes smoother program execution.

Explanation

A try-catch block allows a program to attempt executing code that may cause an error. If an error occurs, the catch section handles the exception, preventing the program from crashing and enabling it to respond appropriately, such as logging the error or providing user feedback. This promotes smoother program execution.

4. In a try-catch-finally block, when does the finally block execute?

Only if an exception is caught

Only if no exception occurs

Always, whether an exception occurs or not

Never, unless explicitly called

The finally block is designed to execute regardless of whether an exception is thrown or caught within the try block. This ensures that essential cleanup code, such as closing resources or releasing locks, is always executed, maintaining program stability and resource management.

Explanation

The finally block is designed to execute regardless of whether an exception is thrown or caught within the try block. This ensures that essential cleanup code, such as closing resources or releasing locks, is always executed, maintaining program stability and resource management.

5. What type of exception occurs when you try to access a null object?

IndexOutOfBoundsException

NullPointerException

ArrayIndexException

AccessViolationException

A NullPointerException occurs when an application attempts to use an object reference that has not been initialized, meaning it points to null. This situation arises when methods or properties are called on a null reference, leading to runtime errors as the program cannot access or manipulate the intended object.

Explanation

A NullPointerException occurs when an application attempts to use an object reference that has not been initialized, meaning it points to null. This situation arises when methods or properties are called on a null reference, leading to runtime errors as the program cannot access or manipulate the intended object.

6. Which statement about checked exceptions is true?

They must be caught or declared in the method signature

They never need to be handled

They are always fatal to the program

They occur only during compilation

Checked exceptions are a category of exceptions in Java that must be explicitly handled by the programmer. This means that any method that can throw a checked exception must either catch it using a try-catch block or declare it in its method signature with a throws clause, ensuring that the exception is properly managed.

Explanation

Checked exceptions are a category of exceptions in Java that must be explicitly handled by the programmer. This means that any method that can throw a checked exception must either catch it using a try-catch block or declare it in its method signature with a throws clause, ensuring that the exception is properly managed.

7. What does the throw keyword do?

Catches an exception that was thrown

Creates and throws an exception manually

Prevents an exception from being thrown

Converts an error into a warning

The throw keyword is used in programming to explicitly create and raise an exception. This allows developers to signal that an error condition has occurred and to provide a specific exception type, which can then be caught by an exception handler for appropriate error management.

Explanation

The throw keyword is used in programming to explicitly create and raise an exception. This allows developers to signal that an error condition has occurred and to provide a specific exception type, which can then be caught by an exception handler for appropriate error management.

8. If a method does not catch an exception, what happens?

The program automatically fixes the error

The exception propagates up the call stack

The exception is silently ignored

A new exception is created

When a method does not catch an exception, the exception is not resolved within that method. Instead, it propagates up the call stack, meaning that the next higher method in the call hierarchy gets the opportunity to handle the exception. This process continues until the exception is caught or reaches the top level of the program.

Explanation

When a method does not catch an exception, the exception is not resolved within that method. Instead, it propagates up the call stack, meaning that the next higher method in the call hierarchy gets the opportunity to handle the exception. This process continues until the exception is caught or reaches the top level of the program.

9. What is the purpose of custom exceptions?

To make code run faster

To create specific error types for your application

To replace all built-in exceptions

To prevent all errors from occurring

Custom exceptions allow developers to define specific error types tailored to their application's needs. This enhances error handling by providing more meaningful messages and context, making debugging easier and improving overall code clarity. They enable the differentiation of error scenarios, allowing for more precise responses to various issues that may arise during execution.

Explanation

Custom exceptions allow developers to define specific error types tailored to their application's needs. This enhances error handling by providing more meaningful messages and context, making debugging easier and improving overall code clarity. They enable the differentiation of error scenarios, allowing for more precise responses to various issues that may arise during execution.

10. Which is an unchecked exception in Java?

IOException

SQLException

RuntimeException

FileNotFoundException

Unchecked exceptions in Java are those that do not require explicit handling, such as being caught or declared. RuntimeException, which includes various exceptions like NullPointerException and ArrayIndexOutOfBoundsException, falls into this category. In contrast, IOException, SQLException, and FileNotFoundException are checked exceptions that must be handled during compile time.

Explanation

Unchecked exceptions in Java are those that do not require explicit handling, such as being caught or declared. RuntimeException, which includes various exceptions like NullPointerException and ArrayIndexOutOfBoundsException, falls into this category. In contrast, IOException, SQLException, and FileNotFoundException are checked exceptions that must be handled during compile time.

11. When should you use a try-catch block?

For every single line of code

Only when you expect an exception might occur

Never; errors should always crash the program

Only in the main method

A try-catch block should be used selectively, specifically around code that may throw exceptions. This approach allows for graceful error handling without cluttering the entire codebase, ensuring that only potentially problematic sections are monitored, while the rest of the code can execute normally without unnecessary overhead.

Explanation

A try-catch block should be used selectively, specifically around code that may throw exceptions. This approach allows for graceful error handling without cluttering the entire codebase, ensuring that only potentially problematic sections are monitored, while the rest of the code can execute normally without unnecessary overhead.

12. What happens if you catch a general Exception class?

It catches only specific exceptions

It catches all types of exceptions

It prevents the program from running

It only catches syntax errors

Catching a general Exception class in programming allows the code to handle any type of exception that may arise during execution. This includes not only specific exceptions but also unexpected ones, providing a safety net that prevents the program from crashing and enabling developers to implement error handling strategies effectively.

Explanation

Catching a general Exception class in programming allows the code to handle any type of exception that may arise during execution. This includes not only specific exceptions but also unexpected ones, providing a safety net that prevents the program from crashing and enabling developers to implement error handling strategies effectively.