Java Tutorial » Chapter 21 — Exceptions

Chapter 21 — Java Exceptions

Mastering error handling and creating robust Java applications.

1. Introduction

What are Exceptions?

An exception is an event that disrupts the normal flow of a program's instructions. It's an object that's "thrown" when an error occurs and can be "caught" to handle the error gracefully.

Exceptions provide a structured way to handle errors, making programs more robust and preventing them from crashing. Instead of checking return codes for every possible error, you can group related code in a try block and handle any exceptions that might occur.

Java's exception handling is based on five keywords: try, catch, finally, throw, and throws.

2. Exception Hierarchy

The Family Tree of Exceptions

All exception types in Java are subclasses of the java.lang.Throwable class. The hierarchy is divided into two main branches:

  • Error: Serious problems that applications shouldn't try to catch (e.g., OutOfMemoryError). These are typically caused by the JVM.
  • Exception: Conditions that a reasonable application might want to catch. This is further divided into:
    • Checked Exceptions: Exceptions that must be either caught or declared in the method signature (e.g., IOException, SQLException).
    • Unchecked Exceptions: Exceptions that don't need to be declared or caught (e.g., NullPointerException, ArrayIndexOutOfBoundsException).
public class ExceptionHierarchy {
    public static void main(String[] args) {
        try {
            // This will throw an unchecked exception
            String str = null;
            System.out.println(str.length()); // NullPointerException
            
            // This would throw a checked exception if not handled
            FileReader reader = new FileReader("nonexistent.txt");
        } catch (NullPointerException e) {
            System.err.println("Caught NullPointerException: " + e.getMessage());
        } catch (FileNotFoundException e) {
            System.err.println("Caught FileNotFoundException: " + e.getMessage());
        }
    }
}
3. Built-in Exceptions

Common Java Exception Types

Java provides many built-in exception classes to handle common error conditions. Here are some of the most frequently used ones:

  • NullPointerException: Thrown when an application attempts to use null where an object is required.
  • ArrayIndexOutOfBoundsException: Thrown when accessing an array with an illegal index.
  • ArithmeticException: Thrown for exceptional arithmetic conditions like division by zero.
  • ClassNotFoundException: Thrown when a class cannot be found.
  • FileNotFoundException: Thrown when trying to access a file that doesn't exist.
  • IOException: A general class for exceptions produced by failed or interrupted I/O operations.
  • NumberFormatException: Thrown when trying to convert a string to a numeric type but the string doesn't have the appropriate format.
4. Exception Methods

Methods of the Throwable Class

The Throwable class provides several useful methods to get information about the exception:

  • String getMessage(): Returns a detailed message about the exception.
  • String toString(): Returns a short description of the exception.
  • void printStackTrace(): Prints the stack trace to the standard error stream.
  • Throwable getCause(): Returns the cause of the exception.
public class ExceptionMethods {
    public static void main(String[] args) {
        try {
            methodThatThrowsException();
        } catch (Exception e) {
            System.out.println("Exception message: " + e.getMessage());
            System.out.println("Exception string: " + e.toString());
            System.out.println("Printing stack trace:");
            e.printStackTrace();
        }
    }
    
    private static void methodThatThrowsException() throws Exception {
        throw new Exception("This is a custom exception message");
    }
}
5. Catching Exceptions

Handling Errors Gracefully

The try-catch block is the fundamental mechanism for handling exceptions. Code that might throw an exception is placed in the try block, and the exception handling code is placed in the catch block.

public class CatchingExceptions {
    public static void main(String[] args) {
        try {
            // Code that might throw an exception
            int[] numbers = {1, 2, 3};
            System.out.println(numbers[5]); // This will throw ArrayIndexOutOfBoundsException
        } catch (ArrayIndexOutOfBoundsException e) {
            System.err.println("Caught exception: " + e.getMessage());
            System.out.println("Continuing program execution...");
        }
    }
}
6. Multiple Catch Blocks

Handling Different Exception Types

You can have multiple catch blocks to handle different types of exceptions. Java will execute the first catch block that matches the thrown exception type.

