Exception Handling in Java: Quick Revision
Q. Exception Handling Hierarchy in Java

Exception handling in Java is based on a well-defined class hierarchy that categorizes various types of exceptions. All exception-related classes inherit from the Throwable class, which is the root of the hierarchy. Below is a detailed explanation of the exception handling hierarchy:

1. Throwable

The root class for all errors and exceptions in Java. It has two main subclasses:

2. Error (Unchecked)

Indicates critical problems that are beyond the application's control. Examples include:

3. Exception

Represents conditions that a program should catch and handle. It is further divided into:

4. Commonly Used Exception Subclasses

Some other important exceptions that are part of the hierarchy include:

Hierarchy Diagram

The hierarchy can be represented as:

Conclusion

Understanding the exception hierarchy helps developers identify the type of exceptions they need to handle and ensures efficient exception management. Checked exceptions enforce error handling during compile-time, while unchecked exceptions allow more flexibility at runtime.

Q. Explain Checked Exceptions and Unchecked Exceptions in Java

In Java, exceptions are categorized into Checked Exceptions and Unchecked Exceptions based on when they are checked by the compiler. Understanding this distinction is essential for effective exception handling.

1. Checked Exceptions

Checked exceptions are exceptions that are checked at compile-time. The compiler ensures that these exceptions are either handled using a try-catch block or declared in the method signature using the throws keyword. Must handle or declare them explicitly.

2. Unchecked Exceptions

Unchecked exceptions are exceptions that occur during runtime and are not checked by the compiler. These are subclasses of RuntimeException. No mandatory handling or declaration needed; should focus on writing bug-free code.

Key Differences Between Checked and Unchecked Exceptions
Feature Checked Exceptions Unchecked Exceptions
Definition Checked at compile-time. Checked at runtime.
Hierarchy Subclasses of Exception (excluding RuntimeException). Subclasses of RuntimeException.
Handling Must be handled or declared using throws. Handling is optional.
Examples IOException, SQLException. NullPointerException, ArithmeticException.
Common Use For recoverable conditions like file not found or database issues. For programming errors like accessing null objects or invalid indexes.

Checked Exception Example
import java.io.*;

public class CheckedExceptionExample {
    public static void readFile(String filePath) throws IOException {
        BufferedReader reader = new BufferedReader(new FileReader(filePath));
        System.out.println(reader.readLine());
        reader.close();
    }

    public static void main(String[] args) {
        try {
            readFile("test.txt");
        } catch (IOException e) {
            System.out.println("File not found: " + e.getMessage());
        }
    }
}
Unchecked Exception Example
public class UncheckedExceptionExample {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3};
        try {
            System.out.println(numbers[5]); // Causes ArrayIndexOutOfBoundsException
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Invalid array index: " + e.getMessage());
        }
    }
}
Q. Explain Try-Catch and Finally Block in Java

The try-catch and finally blocks are fundamental constructs in Java for handling exceptions. These blocks help ensure that a program can gracefully handle runtime errors and continue execution without crashing. Here’s a detailed explanation of their usage, scenarios, and common interview questions.

1. try-catch Block

The try block contains code that might throw an exception. The catch block is used to handle the exception that occurs in the try block. 

try {
    // Code that may throw an exception
    int result = 10 / 0; // ArithmeticException
} catch (ArithmeticException e) {
    System.out.println("Caught an exception: " + e.getMessage());
}
2. finally Block

The finally block contains code that will execute regardless of whether an exception was thrown or caught. It is typically used for cleanup operations such as closing resources. 

try {
    // Risky code
    int[] arr = {1, 2};
    System.out.println(arr[5]);
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("Exception handled: " + e);
} finally {
    System.out.println("This will always execute.");
}
3. Nested Try-Catch

You can nest try-catch blocks to handle exceptions at multiple levels. 

