exception handling in java interview questions

Welcome! 30 Java Exception Handling Interview Questions with a mix of easy, medium, and hard are included in this blog. Before moving on to the Java Exception Handling Interview Questions, let’s first become familiar with the fundamental ideas of Java.

What is java and it’s advantage:

Java is a popular, versatile, and object-oriented programming language developed by James Gosling and his team at Sun Microsystems in the 1990s. It is designed to be platform-independent, allowing developers to write code once and run it on any device or platform that supports Java, without needing to recompile the code. Java is widely used for building a variety of applications, from mobile and web applications to large-scale enterprise systems.

Advantages of Java:

1. Platform Independence: Java programs are compiled into bytecode, which can be executed on any Java Virtual Machine (JVM). This enables Java applications to run on any platform without modification, promoting the concept of “Write Once, Run Anywhere” (WORA).
2. Object-Oriented: Java is a pure object-oriented programming language, emphasizing code reusability, modularity, and extensibility. It supports encapsulation, inheritance, and polymorphism, allowing for the creation of robust and maintainable software systems.
3. Simplicity: Java was designed to be easy to use and learn. Its syntax is clear and concise, making it accessible for beginner programmers. Java also eliminates the complexity of managing pointers and memory allocation, providing automatic garbage collection.
4. Rich Standard Library: Java provides a vast collection of pre-built classes and libraries for various functionalities, such as networking, database connectivity, file handling, and graphical user interface (GUI) development. These libraries simplify and accelerate the development process.
5. Multithreading: Java supports multithreading, allowing the execution of multiple threads simultaneously. Multithreading is crucial for developing responsive and efficient applications, especially in the context of modern, multi-core processors.
6. Security: Java has built-in security features to protect against viruses, tampering, and unauthorized access. It includes a robust security manager and a set of APIs for secure communication, authentication, and access control.
7. Distributed Computing: Java supports distributed computing through Remote Method Invocation (RMI) and Java Message Service (JMS), making it well-suited for building scalable and distributed applications.
8. Dynamic: Java applications can adapt and modify themselves dynamically, allowing for runtime loading of classes and libraries. This capability is valuable for applications requiring extensibility and flexibility.
9. Community Support: Java has a vast and active community of developers, providing extensive resources, forums, and open-source libraries. The community support ensures continuous improvements, bug fixes, and a wealth of knowledge for developers.
10. Enterprise-level Scalability: Java’s robustness and scalability make it a preferred choice for large-scale enterprise applications. It is widely used in banking, e-commerce, telecommunications, and various other domains requiring high performance and reliability.

These advantages have contributed to Java’s enduring popularity and its widespread adoption in various domains, making it one of the most influential programming languages in the software industry.

Q 1: What is exception in java with example?

In Java, an exception is an event that disrupts the normal flow of a program’s instructions during execution. Exceptions are used to handle errors and other exceptional events that can occur in a Java program. When an exceptional event occurs, an object representing that exception is created and thrown in the method that caused the error.

Here’s a basic overview of exceptions in Java:

1. Throwing an Exception: You can throw an exception explicitly using the throw keyword. For example, you might throw an exception if a certain condition is not met:

if(someConditionIsNotMet) {
    throw new Exception("This is an error message");
}

2. Catching an Exception: Exceptions are caught using try, catch, and finally blocks. Code that might throw an exception is enclosed within a try block, and if an exception occurs, it’s caught and handled in a corresponding catch block:

try {
    // code that might cause an exception
} catch (Exception e) {
    // handle the exception
    System.out.println("An exception occurred: " + e.getMessage());
} finally {
    // code that will be executed regardless of whether an exception occurred or not
}

In the catch block, you can handle the exception, log the error, or take any necessary corrective action.

Types of Exceptions

Types of Exceptions: There are two main types of exceptions in Java: checked exceptions and unchecked exceptions.

1. Checked Exceptions (Compile time Exceptions)
2. Unchecked Exceptions (Runtime Exceptions)

1. Checked Exceptions: These are exceptions that are checked at compile-time. If a method is capable of causing a checked exception, it must declare that it throws the exception using the throws keyword.

public void readFile() throws IOException {
    // code that might throw IOException
}

2. Unchecked Exceptions (Runtime Exceptions): These are exceptions that are not checked at compile-time. They extend the RuntimeException class. Examples include NullPointerException, ArrayIndexOutOfBoundsException, etc. Methods are not required to declare that they may throw unchecked exceptions.

public void divide(int a, int b) {
    if (b == 0) {
        throw new ArithmeticException("Division by zero is not allowed");
    }
    int result = a / b;
    System.out.println("Result: " + result);
}

Unchecked exceptions are often caused by bugs in the code (such as trying to access an array element that doesn’t exist), while checked exceptions are usually related to external factors, like file I/O operations or network connections.

