Java Checked vs Unchecked Exceptions

In Java, an exception is an unwanted or unexpected event that occurs during the execution of a program, i.e., at run time, that disrupts the normal flow of the program’s instructions. In Java, there are two types of exceptions:

• Checked Exception: These exceptions are checked at compile time, forcing the programmer to handle them explicitly.
• Unchecked Exception: These exceptions are checked at runtime and do not require explicit handling at compile time.

Difference Between Checked and Unchecked Exceptions

Checked Exceptions in Java

Checked Exceptions are exceptions that are checked at compile time. If a method throws a checked Exception, then the exception must be handled using a try-catch block and declared the exception in the method signature using the throw keyword.

Types of Checked Exception

• Fully Checked Exception: A checked exception where all its child classes are also checked (e.g., IOException, InterruptedException).
• Partially Checked Exception: A checked exception where some of its child classes are unchecked (e.g., Exception).

Checked exceptions represent invalid conditions in areas outside the immediate control of the program like memory, network, file system, etc. Any checked exception is a subclass of Exception. Unlike unchecked exceptions, checked exceptions must be either caught by the caller or listed as part of the method signature using the throws keyword.

Example:

// Java Program to Illustrate Checked Exceptions
// Where FileNotFoundException occurs
import java.io.*;

class Geeks 
{
    public static void main(String[] args) 
    {
        // Getting the current root directory
        String root = System.getProperty("user.dir");
        System.out.println("Current root directory: " + root);

        // Adding the file name to the root directory
        String path = root + "\\message.txt";
        System.out.println("File path: " + path);

        // Reading the file from the path in the local directory
        FileReader f = new FileReader(path);

        // Creating an object as one of the ways of taking input
        BufferedReader b = new BufferedReader(f);

        // Printing the first 3 lines of the file "C:\user\message.txt"
        for (int counter = 0; counter < 3; counter++)
            System.out.println(b.readLine());

        // Closing file connections
        // using the close() method
        f.close();
    }
}

Output: 

To fix the above program, we either need to specify a list of exceptions using throws, or we need to use a try-catch block. We have used throws in the below program. Since FileNotFoundException is a subclass of IOException, we can just specify IOException in the throws list and make the above program compiler-error-free.

Example:

// Handling Checked Exceptions
import java.io.*;
class Geeks {

    public static void main(String[] args) throws IOException {

        // Getting the current root directory
        String root = System.getProperty("user.dir");
        System.out.println("Current root directory: " + root);

        // Adding the file name to the root directory
        String path = root + "\\message.txt";
        System.out.println("File path: " + path);

        // Reading the file from the path in the local directory
        try {
            FileReader f = new FileReader(path);

            // Creating an object as one of the ways of taking input
            BufferedReader b = new BufferedReader(f);

            // Printing the first 3 lines of the file 
            // "C:\\Devanshu\\JAVACODES\\message.txt"
            for (int counter = 0; counter < 3; counter++)
                System.out.println(b.readLine());

            // Closing file connections
            // using the close() method
            f.close();
        } catch (FileNotFoundException e) {
            System.out.println("File not found: " + e.getMessage());
        } catch (IOException e) {
            System.out.println("An I/O error occurred: " + e.getMessage());
        }
    }
}

Output: 

Note: If you are running this code on Linux/macOS, use the correct path format i.e. /home/user/test/a.txt

Explanation: In the above program we create a Java programme which reads a file from the same directory this programme may throw exceptions like FileNotFoundException or IOException so we handle it using the try-catch block to handle the exceptions and execute the programme without any interruption.

Unchecked Exceptions in Java

Unchecked exception are exceptions that are not checked at the compile time. In Java, exceptions under Error and RuntimeException classes are unchecked exceptions, everything else under throwable is checked. 

Consider the following Java program. It compiles fine, but it throws an ArithmeticException when run. The compiler allows it to compile because ArithmeticException is an unchecked exception.

Example: Java program to illustrate the Runtime Unchecked Exception.

// Java Program to Illustrate Un-checked Exceptions
class Geeks {
    public static void main(String args[]) {
      
        // Here we are dividing by 0
        // which will not be caught at compile time
        // as there is no mistake but caught at runtime
        // because it is mathematically incorrect
        int x = 0;
        int y = 10;
        int z = y / x;
    }
}

Output:

Note:

• Unchecked exceptions are runtime exceptions that are not required to be caught or declared in a throws clause.
• These exceptions are caused by programming errors, such as attempting to access an index out of bounds in an array or attempting to divide by zero.
• Unchecked exceptions include all subclasses of the RuntimeException class, as well as the Error class and its subclasses.

The separation into checked and unchecked exceptions sounded like a good idea at the time. Over the years, it has introduced more boilerplate and less aesthetically pleasing code patterns than it solved real problems. The typical pattern within the Java ecosystem is to hide the checked exception within an unchecked one.

Example:

try {
// Some I/O operation here
} catch( final IOException ex ) {
throw new RuntimeException( "I/O operation failed", ex );
}