try {
    try {
        int[] arr = {1, 2};
        System.out.println(arr[2]); // Inner try block
    } catch (ArrayIndexOutOfBoundsException e) {
        System.out.println("Inner catch: " + e.getMessage());
    }
} catch (Exception e) {
    System.out.println("Outer catch: " + e.getMessage());
}
4. Scenarios 5. Common Interview Questions
  1. Can a try block exist without a catch block?

    Yes, a try block can exist without a catch block if a finally block is present.

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

    It will overwrite any exception thrown in the try or catch block, leading to the final exception being propagated.

  3. Can we write multiple catch blocks for a single try block?

    Yes, each catch block can handle a specific exception type.

  4. What is the order of execution for try-catch-finally?

    The order is try, then catch (if an exception occurs), followed by finally.

  5. Can we use finally without a try block?

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

  6. Can a catch block handle multiple exceptions?

    Yes, using multi-catch syntax (catch(Exception1 | Exception2 e)).

  7. What if a return statement is in both try and finally blocks?

    The return statement in the finally block will override the one in the try.

6. Advanced Examples

Multi-Catch Example:

try {
    int num = Integer.parseInt("abc");
    int result = 10 / 0;
} catch (NumberFormatException | ArithmeticException e) {
    System.out.println("Exception handled: " + e);
} finally {
    System.out.println("Execution complete.");
}

Returning from Finally Example:

public static int test() {
    try {
        return 10;
    } finally {
        return 20; // This return overrides the try block's return
    }
}
System.out.println(test()); // Output: 20
Conclusion

Understanding the nuances of try-catch and finally blocks is essential for effective exception handling in Java. Mastering these concepts will help in writing robust and error-resistant code.

Throw and Throws Keywords in Java

The throw and throws keywords in Java are used for exception handling but serve different purposes. While throw is used to explicitly throw an exception, throws is used to declare exceptions that a method might throw.

1. throw Keyword

The throw keyword is used to explicitly throw an exception during program execution. It is typically followed by an instance of an exception class. 

public class ThrowExample {
    public static void validateAge(int age) {
        if (age < 18) {
            throw new IllegalArgumentException("Age must be 18 or above");
        }
        System.out.println("Valid age");
    }

    public static void main(String[] args) {
        validateAge(16); // This will throw an exception
    }
}
2. throws Keyword

The throws keyword is used in method declarations to indicate that a method might throw certain exceptions. It allows the caller of the method to handle the exception. 

import java.io.IOException;

public class ThrowsExample {
    public static void readFile() throws IOException {
        throw new IOException("File not found");
    }

    public static void main(String[] args) {
        try {
            readFile();
        } catch (IOException e) {
            System.out.println("Exception handled: " + e.getMessage());
        }
    }
}
3. Differences Between throw and throws
Aspect throw throws
Purpose Used to explicitly throw an exception. Used to declare exceptions in the method signature.
Placement Inside a method or block. In the method declaration.
Exception Type Requires an instance of an exception. Specifies one or more exception types.
Runtime/Checked Can throw both checked and unchecked exceptions. Used only for checked exceptions.
Execution Directly throws the exception. Alerts the caller to handle the exception.

4. Key Interview Questions 5. Best Practices Conclusion

The throw and throws keywords complement each other in exception handling. Mastering their usage ensures robust and clean exception management in Java applications.

Custom Exceptions in Java

Custom exceptions are user-defined exceptions in Java that allow developers to create specific exceptions for their application’s requirements. By extending the Exception class or RuntimeException class, developers can create meaningful exception types to represent unique error conditions in their application.

1. Why Use Custom Exceptions? 2. Creating a Custom Exception

Custom exceptions can extend either Exception (for checked exceptions) or RuntimeException (for unchecked exceptions).

Example: A custom checked exception for invalid age input.

class InvalidAgeException extends Exception {
    public InvalidAgeException(String message) {
        super(message);
    }
}
3. Using a Custom Exception

After defining a custom exception, it can be used in a method or block of code to indicate an error condition. 

class CustomExceptionExample {
    public static void validateAge(int age) throws InvalidAgeException {
        if (age < 18) {
            throw new InvalidAgeException("Age must be 18 or above.");
        }
        System.out.println("Age is valid.");
    }

    public static void main(String[] args) {
        try {
            validateAge(16); // Throws InvalidAgeException
        } catch (InvalidAgeException e) {
            System.out.println("Exception caught: " + e.getMessage());
        }
    }
}
4. Custom Unchecked Exception

To create an unchecked exception, extend the RuntimeException class. These exceptions are not required to be declared in the method signature.

Example: A custom unchecked exception.

class InvalidInputException extends RuntimeException {
    public InvalidInputException(String message) {
        super(message);
    }
}

