MCS024 : Question 2 (a) Exception Handling, Checked and Unchecked Exceptions in Java | June 2023 Paper Solution

Question 2. (a) Explain how exception handling is performed in Java. Briefly discuss the concept of checked exception and unchecked exception, with an example of each.

Answer:

Exception handling in Java helps deal with errors that can occur during program execution. Here's a simple explanation of how exception handling works, along with the concepts of checked and unchecked exceptions:

Exception Handling in Java:

In Java, when we write code, errors can occur. Exception handling allows us to catch and handle these errors gracefully, preventing our program from crashing. Here's how it works:

1. Try Block: We put the code that might cause an error inside a try block. If an error occurs within this block, Java looks for the corresponding catch block to handle it.

2. Catch Block: The catch block follows the try block. It specifies the type of error it can handle. If an error of that type occurs, the catch block is executed.

3. Finally Block: The finally block is optional. It comes after the try-catch blocks and is executed regardless of whether an error occurred or not. It is useful for performing cleanup tasks.


Checked Exception:
A checked exception is an error that Java knows might happen and requires us to handle it in our code. We need to either catch the exception using a catch block or declare it using the "throws" keyword.

Example of Checked Exception:
Let's say we want to read data from a file. If the file is not found, a FileNotFoundException occurs, which is a checked exception. Here's an example:


import java.io.FileReader;
import java.io.FileNotFoundException;

public class FileReadExample {
public static void main(String[] args) {
FileReader fileReader;
try {
fileReader = new FileReader("lawtantra.txt");
// Perform file reading operations
} catch (FileNotFoundException e) {
System.out.println("File not found: " + e.getMessage());
}
}
}


In this example, we try to create a FileReader object to read from a file named "lawtantra.txt". If the file is not found, a FileNotFoundException occurs. We catch the exception in the catch block and display an error message.


Unchecked Exception:
An unchecked exception is an error that Java doesn't expect or check at compile time. It usually occurs due to programming mistakes. We don't have to explicitly handle unchecked exceptions, although it's good practice to do so.

Example of Unchecked Exception:
Let's consider a division operation where we divide a number by zero, resulting in an ArithmeticException, an unchecked exception. Here's an example:

public class DivisionExample {
public static void main(String[] args) {
int a = 10;
int b = 0;
int result;
try {
result = a / b; // Division by zero
} catch (ArithmeticException e) {
System.out.println("Error: " + e.getMessage());
}
}
}


In this example, we divide the integer 'a' by zero, which causes an ArithmeticException. We catch the exception in the catch block and print an error message.


In summary, exception handling in Java allows for the detection and management of errors during program execution. Checked exceptions must be explicitly declared or handled, while unchecked exceptions do not require explicit handling. Understanding and appropriately handling exceptions is important for writing robust and reliable Java programs.