public class MultipleCatchBlocks {
    public static void main(String[] args) {
        try {
            String[] args2 = {"arg1", "arg2"};
            int index = 2;
            System.out.println(args2[index]); // This will throw ArrayIndexOutOfBoundsException
        } catch (ArrayIndexOutOfBoundsException e) {
            System.err.println("Array index out of bounds: " + e.getMessage());
        } catch (Exception e) {
            // This is a general catch-all for any other exception
            System.err.println("General exception: " + e.getMessage());
        }
    }
}
7. Catching Multiple Exception Types

Multi-catch in Java 7+

Starting with Java 7, you can catch multiple exception types in a single catch block using the pipe (|) operator. This reduces code duplication when you need to handle several exceptions in the same way.

public class MultiCatch {
    public static void main(String[] args) {
        try {
            // Code that might throw different exceptions
            String input = "123a";
            int number = Integer.parseInt(input); // This will throw NumberFormatException
        } catch (NumberFormatException | NullPointerException e) {
            // Handle both NumberFormatException and NullPointerException the same way
            System.err.println("Invalid input: " + e.getMessage());
        }
    }
}
8. The Throws/Throw Keywords

Declaring and Throwing Exceptions

The throws keyword is used in a method signature to declare that a method might throw an exception. This is required for checked exceptions.

The throw keyword is used to explicitly throw an exception from within a method or block of code.

import java.io.IOException;

public class ThrowsThrowExample {
    // Method signature declares that it might throw an IOException
    public static void readFile(String filename) throws IOException {
        // Method implementation might throw an IOException
        if (filename == null) {
            throw new IOException("Filename cannot be null");
        }
        // Code to read the file would go here
    }
    
    public static void main(String[] args) {
        try {
            readFile("nonexistent.txt");
        } catch (IOException e) {
            System.err.println("Caught IOException: " + e.getMessage());
        }
    }
}
9. The Finally Block

Cleanup Code

The finally block contains code that will always execute, whether an exception was thrown or not. It's typically used for cleanup operations like closing files or releasing resources.

public class FinallyBlock {
    public static void main(String[] args) {
        try {
            // Code that might throw an exception
            System.out.println("Opening resource");
            // Simulate an exception
            throw new Exception("Something went wrong");
        } catch (Exception e) {
            System.err.println("Caught exception: " + e.getMessage());
        } finally {
            // This code always executes
            System.out.println("Closing resource");
        }
    }
}
10. The try-with-resources

Automatic Resource Management

Introduced in Java 7, the try-with-resources statement ensures that each resource is closed at the end of the statement. It works with objects that implement the AutoCloseable interface.

This eliminates the need for a finally block just to close resources, making the code cleaner and less error-prone.

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

public class TryWithResources {
    public static void main(String[] args) {
        // The BufferedReader will be automatically closed
        try (BufferedReader reader = new BufferedReader(new FileReader("example.txt"))) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            System.err.println("Error reading file: " + e.getMessage());
        }
        // No need for a finally block to close the reader
    }
}
11. User-defined Exceptions

Creating Custom Exceptions

While Java provides many built-in exceptions, you can create your own exception classes by extending the Exception class. This is useful when you need to handle application-specific error conditions.

Custom exceptions should typically end with "Exception" and follow Java naming conventions.

// Custom exception class
class InsufficientFundsException extends Exception {
    public InsufficientFundsException(String message) {
        super(message);
    }
}

public class BankAccount {
    private double balance;
    
    public BankAccount(double initialBalance) {
        this.balance = initialBalance;
    }
    
    public void withdraw(double amount) throws InsufficientFundsException {
        if (amount > balance) {
            throw new InsufficientFundsException("Insufficient funds. Available: " + balance + ", Requested: " + amount);
        }
        balance -= amount;
    }
    
    public double getBalance() {
        return balance;
    }
}

public class UserDefinedException {
    public static void main(String[] args) {
        BankAccount account = new BankAccount(100.0);
        
        try {
            account.withdraw(150.0); // This will throw our custom exception
        } catch (InsufficientFundsException e) {
            System.err.println("Transaction failed: " + e.getMessage());
        }
        
        System.out.println("Current balance: " + account.getBalance());
    }
}
12. Common Exceptions