class UncheckedExceptionExample {
    public static void validateInput(String input) {
        if (input == null || input.isEmpty()) {
            throw new InvalidInputException("Input cannot be null or empty.");
        }
        System.out.println("Input is valid.");
    }

    public static void main(String[] args) {
        validateInput(""); // Throws InvalidInputException
    }
}
5. Key Interview Questions on Custom Exceptions 6. Best Practices for Custom Exceptions Conclusion

Custom exceptions enhance the clarity and maintainability of Java applications by allowing developers to handle domain-specific errors explicitly. By following best practices, developers can ensure their custom exceptions are both functional and easy to understand.

Multi-Catch Block in Java

The multi-catch block in Java, introduced in Java 7, allows a single catch block to handle multiple exception types. This helps reduce redundant code and improves readability by combining similar exception handling logic.

1. Syntax of Multi-Catch Block

Multiple exceptions can be caught in a single catch block by separating their types with a vertical bar |. 

try {
    // Code that may throw exceptions
} catch (ExceptionType1 | ExceptionType2 ex) {
    // Handle both ExceptionType1 and ExceptionType2
}
2. Example of Multi-Catch Block

Handling multiple exceptions in a single catch block:

public class MultiCatchExample {
    public static void main(String[] args) {
        try {
            int[] numbers = {1, 2, 3};
            System.out.println(numbers[5]); // Throws ArrayIndexOutOfBoundsException
            int result = 10 / 0;           // Throws ArithmeticException
        } catch (ArithmeticException | ArrayIndexOutOfBoundsException ex) {
            System.out.println("Exception caught: " + ex.getMessage());
        }
    }
}
3. Rules for Multi-Catch Block 4. Benefits of Multi-Catch Block 5. Limitations of Multi-Catch Block 6. Key Interview Questions Conclusion

Multi-catch blocks streamline exception handling by consolidating related exceptions. However, it is important to use them correctly, ensuring that the exceptions handled are independent and disjoint. They are a powerful tool for clean and concise error-handling code in Java.

Try-with-Resources in Java

The try-with-resources statement, introduced in Java 7, is a feature for managing resources such as streams, files, or database connections efficiently. It ensures that resources are closed automatically after they are no longer needed, reducing the risk of resource leaks.

1. Key Features of Try-with-Resources 2. Syntax of Try-with-Resources

Resources are declared within parentheses (()) in the try statement. 

try (ResourceType resource = new ResourceType()) {
    // Code that uses the resource
} catch (ExceptionType ex) {
    // Handle exceptions
}
3. Example: File Reading with Try-with-Resources

Below is an example of reading a file using BufferedReader:

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class TryWithResourcesExample {
    public static void main(String[] args) {
        try (BufferedReader reader = new BufferedReader(new FileReader("example.txt"))) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            System.out.println("Error reading file: " + e.getMessage());
        }
    }
}
4. How It Works 5. Multiple Resources in Try-with-Resources

You can manage multiple resources in a single try-with-resources block:

try (BufferedReader reader = new BufferedReader(new FileReader("file1.txt"));
     FileReader fileReader = new FileReader("file2.txt")) {
    // Code that uses reader and fileReader
} catch (IOException ex) {
    System.out.println("Error: " + ex.getMessage());
}
6. Example with Custom Resource

You can use try-with-resources for custom classes that implement AutoCloseable. 

class CustomResource implements AutoCloseable {
    public void useResource() {
        System.out.println("Using custom resource");
    }

    @Override
    public void close() {
        System.out.println("Closing custom resource");
    }
}

