Exception propagation in Java

Introduction

Exception propagation helps your program handle errors by passing problems up the chain until something can fix them.

When a method encounters an error it cannot fix and wants to let the caller handle it.

When you want to keep your code clean by not catching every error immediately.

When multiple methods call each other and an error needs to be handled at a higher level.

When you want to log or display errors in one place instead of many.

Syntax

Java

public void method() throws ExceptionType {
    // code that might throw ExceptionType
}

The throws keyword tells callers this method might throw an exception.

If a method calls another that throws a checked exception, it must handle or declare it.

Examples

This method declares it might throw an IOException, so callers must handle or declare it.

Java

public void readFile() throws IOException {
    // code that reads a file
}

This method calls readFile() and propagates the IOException up.

Java

public void process() throws IOException {
    readFile(); // might throw IOException
}

The start() method catches the exception and handles it.

Java

public void start() {
    try {
        process();
    } catch (IOException e) {
        System.out.println("Error handled here: " + e.getMessage());
    }
}

Sample Program

This program shows exception propagation. readFile() throws an IOException. process() calls readFile() and propagates the exception. start() catches and handles it.

Java

import java.io.IOException;

public class ExceptionPropagationDemo {
    public static void readFile() throws IOException {
        throw new IOException("File not found");
    }

    public static void process() throws IOException {
        readFile();
    }

    public static void start() {
        try {
            process();
        } catch (IOException e) {
            System.out.println("Caught exception: " + e.getMessage());
        }
    }

    public static void main(String[] args) {
        start();
    }
}

Important Notes

Unchecked exceptions (like RuntimeException) do not need to be declared or caught.

Always handle exceptions at a level where you can fix or report them properly.

Summary

Exception propagation passes errors up to callers until handled.

Use throws to declare exceptions a method might throw.

Catch exceptions where you can handle or report them well.