Currently Empty: ₹0.00
Java Exception Handling: A Comprehensive Overview
Exception handling is a critical aspect of Java programming, allowing developers to gracefully manage unexpected situations during program execution. In Java, exceptions are categorized into two main types: built-in exceptions provided by the Java platform and user-defined exceptions created by developers.
User-defined Exceptions: Java allows developers to create their own custom exceptions by extending the Exception class. This can be useful for handling application-specific error conditions.
Creating a User-defined Exception:To create a custom exception, developers can define a new class that extends Exception or one of its subclasses.
public class MyCustomException extends Exception {
public MyCustomException(String message) {
super(message);
}
}
Throwing User-defined Exceptions:Developers can throw their custom exceptions using the throw keyword.
try {
// code that may trigger a custom exception
throw new MyCustomException(“This is a custom exception”);
} catch (MyCustomException e) {
// handle the custom exception
}
public class MyCustomException extends Exception {
public MyCustomException(String message) {
super(message);
}Throwing User-defined Exceptions:Developers can throw their custom exceptions using the throw keyword.
try {
// code that may trigger a custom exception
throw new MyCustomException("This is a custom exception");
} catch (MyCustomException e) {
// handle the custom exception
}
Built-in Exceptions
1. Unchecked Exceptions:Also known as runtime exceptions, they are not required to be caught or declared explicitly.
Examples:
- NullPointerException
- ArrayIndexOutOfBoundsException
- ArithmeticException
2. Checked Exceptions:These exceptions must be either caught or declared in the method signature using the throws keyword.
Examples:
- IOException
- SQLException
3. Errors:These are exceptional situations that are typically beyond the control of the programmer.
Examples:
- OutOfMemoryError
- StackOverflowError
Best Practices in Exception Handling
Effective exception handling is crucial for writing robust and maintainable code. Some best practices include:
- Catch Specific Exceptions: Catch specific exceptions rather than using a generic Exception catch block. This allows for more targeted error handling.
- Use Finally Block: The finally block ensures that cleanup code runs, whether an exception occurs or not.
- Logging: Utilize logging frameworks to log exception details. This aids in troubleshooting and debugging.
- Handle Exceptions Appropriately: Choose between catching, declaring, or throwing exceptions based on the nature of the exception and the program’s requirements.
1. What is Exception? Benefits of using Exception in a program?
An exception is an abnormal event that occurs during the execution of a program, disrupting the normal flow of instructions. Exception handling is a mechanism to handle these abnormal situations.
Benefits:
Improves code readability.
Separates normal code from error-handling code.
Enables a more robust and fault-tolerant program.
Code Example :
:try {
// code that may throw an exception
} catch (Exception e) {
// handle the exception
}2. What is Error? How does it differ from Exception? Difference between Error and Exception?
An error is a severe issue that typically cannot be handled by the program. It often leads to the termination of the program. Exceptions, on the other hand, are recoverable and can be handled.
Difference:Errors are generally caused by the environment, whereas exceptions are caused by the program itself.
Code Example:
try {
// code that may throw an exception
} catch (Error e) {
// handle the error
}3. What’s the superclass/interface of all exceptions/errors? Or Which class is the root class/Base Class for all types of errors and exceptions in Exception Hierarchy?
The superclass of all exceptions is java.lang.Throwable. Both Error and Exception classes extend from Throwable.
Code Example:
try {
// code that may throw an exception
} catch (Throwable t) {
// handle throwable (can catch both errors and exceptions)
}4. What are the different types of exceptions is there > explain with an example?
There are two main types: Checked Exceptions and Unchecked Exceptions. Checked exceptions are checked at compile-time, and unchecked exceptions are checked at runtime.
Code Example:
try {
// code that may throw a checked exception
} catch (CheckedExceptionce) {
// handle the checked exception
}5. What are the two types of Exceptions in Java? Which are the differences between them?
The two types are Checked Exceptions and Unchecked Exceptions. Checked exceptions must be either caught or declared in the method signature, whereas unchecked exceptions do not need such obligations.
Code Example:
try {
// code that may throw an unchecked exception
} catch (UncheckedExceptionue) {
// handle the unchecked exception
}6. What is Checked/Compile Time Exception and Unchecked/Runtime Exception with an example?
Checked exceptions are checked at compile-time, and the compiler enforces handling or declaration. Unchecked exceptions are checked at runtime and do not require explicit handling.
Code Example:
// Checked Exception (Compile Time)
public void methodWithCheckedException() throws CheckedException {
// code that may throw a checked exception
}
// Unchecked Exception (Runtime)
public void methodWithUncheckedException() {
// code that may throw an unchecked exception
}7. What does it mean by exception Handling?
Exception handling is the process of dealing with exceptions or errors that may occur during the execution of a program. It involves detecting, catching, and responding to exceptions to ensure a smooth program flow.
Code Example:
try {
// code that may throw an exception
} catch (Exception e) {
// handle the exception
}8. What is the mechanism for handling exceptions in Java?
The mechanism involves using try, catch, and optionally finally blocks. The try block contains the code that may throw an exception, the catch block handles the exception, and the finally block is used for cleanup code that should execute regardless of whether an exception occurs.
Code Example:
try {
// code that may throw an exception
} catch (Exception e) {
// handle the exception
} finally {
// cleanup code (optional)
}9. Describe the use of Try, Catch & Finally Block?
The try block contains the code where an exception might occur. The catch block handles the exception, providing a way to respond to the error. The finally block contains code that will be executed regardless of whether an exception occurs or not.
Code Example:
try {
// code that may throw an exception
} catch (Exception e) {
// handle the exception
} finally {
// cleanup code (optional)
}10. What’s JDK7 features try with Resource?
JDK7 introduced the try-with-resources statement, which simplifies resource management by automatically closing resources (like IO streams) when they are no longer needed. Resources must implement the AutoCloseable interface.
Code Example:
try (FileReader reader = new FileReader("file.txt")) {
// code that uses the reader
} catch (IOException e) {
// handle the exception
}11. What’s user-defined exception and Write your custom exception?
User-defined exceptions are exceptions created by the programmer to represent specific error conditions in their application. To create a custom exception, a new class should extend the Exception class or its subclasses.
Code Example:
public class MyCustomException extends Exception {
// additional custom exception code
}12. How to write user-defined compile-time and Runtime Custom Exception?
For a compile-time custom exception, extend Exception or its subclasses. For a runtime custom exception, extend RuntimeException or its subclasses.
Code Example:
// Compile-time custom exception
public class MyCompileTimeException extends Exception {
// additional code
}
// Runtime custom exception
public class MyRuntimeException extends RuntimeException {
// additional code
}13. What are the different keywords in Exception handling in Java?
: Keywords include try, catch, finally, throw, and throws
try {
// code that may throw an exception
} catch (Exception e) {
// handle the exception
} finally {
// cleanup code (optional)
}14. What is the difference between throws and throw keywords in Java?
Throws is used in method declarations to indicate that the method might throw certain exceptions. throw is used to throw a specific exception manually.
Code Example:
public void myMethod() throws MyException {
// code that may throw MyException
}
public void anotherMethod() {
throw new MyException();
}
15. How to differentiate between the finally, final, and finalize keywords?
It is a block used in exception handling. Code within the finally block will be executed regardless of whether an exception is thrown or not.
final: It is a keyword used to declare a variable, method, or class that cannot be modified. Once assigned, the value of a final variable cannot be changed, and a final method or class cannot be overridden or extended.
finalize: It is a method in the Object class that gets called by the garbage collector before an object is garbage collected.
Code Example:
// finally block
try {
// code that may throw an exception
} catch (Exception e) {
// handle the exception
} finally {
// cleanup code (optional)
}
// final keyword
final int x = 10;
// finalize method
protected void finalize() {
// cleanup code before garbage collection
}16. What is a stack trace in Java, and why is it important in exception handling?
A stack trace is a detailed report of the call stack at a specific point in time during the execution of a program. It shows the sequence of method calls that led to the point where the exception occurred. It helps in identifying the root cause of the exception.
Code Example:
try {
// code that may throw an exception
} catch (Exception e) {
e.printStackTrace(); // prints the stack trace to the console
}17. Is Java support nested try-catch block? What is a nested try-catch block?
Yes, Java supports nested try-catch blocks. A nested try-catch block is a try-catch block inside another try, catch, or finally block. It allows for more granular exception handling.
Code Example:
try {
// outer try block
try {
// inner try block
} catch (Exception e) {
// inner catch block
}
} catch (Exception ex) {
// outer catch block
}18. Is JAVA Support Multi-Catch Block? What is a multi-catch block in Java?
Yes, Java supports multi-catch blocks, introduced in Java 7. It allows a single catch block to handle multiple types of exceptions.
Code Example:
try {
// code that may throw multiple exceptions
} catch (IOException | SQLException e) {
// handle either IOException or SQLException
}19. What are chained exceptions in Java? Give an example and Real-time use in any application?
Chained exceptions allow one exception to be set as the cause of another. Real-time use: Logging the root cause while throwing a higher-level exception to maintain more detailed error information.
try {
// code that may throw an exception
} catch (IOException e) {
throw new MyCustomException("Error processing file", e);
}20. How do you catch Multiple Exceptions in a single block of code?
: Using a multi-catch block or catching each exception type separately within the same try-catch block.
Code Example:
try {
// code that may throw multiple exceptions
} catch (IOException | SQLException e) {
// handle either IOException or SQLException
}21. What will be the result of the main method throwing an exception?
If the main method throws an unhandled exception, the program terminates, and the exception details are printed to the console.
Code Example:
public static void main(String[] args) throws MyException {
// code that may throw MyException
}22. What are the best practices in Java exception handling?
Catch only exceptions you can handle.
- Provide meaningful error messages.
- Use specific exception types.
- Use the try-with-resources statement for resource management.
Code Example:
try (FileReader reader = new FileReader("file.txt")) {
// code that uses the reader
} catch (IOException e) {
// handle the exception with meaningful message
System.err.println("Error reading file: " + e.getMessage());
}23. How to use exception handling with method overriding?
When overriding a method in a subclass, the overridden method can declare the same or subclass exceptions. It cannot declare broader exceptions.
Code Example:
class Parent {
void myMethod() throws ParentException {
// code that may throw ParentException
}
}
class Child extends Parent {
@Override
void myMethod() throws ChildException {
// code that may throw ChildException
}
}24. Does finally run always? In which case finally doesn’t run?
finally block runs almost always, except when the program exits due to a call to System.exit() or if the JVM crashes.
Code Example:
try {
// code that may throw an exception
} catch (Exception e) {
// handle the exception
} finally {
// cleanup code (will run even if an exception occurs)
}25. How to get the current stack trace of a Thread?
: Using Thread.currentThread().getStackTrace() method to obtain the current stack trace.
Code Example:
StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
for (StackTraceElementelement :stackTrace) {
System.out.println(element);
}26. Difference between NoClassDefFoundError and ClassNotFoundException in Java?
NoClassDefFoundError: Occurs when a class was present during compilation but not found during runtime.
ClassNotFoundException: Occurs when trying to load a class dynamically using Class.forName() and the class is not found.
Code Example:
try {
Class.forName("NonExistentClass");
} catch (ClassNotFoundException e) {
// handle the ClassNotFoundException
}27. How to create custom Exceptions in Java?
Create a new class that extends Exception or its subclasses.
Code Example:
public class MyCustomException extends Exception {
// constructor
public MyCustomException (String errorMessage) {
super(errorMessage);
}
// additional custom exception code
}28. Can we have a try block without a catch?
Yes, a try block can be followed by either a catch block or a finally block or both.
Code Example:
try {
// code that may throw an exception
} finally {
// cleanup code (optional)
}29. What statements can exist in between try, catch, and finally blocks?
Any valid Java statements can exist between try, catch, and finally blocks.
Code Example:
try {
// code that may throw an exception
System.out.println("Inside try block");
} catch (Exception e) {
// handle the exception
System.out.println("Inside catch block");
} finally {
// cleanup code (optional)
System.out.println("Inside finally block");
}30. Can we throw an exception manually/explicitly?
Yes, exceptions can be thrown manually using the throw keyword.
Code Example:throw new MyCustomException(“This is a manual exception”);
32. Does the catch block rethrow an exception in Java?
Answer: Yes, a catch block can rethrow an exception using the throw statement.
Code Example:
try {
// code that may throw an exception
} catch (Exception e) {
// handle the exception
throw e; // rethrow the exception
}31. Why is it always recommended that cleanup activities like closing DB connections and I/O resources be kept inside a finally block?
The finally block ensures that certain code, like cleanup activities, is executed regardless of whether an exception occurs or not. It helps to prevent resource leaks and ensures proper resource management.
Code Example:
try {
// code that may throw an exception
} catch (Exception e) {
// handle the exception
} finally {
// cleanup code (e.g., close DB connections or release resources)
}32. What is ClassCastException in Exception Handling?
ClassCastException occurs when there is an attempt to cast an object to a class of which it is not an instance.
Code Example:
Object obj = "Hello"; Integer num = (Integer) obj; // ClassCastException: cannot cast String to Integer
33. When do we use the printStackTrace() method in Java?
The printStackTrace() method is used to print the stack trace of an exception to the console. It is often used for debugging purposes to understand where an exception occurred.
Code Example:
try {
// code that may throw an exception
} catch (Exception e) {
e.printStackTrace(); // prints the stack trace to the console
}34. Give some examples of Checked exceptions?
Checked exceptions are checked at compile-time. Examples include IOException, SQLException, and FileNotFoundException.
Code Example:
try {
// code that may throw a checked exception
} catch (IOException e) {
// handle the IOException
}35. Give some examples of Unchecked exceptions?
Unchecked exceptions are checked at runtime. Examples include NullPointerException, ArrayIndexOutOfBoundsException, and ArithmeticException.
Code Example:
try {
// code that may throw an unchecked exception
} catch (NullPointerException e) {
// handle the NullPointerException
}36. List the Methods in the Throwable class? And reason?
Some methods in the Throwable class include getMessage(), printStackTrace(), getCause(), and toString(). These methods provide information about the exception, making it easier to diagnose and handle errors.
Code Example:
try {
// code that may throw an exception
} catch (Exception e) {
System.out.println("Exception message: " + e.getMessage());
e.printStackTrace();
System.out.println("Exception cause: " + e.getCause());
System.out.println("Exception details: " + e.toString());
}37. What is a SQLException in Exception Handling?
: SQLException is a checked exception that occurs when there is an error in the database access code, typically related to SQL operations.
Code Example:
try {
// code that may throw a SQLException
} catch (SQLException e) {
// handle the SQLException
}38. . What is NumberFormatException in Java?
NumberFormatException is an unchecked exception that occurs when a method that converts a string to a numeric format encounters an inappropriate format.
Code Example:
try {
String str = "abc";
int num = Integer.parseInt(str); // NumberFormatException
} catch (NumberFormatException e) {
// handle the NumberFormatException
}39. What is ArrayIndexOutOfBoundsException in Java?
ArrayIndexOutOfBoundsException is an unchecked exception that occurs when trying to access an array element with an invalid index.
Code Example:
try {
int[] arr = new int[3];
int value = arr[5]; // ArrayIndexOutOfBoundsException
} catch (ArrayIndexOutOfBoundsException e) {
// handle the ArrayIndexOutOfBoundsException
}40. Is it legal to have an empty catch block?
Yes, it is legal to have an empty catch block, but it’s generally considered bad practice. An empty catch block may hide the details of an exception, making it difficult to diagnose and fix issues.
Code Example:
try {
// code that may throw an exception
} catch (Exception e) {
// empty catch block (not recommended)
}41. List some important methods of the Java Exception class? And the reason?
: Some important methods of the Exception class include getMessage(), printStackTrace(), getCause(), and toString(). These methods provide information about the exception, aiding in debugging and handling.
Code Example:
try {
// code that may throw an exception
} catch (Exception e) {
System.out.println("Exception message: " + e.getMessage());
e.printStackTrace();
System.out.println("Exception cause: " + e.getCause());
System.out.println("Exception details: " + e.toString());
}42. What is an unreachable catch block error in Java?
An unreachable catch block error occurs when the catch block is written for an exception that is not possible to be thrown within the corresponding try block. The compiler detects this as an error.
Code Example:
try {
// code that may throw IOException
} catch (SQLException e) {
// Unreachable catch block for SQLException (compile-time error)
}43. Can we provide statements after the finally block if the control is returning from the finally block itself?
No, statements placed after the finally block will not be executed if the control is returning from the finally block itself. The finally block always runs, and the control transfers directly to the calling method.
Code Example:
try {
// code that may throw an exception
} finally {
// cleanup code
return; // control returns from here, statements after this line will not be executed
}44. Does the finally block get executed if either try or catch blocks are returning the control?
Yes, the finally block gets executed even if either the try or catch blocks are returning the control. The finally block ensures cleanup code is executed regardless of how the control leaves the try-catch structure.
Code Example:
try {
// code that may throw an exception
return;
} finally {
// cleanup code (will run even if an exception occurs or control is returned from try block)
}45. What will happen if we override a superclass method that is throwing an unchecked exception with a checked exception in the subclass?
It will result in a compilation error. When overriding a method, the overriding method cannot throw broader checked exceptions than the overridden method.
Code Example:
class Parent {
void myMethod() throws RuntimeException {
// code
}
}
class Child extends Parent {
// Compilation error: overridden method does not throw RuntimeException or its subclass
void myMethod() throws Exception {
// code
}
}46. Why does an exception occur in the program?
Exceptions occur in a program due to unexpected conditions or errors during runtime. These conditions may include invalid input, resource unavailability, or other issues that disrupt the normal flow of the program.
47. What does JVM do when an exception occurs in a program?
When an exception occurs, the JVM looks for an appropriate exception handler. If found, it transfers control to the handler. If not, the program terminates, and the JVM prints a detailed stack trace, including the exception details.
48. What will happen to the exception object after exception handling is done?
After exception handling is done, the exception object is not automatically destroyed. It may be collected by the garbage collector if there are no references to it, or it may persist if there are references or if it’s part of an active exception handling mechanism.
49. How will you handle the checked exception?
Checked exceptions are typically handled by either catching them using a try-catch block or declaring them in the method signature using the throws clause. Alternatively, they can be addressed by implementing appropriate error-handling strategies.
Code Example:
try {
// code that may throw a checked exception
} catch (CheckedExceptionce) {
// handle the checked exception
}50. Which exception class can you use in the catch block to handle both checked and unchecked exceptions?
To handle both checked and unchecked exceptions in a generic way, you can use the base class Exception in the catch block.
Code Example:
try {
// code that may throw an exception
} catch (Exception e) {
// handle both checked and unchecked exceptions
}51. Can we throw checked exceptions from the static block?
Yes, checked exceptions can be thrown from the static block. However, the method containing the static block needs to declare the exception using the throws clause.
Code Example:
class MyClass {
static {
try {
// code that may throw a checked exception
} catch (CheckedExceptionce) {
// handle the checked exception
}
}
}52. Do checked exceptions occur at compile time?
Yes, checked exceptions are checked at compile time. The compiler enforces handling or declaration of checked exceptions in the method signature.
53. Are compile-time errors exceptions?
No, compile-time errors are not exceptions. Compile-time errors occur during the compilation phase and prevent the program from being successfully compiled. They are not part of the runtime exception handling mechanism.
54. What happens when a runtime exception occurs in a program?
When a runtime exception occurs, the normal flow of the program is disrupted, and the program terminates. The JVM prints a detailed stack trace, including information about the exception.
55. Do we have to always put a catch block after a try block?
No, it’s not mandatory to have a catch block after a try block. You can have a finally block without a catch block if you only want to execute cleanup code without explicitly handling the exception.
Code Example:
try {
// code that may throw an exception
} finally {
// cleanup code (will run even if an exception occurs)
}56. What are the three possible forms of the try block?
The three possible forms of the try block are:
try-catch: Contains code that may throw an exception, and it specifies how to handle the exception.
try-finally: Contains code that may throw an exception, and it specifies cleanup code that runs regardless of whether an exception occurs or not.
try-catch-finally: Contains code that may throw an exception, and it includes both exception handling and cleanup code.
Code Example:
// 1. try-catch
try {
// code that may throw an exception
} catch (Exception e) {
// handle the exception
}
// 2. try-finally
try {
// code that may throw an exception
} finally {
// cleanup code (will run even if an exception occurs)
}
// 3. try-catch-finally
try {
// code that may throw an exception
} catch (Exception e) {
// handle the exception
} finally {
// cleanup code (will run even if an exception occurs)
}57. Can we write statements between try block and catch block?
Yes, you can write statements between the try block and the catch block. These statements will be part of the normal flow of the program and will be executed before the catch block in case no exception occurs.
Code Example:
try {
// code that may throw an exception
System.out.println("Inside try block");
} catch (Exception e) {
// handle the exception
}58. Does a finally block override the value returned by the try or catch block?
No, a finally block does not override the value returned by the try or catch block. The value returned by the finally block is the one that is ultimately returned from the method.
Code Example:
public int myMethod() {
try {
// code that may return a value
return 42;
} finally {
// cleanup code in finally block
return 100; // overrides the value returned by the try block
}
}59. Can we throw multiple exceptions in one throw statement?
No, a single throw statement can only throw one exception at a time. If you need to throw multiple exceptions, you would need multiple throw statements.
Code Example:
if (condition) {
throw new MyException("This is the first exception");
} else {
throw new AnotherException("This is the second exception");
}60. What is rethrowing an exception in Java?
Rethrowing an exception means throwing the same exception again after catching it. This can be done using the throw statement in the catch block.
Code Example:
try {
// code that may throw an exception
} catch (Exception e) {
// handle the exception
throw e; // rethrow the same exception
}61. What is an error in Java? What are the types of errors in Java programming
In Java, errors are exceptional situations that are typically beyond the control of the programmer. Examples include OutOfMemoryError and StackOverflowError. Errors are not meant to be caught or handled by regular application code.
Code Example:
try {
// code that may result in an error (e.g., running out of memory)
} catch (Error e) {
// This is generally not recommended - errors are not meant to be caught
}62. State the difference between runtime error and syntax error (compile-time error).
Compile-time error (Syntax Error): Occurs during the compilation of the code when the syntax is incorrect or violates language rules. The code cannot be executed until the syntax errors are fixed.
Runtime Error: Occurs during the execution of the program and is related to incorrect or unexpected conditions during runtime. These errors are not detected by the compiler but surface during program execution.
63. Can we throw an exception explicitly or manually?
Yes, exceptions can be thrown explicitly or manually using the throw keyword. This allows the programmer to indicate that a particular exceptional condition has occurred.
Code Example:
throw new MyCustomException(“This is a manual exception”);
64. What’s an OutOfMemoryError? What are the steps you will take to resolve an OutOfMemoryError?
OutOfMemoryError occurs when the Java Virtual Machine (JVM) runs out of memory to allocate new objects. To resolve it, you can:
Increase heap size using -Xmx option.
Analyze and optimize memory usage.
Identify memory leaks and fix them.
Reduce the application’s memory footprint.
Code Example:
try {
// code that may result in OutOfMemoryError
} catch (OutOfMemoryError e) {
// handle or log the OutOfMemoryError
}65. What’s a StackOverflowError? What steps need to be taken to avoid StackOverflowError?
StackOverflowError occurs when the call stack grows beyond the limit. To avoid it, you can:
Optimize recursive algorithms.
Increase the stack size using -Xss option.
Use iteration instead of recursion for deep call hierarchies.
Code Example:
public static void recursiveMethod() {
recursiveMethod(); // may result in StackOverflowError
}66. Are we allowed to use only try block without catch and finally blocks?
Yes, it is allowed to have a try block without catch and finally blocks. This is useful when you want to handle exceptions in a higher-level context or propagate them up the call stack.
Code Example:
try {
// code that may throw an exception
}67. What statements can exist in between try, catch, and finally blocks?
Any valid Java statements can exist between try, catch, and finally blocks. This includes variable declarations, method calls, and other executable statements.
Code Example:
try {
// code that may throw an exception
System.out.println("Inside try block");
} catch (Exception e) {
// handle the exception
} finally {
// cleanup code (optional)
System.out.println("Inside finally block");
}68. What is RuntimeException in Java? Give an example?
RuntimeException is a subclass of Exception representing exceptions that can occur during the normal operation of the Java Virtual Machine. Examples include NullPointerException, ArrayIndexOutOfBoundsException, etc.
Code Example:
try {
throw new NullPointerException("This is a runtime exception");
} catch (RuntimeException e) {
// handle the runtime exception
}69. What is a SQLException in Exception Handling?
SQLException is a checked exception that occurs when there is an error in the database access code, typically related to SQL operations.
Code Example:
try {
// code that may throw a SQLException
} catch (SQLException e) {
// handle the SQLException
}70. What is ArrayIndexOutOfBoundsException in Java?
ArrayIndexOutOfBoundsException is an unchecked exception that occurs when trying to access an array element with an invalid index.
Code Example:
try {
int[] arr = new int[3];
int value = arr[5]; // ArrayIndexOutOfBoundsException
} catch (ArrayIndexOutOfBoundsException e) {
// handle the ArrayIndexOutOfBoundsException
}71. What will happen if we override a superclass method which is throwing an unchecked exception with a checked exception in the subclass?
If a subclass overrides a superclass method and throws a checked exception broader than the one declared in the superclass, it will result in a compilation error. The overriding method must throw the same exception type or its subtype.
Code Example:
class Parent {
void myMethod() throws RuntimeException {
// code
}
}
class Child extends Parent {
// Compilation error: overridden method does not throw RuntimeException or its subclass
void myMethod() throws Exception {
// code
}
}72. How do we catch an exception?
Exceptions are caught using try-catch blocks. The code that may throw an exception is placed inside the try block, and the exception is handled in the corresponding catch block.
Code Example:
try {
// code that may throw an exception
} catch (Exception e) {
// handle the exception
}73. What will happen to the exception object after exception handling is done?
After exception handling is done, the exception object is not automatically destroyed. It may be collected by the garbage collector if there are no references to it, or it may persist if there are references or if it’s part of an active exception handling mechanism.
74. How will you handle the checked exception?
: Checked exceptions are typically handled by either catching them using a try-catch block or declaring them in the method signature using the throws clause. Alternatively, they can be addressed by implementing appropriate error-handling strategies.
Code Example:
try {
// code that may throw a checked exception
} catch (CheckedExceptionce) {
// handle the checked exception
}75. Can we throw checked exceptions from the static block?
Yes, checked exceptions can be thrown from the static block. However, the method containing the static block needs to declare the exception using the throws clause.
Code Example:
class MyClass {
static {
try {
// code that may throw a checked exception
} catch (CheckedExceptionce) {
// handle the checked exception
}
}
}76. Can we write statements between try block and catch block?
: Yes, you can write statements between the try block and the catch block. These statements will be part of the normal flow of the program and will be executed before the catch block in case no exception occurs.
Code Example:
try {
// code that may throw an exception
System.out.println("Inside try block");
} catch (Exception e) {
// handle the exception
}77. What are the steps you will take in order to resolve an OutOfMemoryError?
To resolve an OutOfMemoryError, you can take the following steps:
Increase heap size: Allocate more memory to the Java Virtual Machine (JVM) using the -Xmx option.
Analyze and optimize memory usage: Identify and optimize memory-intensive parts of the code.
Identify and fix memory leaks: Use profiling tools to identify and fix memory leaks in the application.
Reduce memory footprint: Optimize data structures and algorithms to reduce overall memory consumption.
Code Example:
try {
// code that may result in OutOfMemoryError
} catch (OutOfMemoryError e) {
// handle or log the OutOfMemoryError
}78. What are the steps that need to be taken care of to avoid StackOverflowError?
To avoid StackOverflowError, you can take the following steps:
Optimize recursive algorithms: Ensure that recursive algorithms have a proper base case and termination condition.
Increase stack size: Adjust the stack size using the -Xss option if needed.
Use iteration: Consider converting recursive approaches to iterative ones for deep call hierarchies.
Code Example:
public static void recursiveMethod() {
recursiveMethod(); // may result in StackOverflowError
}79. What is a Memory Leak? How to find it in your Application?
A memory leak occurs when an application fails to release memory that is no longer needed, leading to a gradual increase in memory consumption. To find memory leaks:
Use profiling tools: Analyze memory usage with tools like VisualVM or YourKit.
Heap dumps: Capture and analyze heap dumps to identify objects that are not being garbage-collected.
Code review: Inspect the code for potential resource leaks, unclosed connections, or unmanaged resources.
Code Example:
// Hypothetical code with a memory leak
List<Object> list = new ArrayList<>(); // … add objects to the list, but forget to remove them
80. What is a SQLException in Exception Handling?
SQLException is a checked exception that occurs when there is an error in the database access code, typically related to SQL operations.
Code Example:
try {
// code that may throw a SQLException
} catch (SQLException e) {
// handle the SQLException
}81. What is throwing an exception in Java?
Throwing an exception in Java is the process of explicitly causing an exception to occur during the execution of a program. This is done using the throw keyword, followed by an instance of a subclass of Throwable (typically an exception object).
Code Example:
throw new MyException(“This is a custom exception”);
82. What will happen to the exception object after exception handling is done?
After exception handling is done, the exception object is not automatically destroyed. It may be collected by the garbage collector if there are no references to it, or it may persist if there are references or if it’s part of an active exception handling mechanism.
83. How will you handle the checked exception?
Checked exceptions are typically handled by either catching them using a try-catch block or declaring them in the method signature using the throws clause. Alternatively, they can be addressed by implementing appropriate error-handling strategies.
Code Example:
try {
// code that may throw a checked exception
} catch (CheckedExceptionce) {
// handle the checked exception
}84. Which exception class can you use in the catch block to handle both checked and unchecked exceptions?
To handle both checked and unchecked exceptions in a generic way, you can use the base class Exception in the catch block.
Code Example:
try {
// code that may throw an exception
} catch (Exception e) {
// handle both checked and unchecked exceptions
}85. Can we throw checked exceptions from the static block?
Yes, checked exceptions can be thrown from the static block. However, the method containing the static block needs to declare the exception using the throws clause.
Code Example:
class MyClass {
static {
try {
// code that may throw a checked exception
} catch (CheckedExceptionce) {
// handle the checked exception
}
}
}86. Can we write statements between the try block and catch block?
Yes, you can write statements between the try block and the catch block. These statements will be part of the normal flow of the program and will be executed before the catch block in case no exception occurs.
Code Example:
try {
// code that may throw an exception
System.out.println("Inside try block");
} catch (Exception e) {
// handle the exception
}87. Can we throw multiple exceptions in one throw statement?
No, a single throw statement can only throw one exception at a time. If you need to throw multiple exceptions, you would need multiple throw statements.
Code Example:
if (condition) {
throw new MyException("This is the first exception");
} else {
throw new AnotherException("This is the second exception");
}