Exception Handling in Java

// try-catch-finally
try {
    int result = 10 / 0;          // throws ArithmeticException
} catch (ArithmeticException e) {
    System.err.println("Error: " + e.getMessage());  // "/ by zero"
} finally {
    // always runs — cleanup, logging
    System.out.println("Done");
}

// Multiple catch blocks
try {
    String s = null;
    int n = Integer.parseInt(s);   // NullPointerException
} catch (NumberFormatException e) {
    System.err.println("Not a number");
} catch (NullPointerException e) {
    System.err.println("Null input");
} catch (Exception e) {
    System.err.println("Unexpected: " + e.getClass().getSimpleName());
}
// More specific exceptions must come BEFORE more general ones

// Multi-catch (Java 7+) — when handling is identical
try {
    process();
} catch (IOException | SQLException e) {
    log.error("Data error: {}", e.getMessage());
}

// CHECKED exception — extends Exception (not RuntimeException)
// Compiler requires you to either catch it or declare throws

// Method that declares it throws checked exception
public String readFile(Path path) throws IOException {
    return Files.readString(path);   // Files.readString throws IOException
}

// Caller must handle:
try {
    String content = readFile(Path.of("data.txt"));
} catch (IOException e) {
    System.err.println("Could not read file: " + e.getMessage());
}

// UNCHECKED exception — extends RuntimeException
// No obligation to declare or catch (but can still catch)
public int divide(int a, int b) {
    if (b == 0) throw new ArithmeticException("Divisor cannot be zero");
    return a / b;
}

// Throwing checked exceptions from lambdas requires wrapping
// (lambdas cannot declare checked exceptions)
List<Path> paths = List.of(Path.of("a.txt"), Path.of("b.txt"));
paths.forEach(p -> {
    try {
        System.out.println(Files.readString(p));
    } catch (IOException e) {
        throw new RuntimeException(e);   // wrap in unchecked
    }
});

// try-with-resources — automatically closes AutoCloseable resources
// Resource declared in the () is closed when the try block exits
// (whether normally, via exception, or via return)

// Old style — error-prone (what if close() itself throws?)
BufferedReader br = null;
try {
    br = new BufferedReader(new FileReader("file.txt"));
    String line = br.readLine();
} catch (IOException e) {
    e.printStackTrace();
} finally {
    if (br != null) {
        try { br.close(); } catch (IOException e) { /* swallow */ }
    }
}

// Modern style — clean and correct
try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
    String line;
    while ((line = br.readLine()) != null) {
        System.out.println(line);
    }
} catch (IOException e) {
    System.err.println("Read error: " + e.getMessage());
}
// br.close() called automatically — even if exception was thrown

// Multiple resources — closed in reverse order of declaration
try (var conn = dataSource.getConnection();
     var stmt = conn.prepareStatement("SELECT * FROM users")) {
    ResultSet rs = stmt.executeQuery();
    while (rs.next()) System.out.println(rs.getString("name"));
} catch (SQLException e) {
    throw new RuntimeException("DB query failed", e);
}