public class CustomResourceExample {
    public static void main(String[] args) {
        try (CustomResource resource = new CustomResource()) {
            resource.useResource();
        } catch (Exception e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}
7. Benefits of Try-with-Resources 8. Common Interview Questions Conclusion

Try-with-resources is an efficient and clean way to manage resources in Java, reducing the risk of resource leaks and simplifying error handling. It is particularly useful for file I/O, database connections, and other scenarios where resources need to be explicitly released.

Stack Trace in Java

A stack trace in Java is a diagnostic tool that provides a detailed breakdown of the call stack at the point where an exception occurred. It shows the sequence of method calls that led to the error, making it easier to debug and identify the source of the issue.

1. Structure of a Stack Trace

A stack trace contains:

Example: A sample stack trace:

Exception in thread "main" java.lang.NullPointerException: Cannot invoke "String.length()" because "str" is null
    at MainClass.main(MainClass.java:10)

This indicates a NullPointerException occurred at line 10 of the file MainClass.java, inside the main method.

2. Generating a Stack Trace

A stack trace is automatically printed when an unhandled exception occurs, but it can also be manually generated using the printStackTrace() method of the Throwable class. 

public class StackTraceExample {
    public static void main(String[] args) {
        try {
            String str = null;
            System.out.println(str.length()); // Throws NullPointerException
        } catch (NullPointerException e) {
            e.printStackTrace(); // Prints the stack trace
        }
    }
}
3. Analyzing a Stack Trace

Key points to analyze in a stack trace:

4. Stack Trace Methods

Java provides methods in the Throwable class to work with stack traces:

Example: Using getStackTrace():

public class GetStackTraceExample {
    public static void main(String[] args) {
        try {
            int result = 10 / 0; // Throws ArithmeticException
        } catch (ArithmeticException e) {
            for (StackTraceElement element : e.getStackTrace()) {
                System.out.println("Class: " + element.getClassName());
                System.out.println("Method: " + element.getMethodName());
                System.out.println("Line: " + element.getLineNumber());
            }
        }
    }
}
Difference Between Error and Exception in Java
Aspect Error Exception
Definition Errors represent serious problems that an application should not try to recover from. Exceptions represent conditions that an application might want to catch and handle.
Recoverability Not recoverable; usually requires program termination or external intervention. Recoverable by proper exception handling mechanisms like try-catch blocks.
Examples OutOfMemoryError, StackOverflowError, NoClassDefFoundError. IOException, NullPointerException, ArithmeticException.
Hierarchy Errors are subclasses of the Error class, which is part of java.lang. Exceptions are subclasses of the Exception class, which is part of java.lang.
Handling Mechanism Errors are not meant to be caught or handled in the application. Exceptions can and should be caught and handled using try-catch blocks.
Cause Usually caused by external factors or JVM issues, such as resource exhaustion. Usually caused by programming mistakes, invalid data, or predictable conditions.
Impact Generally causes the program to crash or halt execution abruptly. Does not necessarily halt the program; can be handled gracefully.
Understanding Unreachable Catch Block Error in Java

An "Unreachable Catch Block" error occurs in Java when a catch block is declared that will never be executed, because the exception it handles will never be thrown. This situation arises from the logical flow of the program and the type of exceptions being thrown by the methods invoked.

1. Causes of Unreachable Catch Block Error 2. Example Scenario 
public class UnreachableCatchBlockExample {
    public static void main(String[] args) {
        try {
            // This method may throw IOException or NullPointerException
            someMethod();
        } catch (IOException e) {
            System.out.println("Caught IOException");
        } catch (NullPointerException e) {
            System.out.println("Caught NullPointerException");
        }
    }

    public static void someMethod() {
        // This method might throw a FileNotFoundException which isn't caught
        // by any of the above catch blocks
        throw new FileNotFoundException("File not found");
    }
}

In the above example, the catch block for NullPointerException is unreachable because the method someMethod() only throws FileNotFoundException, which matches the catch block for IOException.

3. Solutions to Avoid Unreachable Catch Block Error
Understanding the Differences Between ClassNotFoundException and NoClassDefFoundError

Both exceptions are related to issues with class loading in Java, but they differ in their causes, how they are thrown, and their implications.

ClassNotFoundException NoClassDefFoundError
Understanding the Differences Between final, finally, and finalize Keywords in Java

In Java, final, finally, and finalize are keywords with distinct purposes and usages in the language.

1. final 2. finally 3. finalize Key Differences
Understanding Exception Propagation in Java

Exception propagation refers to the process of an exception being passed up the call stack until it is either caught and handled or reaches the main method and terminates the program.

Example Scenario Key Points about Exception Propagation
Best Practices for Java Exception Handling
Q. What are the rules we should follow when overriding a method throwing an Exception?
Rule 1: Exception Handling in Method Overriding

When overriding a method in Java, specific rules apply to exception handling. If the parent class method does not throw any exceptions, the overridden method in the child class must also avoid throwing checked exceptions. However, it is permissible for the overridden method to throw unchecked exceptions.

For example, consider two classes: `ParentDemo` and `ChildDemo`, where `ChildDemo` is a subclass of `ParentDemo`. The `doThis()` method in the parent class is overridden in the child class. The overridden method in `ChildDemo` can throw an unchecked exception like `IllegalArgumentException`. This is valid since unchecked exceptions are not subject to the same restrictions as checked exceptions. 

class ParentDemo {
    void doThis() {
        // No exceptions thrown here
    }
}

class ChildDemo extends ParentDemo {
    @Override
    void doThis() {
        throw new IllegalArgumentException("Unchecked exception");
    }
}
Rule 2: Exception Handling in Overridden Methods with Checked Exceptions

If a parent class method throws one or more checked exceptions, the overridden method in the child class has specific options for handling exceptions:

The following example demonstrates this rule:

    class ParentDemo {
        void doThis() throws IOException {
            // Method in the parent class throwing a checked exception
        }
    }
    
    class ChildDemo extends ParentDemo {
        @Override
        void doThis() throws FileNotFoundException {
            // FileNotFoundException is a subclass of IOException
        }
    }

In this example, the `doThis()` method in the `ParentDemo` class declares the checked exception `IOException`. The overridden `doThis()` method in the `ChildDemo` class is allowed to declare `FileNotFoundException`, a subclass of `IOException`, satisfying the rule.

Rule 3: Handling Unchecked Exceptions in Overridden Methods

If a parent class method declares a throws clause with unchecked exceptions, the overridden method in the child class can throw any number of unchecked exceptions, regardless of their relationship. The child method is not restricted to the same or related unchecked exceptions as the parent.

The following example illustrates this rule:

        class ParentDemo {
            void doThis() throws IllegalArgumentException {
                // Parent method throws an unchecked exception
            }
        }
        
        class ChildDemo extends ParentDemo {
            @Override
            void doThis() throws IllegalArgumentException, NullPointerException, ArithmeticException {
                // Child method can throw multiple unchecked exceptions
            }
        }

In this example, the `doThis()` method in the `ParentDemo` class throws a single unchecked exception, `IllegalArgumentException`. The overridden `doThis()` method in the `ChildDemo` class is allowed to throw additional unchecked exceptions, such as `NullPointerException` and `ArithmeticException`, without any restrictions.

Throwing an Exception Inside a Lambda Expression

Yes, it is possible to throw an exception inside a lambda expression's body. Here are the key points:

Example: Throwing an unchecked exception inside a lambda expression: 

        List list = Arrays.asList(2,3,5,10,20);
            list.forEach(i -> {
                if (i < 0) {
                    throw new IllegalArgumentException("Negative numbers are not allowed.");
                }
                System.out.println(i);
            });
Q. Are we allowed to use only try blocks without a catch and finally blocks?

Before Java 7, it was mandatory for a try block to be followed by either a catch or a finally block. A standalone try block was not allowed.

However, starting from Java 7, it became possible to use a try block without explicitly including catch or finally blocks by using the try-with-resources feature. This allows resource management for parameters that implement the AutoCloseable interface.

It is important to note that if the resources specified in the try-with-resources block do not implement the AutoCloseable interface, it will result in a compilation error.

Q. Does the Finally Block Always Execute in Java?

The finally block is designed to execute regardless of whether an exception occurs in the try or catch blocks. It ensures cleanup operations are performed.

However, there is one exception to this rule: if System.exit(0) is called within the try or catch block, the finally block will not execute. This is because System.exit(0) terminates the running JVM, preventing any further execution.

Q. What Happens to the Exception Object After Exception Handling?

Once exception handling is complete, the exception object becomes eligible for garbage collection. It will be removed from memory during the JVM's garbage collection process, as it is no longer referenced.

Can Checked Exceptions Be Thrown from a Static Block?

It is not possible to throw checked exceptions from a static block. However, you can include try-catch logic within the static block to handle exceptions locally.

Checked exceptions cannot be propagated from static blocks because these blocks are executed by the JVM during class loading, and they are not invoked by any method at runtime.

What Happens When an Exception Is Thrown by the Main Method?

If an exception is thrown by the main() method and is not handled, the Java Runtime terminates the program. The exception message, along with the stack trace, is displayed on the system console to help identify the cause of the error.