Understanding Exception Handling in Java

Java's exception handling mechanism, largely inherited from C++, allows developers to separate error‑prone code from normal execution flow using special exception objects that can be thrown and caught.

When an exception occurs, the runtime throws an object; the call stack unwinds until it reaches a matching catch block, where the programmer can decide how to respond—e.g., notifying the user, handling the error, continuing execution, or terminating the program. A finally block, if present, runs regardless of whether an exception was thrown.

The article distinguishes two major categories of exceptions: unchecked (subclasses of Error and RuntimeException) that usually indicate programming mistakes and need not be declared, and checked exceptions (subclasses of Exception other than RuntimeException) that represent recoverable conditions such as IOException or MalformedURLException and must be declared or handled.

Example 1 shows a typical try‑catch‑finally pattern for reading a text file, handling possible IOException, printing a stack trace, and ensuring the file is closed in the finally block:

BufferedReader br = new BufferedReader(new FileReader("file.txt"));
try {
    StringBuilder sb = new StringBuilder();
    String line = br.readLine();
    while (line != null) {
        sb.append(line);
        sb.append("
");
        line = br.readLine();
    }
    String everything = sb.toString();
} catch (IOException e) {
    e.printStackTrace();
    System.out.println("IO problem");
} finally {
    br.close();
}

Example 2 introduces a Battery class with methods chargeBattery and useBattery. The useBattery method demonstrates nested try‑catch handling, calling a helper test method that throws an Exception when a negative value is supplied:

public class Test {
    public static void main(String[] args) {
        Battery aBattery = new Battery();
        aBattery.chargeBattery(0.5);
        aBattery.useBattery(-0.5);
    }
}

class Battery {
    /** increase battery */
    public void chargeBattery(double p) {
        if (this.power + p < 1.) {
            this.power = this.power + p;
        } else {
            this.power = 1.;
        }
    }

    /** consume battery */
    public boolean useBattery(double p) {
        try {
            test(p);
        } catch (Exception e) {
            System.out.println("catch Exception");
            System.out.println(e.getMessage());
            p = 0.0;
        }
        if (this.power >= p) {
            this.power = this.power - p;
            return true;
        } else {
            this.power = 0.0;
            return false;
        }
    }

    private void test(double p) throws Exception {
        if (p < 0) {
            Exception e = new Exception("p must be positive");
            throw e;
        }
    }

    private double power = 0.0; // percentage of battery
}

The article also shows how to define a custom exception by extending Exception, providing both a no‑argument constructor and one that accepts a message string:

class BatteryUsageException extends Exception {
    public BatteryUsageException() {}
    public BatteryUsageException(String msg) {
        super(msg);
    }
}

Finally, it warns that excessive or overly fine‑grained exception handling can clutter large projects, and advises careful design of error‑handling strategies to keep code maintainable.