Java Programming Types Of Exceptions Checked Vs Unchecked Complete Guide

Step 1: Introduction to Exceptions

An exception is an event that disrupts the normal flow of a program's execution. Java divides exceptions into two categories:

• Checked Exceptions: These are exceptions that the compiler forces you to handle or declare.
• Unchecked Exceptions: These are exceptions that are not checked at compile-time; they include runtime exceptions and errors.

Step 2: Setting Up Your Java Development Environment

Ensure you have a Java Development Kit (JDK) installed and an IDE like Eclipse, IntelliJ IDEA, or a simple text editor with command-line tools.

Step 3: Creating Sample Java Project

Create a new Java project in your IDE with the class name ExceptionTypesDemo.

public class ExceptionTypesDemo {
    public static void main(String[] args) {
        // Code goes here
    }
}

Step 4: Handling Checked Exceptions (FileNotFoundException)

Let's create a method that reads a file from the filesystem. This will throw a FileNotFoundException, which is a checked exception.

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

public class ExceptionTypesDemo {
    public static void main(String[] args) {
        try {
            readFile("example.txt");
        } catch (FileNotFoundException e) {
            System.out.println("File not found: " + e.getMessage());
        } catch (IOException e) {
            System.out.println("IO Error occurred: " + e.getMessage());
        }
    }

    public static void readFile(String fileName) throws FileNotFoundException, IOException {
        BufferedReader reader = new BufferedReader(new FileReader(fileName));
        String line;
        while ((line = reader.readLine()) != null) {
            System.out.println(line);
        }
        reader.close();
    }
}

Explanation:

• The FileReader constructor can throw a FileNotFoundException, which is a checked exception. Therefore, we need to handle it either within the method (using a try-catch block) or declare it in the method signature with throws.
• The readLine() and close() methods of BufferedReader can throw IOException, another checked exception.
• In the main method, we handle these exceptions using try-catch blocks.

Step 5: Throwing Unchecked Exceptions (NullPointerException)

Unchecked exceptions are derived from RuntimeException. They do not need to be declared or handled explicitly.

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

public class ExceptionTypesDemo {
    public static void main(String[] args) {
        try {
            readFile("example.txt");
            handleNullPointer(null);
        } catch (FileNotFoundException e) {
            System.out.println("File not found: " + e.getMessage());
        } catch (IOException e) {
            System.out.println("IO Error occurred: " + e.getMessage());
        } catch (NullPointerException e) {
            System.out.println("Null pointer encountered: " + e.getMessage());
        }
    }

    public static void readFile(String fileName) throws FileNotFoundException, IOException {
        BufferedReader reader = new BufferedReader(new FileReader(fileName));
        String line;
        while ((line = reader.readLine()) != null) {
            System.out.println(line);
        }
        reader.close();
    }

    public static void handleNullPointer(String input) {
        // This will throw a NullPointerException because we're trying to call a method on a null object
        int length = input.length();  
        System.out.println("The length of input string is: " + length);
    }
}

Explanation:

• We added a new method handleNullPointer that attempts to get the length of a null string.
• A NullPointerException is thrown at runtime because we attempted to access a method (length()) on a null reference.
• Since NullPointerException is unchecked, we don't need to declare it in the method signature (throws NullPointerException), although we can choose to do so if needed.
• We handle this exception in the main method using a catch block.

Step 6: Compiling and Running the Program

Save the file and run it.

javac ExceptionTypesDemo.java
java ExceptionTypesDemo

Expected Output if the file does not exist:

File not found: example.txt

Expected Output if the file exists but no null handling occurs:

Contents of the file... (if any)
Exception in thread "main" java.lang.NullPointerException
    at ExceptionTypesDemo.handleNullPointer(ExceptionTypesDemo.java:23)
    at ExceptionTypesDemo.main(ExceptionTypesDemo.java:10)

After adding the null handling: Expected Output if null handling occurs:

Contents of the file... (if any)
Null pointer encountered: Cannot invoke "String.length()" because "input" is null

Step 7: Summary

• Checked Exceptions: The compiler enforces that these exceptions are either caught or declared in the method signature.

  • Example: FileNotFoundException, IOException
  • We handled FileNotFoundException and IOException explicitly in the readFile method and its caller (main).

• Unchecked Exceptions: No enforced requirement for catching or declaring these exceptions.

  • Example: NullPointerException
  • We handled NullPointerException explicitly despite it not being required by the compiler, enhancing robustness.