Custom Exceptions

Custom Exceptions: You can also create your own custom exceptions by extending the Exception class or any of its subclasses. Custom exceptions allow you to define specific exception types for your application.

class CustomException extends Exception {
    CustomException(String message) {
        super(message);
    }
}

And then you can throw and catch your custom exception like any other exception.

Exceptions in Java provide a way to handle errors and exceptional situations gracefully, allowing the program to recover or terminate without crashing. They are an essential part of Java’s error handling mechanism, ensuring robust and reliable applications.

Q 2: what is exception handling in java with example?

Exception handling in Java is a mechanism used to handle runtime errors (exceptions) gracefully, allowing the program to recover from unexpected situations without crashing. Java provides a robust exception handling mechanism through the use of try, catch, finally, throw, and throws keywords.

Basic Exception Handling Structure:

try {
    // Code that might cause an exception
} catch (ExceptionType e) {
    // Code to handle the exception
} finally {
    // Code that will be executed regardless of whether an exception occurred or not
}

Here’s an explanation of the keywords and their roles:

• try Block: The code that might throw an exception is placed inside the try block.
• catch Block: If an exception occurs within the try block, it is caught and handled in the corresponding catch block. The catch block specifies the type of exception it can handle. You can have multiple catch blocks to handle different types of exceptions.
• finally Block: The finally block contains code that will be executed regardless of whether an exception occurred or not. It is often used for cleanup tasks, such as closing files or releasing resources.
• throw Keyword: The throw keyword is used to explicitly throw an exception. You can throw either a built-in exception or a custom exception.
• throws Keyword: The throws keyword is used in method declarations to indicate that the method might throw certain exceptions. It notifies the caller that they need to handle those exceptions.

Example of Exception Handling:

import java.util.InputMismatchException;
import java.util.Scanner;
/*
 * Author: Zameer Ali Mohil
 * */
public class ExceptionHandlingExample {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        try {
            System.out.print("Enter a number: ");
            int num = scanner.nextInt(); // This might cause an InputMismatchException
            int result = 10 / num; // This might cause an ArithmeticException
            System.out.println("Result: " + result);
        } catch (InputMismatchException e) {
            System.out.println("Invalid input. Please enter a number.");
        } catch (ArithmeticException e) {
            System.out.println("Cannot divide by zero.");
        } finally {
            System.out.println("This block always executes, regardless of exceptions.");
            scanner.close();
        }
    }
}

In this example:

• The try block contains code that might throw InputMismatchException or ArithmeticException.
• The catch blocks handle these exceptions and provide appropriate error messages.
• The finally block closes the Scanner object, ensuring that it is always closed, even if an exception occurs.

Exception handling helps prevent program crashes due to unexpected situations, making Java programs more robust and reliable.

Q 3: Explain the try catch block?

Certainly! In Java, the try-catch block is used to handle exceptions. The try block contains the code that might throw an exception, and the catch block catches and handles the exception if it occurs. Here’s an example to demonstrate the usage of the try-catch block:

Example:

import java.util.Scanner;
/*
 * Author: Zameer Ali Mohil
 * */
public class ExceptionHandlingExample {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter a number: ");
        try {
            int num = scanner.nextInt(); // This might cause an InputMismatchException
            int result = 10 / num; // This might cause an ArithmeticException if num is 0
            System.out.println("Result: " + result);
        } catch (ArithmeticException e) {
            // Handle ArithmeticException (division by zero)
            System.out.println("Error: Division by zero is not allowed.");
        } catch (java.util.InputMismatchException e) {
            // Handle InputMismatchException (non-integer input)
            System.out.println("Error: Please enter a valid integer.");
        } finally {
            // Cleanup operations (closing resources, etc.) can go here
            scanner.close();
        }
    }
}

In this example:

• The try block contains the code that might throw exceptions (an InputMismatchException if a non-integer input is given and an ArithmeticException if the user inputs 0).
• The catch blocks handle specific exceptions. In this case, the program catches ArithmeticException and InputMismatchException separately and provides specific error messages for each type of exception.
• The finally block is optional and is used for cleanup operations. In this example, it closes the Scanner object, ensuring that it is always closed, regardless of whether an exception occurred or not.

This try-catch block structure allows the program to gracefully handle exceptions and provide meaningful error messages to the user, enhancing the user experience and preventing the program from crashing due to unexpected inputs.

Q 4: Can we write try block without catch block?

Yes, you can have a try block without a corresponding catch block, but it must be followed by either a catch block or a finally block. The finally block, if used, will always be executed, regardless of whether an exception is thrown or not. This is useful for cleanup operations, even if no exception occurs.

Here’s an example demonstrating a try block without a catch block, followed by a finally block:

/*
 * Author: Zameer Ali Mohil
 * */
public class TryWithoutCatchExample {
    public static void main(String[] args) {
        try {
            // Code that might cause an exception
            int result = 10 / 0; // This will throw an ArithmeticException
            System.out.println("Result: " + result); // This line will not be executed
        } finally {
            // Cleanup operations or code that always needs to be executed
            System.out.println("Finally block executed.");
        }
    }
}

In this example, the try block contains code that attempts to perform an illegal operation (dividing by zero), which results in an ArithmeticException. There is no catch block to handle this specific exception. However, the finally block will still be executed after the try block, allowing you to perform cleanup operations or any necessary tasks.

When you run the above code, it will throw an ArithmeticException and execute the finally block, producing the following output:

Finally block executed.
Exception in thread "main" java.lang.ArithmeticException: / by zero
    at TryWithoutCatchExample.main(TryWithoutCatchExample.java:6)

As you can see, the finally block is always executed, providing a way to ensure specific actions are taken, even in the presence of exceptions.

Q 5: Can we write try block without catch and finally block?

Yes, in Java, you can use a try block without a corresponding catch or finally block. However, it’s generally not recommended to have a try block without handling the exceptions (catch block) or performing cleanup operations (finally block), unless you are sure that the exceptions won’t be thrown or you are handling the exceptions somewhere else in your program.

Here’s an example of a try block without catch or finally:

/*
 * Author: Zameer Ali Mohil
 * */
public class TryWithoutCatchFinallyExample {
    public static void main(String[] args) {
        try {
            // Code that might cause an exception
            int result = 10 / 2; // No exception will be thrown here
            System.out.println("Result: " + result);
        } // No catch or finally block
    }
}

In this example, the try block performs a division operation that will not throw an exception. As there are no specific exceptions to catch and no cleanup operations in the finally block, the code will compile and run without errors.

However, it’s important to handle exceptions appropriately in real-world applications to ensure robust error handling and prevent unexpected program behavior. If an exception occurs in a try block and is not caught (or if there is no finally block for cleanup operations), the program might terminate abruptly, and the root cause of the problem might not be properly addressed. Therefore, it’s generally best practice to use try with catch or finally to handle exceptions and ensure proper cleanup in your Java programs.

Q 6: What is difference between throw, throws and throwable in Java?

In Java, throw, throws, and Throwable are related concepts that deal with exceptions. Let me explain each one individually:

1. throw:

throw is a keyword in Java used to explicitly throw an exception. When an exceptional situation arises in your code, you can use the throw keyword to throw an exception manually.

Example:

/*
 * Author: Zameer Ali Mohil
 * */
public class CustomExceptionExample {
    public static void main(String[] args) {
        try {
            int age = -1;
            if (age < 0) {
                throw new IllegalArgumentException("Age cannot be negative");
            }
        } catch (IllegalArgumentException e) {
            System.out.println("Caught exception: " + e.getMessage());
        }
    }
}

In this example, an IllegalArgumentException is thrown if the age is negative. The throw keyword is used to throw this exception.

2. throws:

throws is a keyword in Java used in method declarations to indicate that a method might throw a specific type of exception. It is used to declare exceptions but does not throw them. When you use the throws keyword in a method signature, you are telling the caller of that method that it might encounter those exceptions and needs to handle them.

Example:

public void readFile(String fileName) throws FileNotFoundException {
    // Code to read file
}

In this example, the readFile method declares that it might throw a FileNotFoundException. If a method has a throws clause, calling code must handle this exception (either using a try-catch block or declaring it in its own throws clause).

3. Throwable:

Throwable is the superclass of all errors and exceptions in Java. Both Error and Exception classes extend Throwable. You can catch objects of type Throwable to catch any exception or error.

Example:

/*
 * Author: Zameer Ali Mohil
 * */
public class CustomExceptionExample {
    public static void main(String[] args) {
        try {
            int result = divide(10, 0);
        } catch (Throwable t) {
            System.out.println("Caught Throwable: " + t.getMessage());
        }
    }

    public static int divide(int a, int b) {
        if (b == 0) {
            throw new ArithmeticException("Division by zero is not allowed");
        }
        return a / b;
    }
}

In this example, the divide method throws an ArithmeticException. The catch block catches Throwable, allowing it to catch both ArithmeticException (a subclass of Throwable) and other types of Throwable objects.

In summary:

• throw is used to throw an exception manually.
• throws is used in method declarations to indicate that the method might throw specific exceptions.
• Throwable is the superclass of all errors and exceptions in Java, and you can catch it to handle any type of exception or error.

Q 7: What is importance of finally block in java?

The finally block in Java is essential for several reasons. Let’s explore its importance with an example:

1. Resource Cleanup:

One of the most common uses of the finally block is to ensure that resources like files, database connections, or network sockets are properly closed, regardless of whether an exception occurs or not. This prevents resource leaks in your program.

Example:

FileWriter writer = null;
try {
    writer = new FileWriter("output.txt");
    // Code to write data to the file
} catch (IOException e) {
    System.out.println("Error writing to the file: " + e.getMessage());
} finally {
    try {
        if (writer != null) {
            writer.close(); // Close the file writer in the finally block
        }
    } catch (IOException e) {
        System.out.println("Error closing the file: " + e.getMessage());
    }
}

In this example, the finally block ensures that the FileWriter is closed, even if an exception occurs during writing.

2. Database Connections:

When working with databases, it’s crucial to close the database connections to prevent exhausting database resources. The finally block can be used to close the database connection, ensuring that it is always closed, even if an exception is thrown during database operations.

Example:

Connection connection = null;
try {
    connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mydatabase", "username", "password");
    // Code to perform database operations
} catch (SQLException e) {
    System.out.println("Database error: " + e.getMessage());
} finally {
    try {
        if (connection != null && !connection.isClosed()) {
            connection.close(); // Close the database connection in the finally block
        }
    } catch (SQLException e) {
        System.out.println("Error closing the connection: " + e.getMessage());
    }
}

In this example, the finally block ensures that the database connection is closed properly.

3. Cleanup and Reset Operations:

The finally block is useful for cleanup and reset operations, such as resetting flags or releasing other acquired resources. It allows you to maintain the program’s state and prepare it for further execution, regardless of exceptions.

Example:

boolean flag = false;
try {
    // Code that might modify the flag variable
} catch (Exception e) {
    System.out.println("Exception occurred: " + e.getMessage());
} finally {
    flag = false; // Reset the flag variable in the finally block
}

In this example, the finally block ensures that the flag variable is reset, even if an exception occurs in the try block.

In summary, the finally block is crucial for ensuring proper cleanup, releasing resources, and maintaining program integrity, especially in scenarios where exceptions might occur. It guarantees that essential cleanup operations are executed, making your Java programs more robust and reliable.

Q 8: What is Difference between checked and unchecked exception in java?

In Java, exceptions are categorized into two main types: checked exceptions and unchecked exceptions.

Checked Exceptions:

Checked exceptions are exceptions that are checked at compile-time. This means that the compiler forces you to handle these exceptions either by using a try-catch block or by declaring the exception using the throws keyword in the method signature. Checked exceptions typically represent external issues that a program should anticipate and recover from, such as file not found, database connectivity issues, or network problems.

Example of Checked Exception:

/*
 * Author: Zameer Ali Mohil
 * */
import java.io.FileReader;
import java.io.FileNotFoundException;

public class CheckedExample {
    public static void main(String[] args) {
        try {
            FileReader file = new FileReader("file.txt"); // This statement can throw FileNotFoundException
        } catch (FileNotFoundException e) {
            System.out.println("File not found: " + e.getMessage());
        }
    }
}

In this example, FileReader constructor can throw a FileNotFoundException, which is a checked exception. The compiler forces you to handle this exception using a try-catch block.

Unchecked Exceptions (Runtime Exceptions):

Unchecked exceptions, also known as runtime exceptions, are exceptions that are not checked at compile-time. These exceptions occur at runtime and are usually caused by programming bugs, such as null pointer access or dividing by zero. Unchecked exceptions are subclasses of RuntimeException and its subclasses.

Example of Unchecked Exception:

/*
 * Author: Zameer Ali Mohil
 * */
public class UncheckedExample {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3};
        System.out.println(numbers[4]); // This statement can throw ArrayIndexOutOfBoundsException
    }
}

In this example, accessing numbers[4] can throw an ArrayIndexOutOfBoundsException, which is an unchecked exception. You are not forced by the compiler to handle this exception, although you should handle it to ensure your program’s robustness.

Key Differences:

• Checked Exceptions:
  • Checked exceptions are checked at compile-time.
  • These exceptions extend Exception class but not RuntimeException.
  • You are forced to handle checked exceptions using try-catch or throws keywords.
  • Examples include IOException, SQLException, etc.
• Unchecked Exceptions:
  • Unchecked exceptions are not checked at compile-time.
  • These exceptions extend RuntimeException class.
  • You are not forced to handle unchecked exceptions, although it’s a good practice to handle them for program robustness.
  • Examples include NullPointerException, ArrayIndexOutOfBoundsException, ArithmeticException, etc.

In general, checked exceptions represent conditions that a well-written application should anticipate and recover from, while unchecked exceptions typically represent programming errors that should be fixed. Unchecked exceptions provide more flexibility to programmers but require careful handling to ensure the robustness of the application.