Handling Frequent Error Conditions

Let's look at some common exceptions and how to handle them in practical scenarios:

NullPointerException

This is one of the most common exceptions in Java. It occurs when you try to use a reference that points to null.

public class NullPointerExample {
    public static void main(String[] args) {
        String text = null;
        
        // This will throw NullPointerException
        try {
            System.out.println("Length of text: " + text.length());
        } catch (NullPointerException e) {
            System.err.println("NullPointerException caught: " + e.getMessage());
        }
        
        // Proper way to handle potential null values
        if (text != null) {
            System.out.println("Length of text: " + text.length());
        } else {
            System.out.println("Text is null");
        }
    }
}

NumberFormatException

This occurs when trying to convert a string to a numeric type but the string doesn't have the appropriate format.

public class NumberFormatExample {
    public static void main(String[] args) {
        String[] inputs = {"123", "45.6", "abc", "1e5"};
        
        for (String input : inputs) {
            try {
                double number = Double.parseDouble(input);
                System.out.println("Converted '" + input + "' to: " + number);
            } catch (NumberFormatException e) {
                System.err.println("Cannot convert '" + input + "' to a number: " + e.getMessage());
            }
        }
    }
}

ArrayIndexOutOfBoundsException

This occurs when trying to access an array with an illegal index (either negative or beyond the array's length).

public class ArrayIndexExample {
    public static void main(String[] args) {
        int[] numbers = {10, 20, 30, 40, 50};
        int[] indices = {-1, 0, 4, 5};
        
        for (int index : indices) {
            try {
                System.out.println("numbers[" + index + "] = " + numbers[index]);
            } catch (ArrayIndexOutOfBoundsException e) {
                System.err.println("Invalid index " + index + ": " + e.getMessage());
            }
        }
    }
}
13. Practice & Challenge

Test Your Skills

  1. Write a program that demonstrates the difference between checked and unchecked exceptions.
  2. Create a program that uses try-with-resources to read a file and count the number of lines.
  3. Write a program that throws a custom exception when a user enters an invalid password.
  4. Create a program that uses multiple catch blocks to handle different types of exceptions.
  5. Write a program that demonstrates the order of execution in try-catch-finally blocks.

🏆 Challenge: Robust File Processor

Create a program that processes a text file with the following requirements:

  • Handle the case where the file doesn't exist.
  • Handle the case where the file can't be read due to permissions.
  • Parse each line as a number and handle non-numeric lines gracefully.
  • Calculate the sum of all valid numbers and display the result.
  • Use try-with-resources to ensure the file is properly closed.
  • Create a custom exception for when a number in the file is negative.

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

// Custom exception for negative numbers
class NegativeNumberException extends Exception {
    public NegativeNumberException(String message) {
        super(message);
    }
}

public class RobustFileProcessor {
    public static void main(String[] args) {
        if (args.length == 0) {
            System.out.println("Usage: java RobustFileProcessor ");
            return;
        }
        
        String filename = args[0];
        double sum = 0;
        
        try (BufferedReader reader = new BufferedReader(new FileReader(filename))) {
            String line;
            int lineNumber = 0;
            
            while ((line = reader.readLine()) != null) {
                lineNumber++;
                try {
                    double number = Double.parseDouble(line);
                    if (number < 0) {
                        throw new NegativeNumberException("Negative number at line " + lineNumber + ": " + number);
                    }
                    sum += number;
                } catch (NumberFormatException e) {
                    System.err.println("Skipping non-numeric value at line " + lineNumber + ": " + line);
                }
            }
            
            System.out.println("Sum of all positive numbers: " + sum);
            
        } catch (IOException e) {
            System.err.println("Error reading file: " + e.getMessage());
        } catch (NegativeNumberException e) {
            System.err.println("Error in file: " + e.getMessage());
        }
    }
}
⬅️ Previous: Files and I/O Next: Collections ➡️