1Z0-830 Exception Handling - Java SE 21 Certification Prep

Exception Hierarchy

Throwable
  |-- Error (unchecked - do not catch these)
  |     |-- OutOfMemoryError
  |     |-- StackOverflowError
  |
  |-- Exception
        |-- RuntimeException (unchecked - no declaration required)
        |     |-- NullPointerException
        |     |-- ArrayIndexOutOfBoundsException
        |     |-- IllegalArgumentException
        |     |-- ArithmeticException
        |     |-- ClassCastException
        |     |-- NumberFormatException
        |     |-- IllegalStateException
        |
        |-- IOException (checked - must handle or declare)
        |-- SQLException (checked - must handle or declare)
        |-- ClassNotFoundException (checked - must handle or declare)

// Checked exception - compiler enforces handling or declaration
public void readFile() throws IOException {
    FileReader fr = new FileReader("file.txt");  // IOException is checked
}

// Unchecked exception - no compile-time requirement to handle
public void divide(int a, int b) {
    int result = a / b;  // Throws ArithmeticException if b == 0
}

// Frequently tested unchecked exceptions:
// NullPointerException       - calling a method on a null reference
// ArrayIndexOutOfBoundsException - accessing index outside array bounds
// ClassCastException         - casting an object to an incompatible type
// IllegalArgumentException   - passing an invalid argument to a method
// IllegalStateException      - calling a method when the object is in the wrong state
// NumberFormatException      - parsing a string that is not a valid number
//                              (subclass of IllegalArgumentException)

Try-Catch-Finally

// Standard try-catch-finally
try {
    int result = divide(10, 0);
} catch (ArithmeticException e) {
    // Handles only ArithmeticException
    System.out.println("Cannot divide by zero");
} catch (Exception e) {
    // Handles all other Exception subclasses
    // Must come AFTER more specific catch blocks
    System.out.println("Error: " + e.getMessage());
} finally {
    // Executes always - even if a return statement runs in try or catch
    System.out.println("Cleanup");
}

// Useful methods on the exception object
try {
    riskyOperation();
} catch (Exception e) {
    e.getMessage();        // Returns the detail message string
    e.getCause();          // Returns the original cause (if wrapped)
    e.printStackTrace();   // Prints the full stack trace to stderr
    e.getStackTrace();     // Returns the stack trace as a StackTraceElement array
}

// Valid try block combinations:
try { } catch (Exception e) { }                  // OK - catch only
try { } finally { }                              // OK - finally only
try { } catch (Exception e) { } finally { }      // OK - catch and finally
// try { }                                       // Compile error - neither catch nor finally

Multi-Catch

// Multi-catch syntax - handle two unrelated exceptions the same way
try {
    // Code that may throw IOException or SQLException
} catch (IOException | SQLException e) {
    System.out.println("Error: " + e.getMessage());
}

// Rule 1: Exceptions in a multi-catch cannot be in a parent-child relationship
try {
    // ...
} catch (Exception | IOException e) {  // Compile error!
    // IOException is a subclass of Exception - redundant and illegal
}

// Rule 2: The exception variable in a multi-catch is effectively final
try {
    // ...
} catch (IOException | SQLException e) {
    e = new IOException();  // Compile error - cannot reassign e
}

// Rule 3: Catch blocks must be ordered from most specific to most general
try {
    // ...
} catch (FileNotFoundException e) {
    // FileNotFoundException is more specific - must come first
} catch (IOException e) {
    // IOException is the parent - comes after
} catch (Exception e) {
    // Most general - must be last
}

// This does NOT compile - FileNotFoundException is unreachable after IOException:
// catch (IOException e) { }
// catch (FileNotFoundException e) { }  // Compile error: already caught by IOException

Try-With-Resources

// Resources declared in the try header are closed automatically
try (FileReader fr = new FileReader("file.txt");
     BufferedReader br = new BufferedReader(fr)) {
    String line = br.readLine();
} // br is closed first, then fr (reverse declaration order)

// AutoCloseable - the base interface for try-with-resources
public interface AutoCloseable {
    void close() throws Exception;
}

// Closeable - extends AutoCloseable for I/O resources specifically
public interface Closeable extends AutoCloseable {
    void close() throws IOException;  // Narrower checked exception
}

// Custom resource implementing AutoCloseable
public class MyResource implements AutoCloseable {
    public void doWork() {
        System.out.println("Working...");
    }

    @Override
    public void close() {
        System.out.println("Closing resource");
    }
}

try (MyResource r = new MyResource()) {
    r.doWork();
}
// Output:
// Working...
// Closing resource

// Java 9+ - use effectively final variables declared outside the try
FileReader fr = new FileReader("file.txt");
BufferedReader br = new BufferedReader(fr);
try (fr; br) {  // fr and br must not be reassigned after declaration
    String line = br.readLine();
}

// Suppressed exceptions - what happens when both try and close() throw
try (MyResource r = new MyResource()) {
    throw new RuntimeException("Exception in try block");
}
// If close() also throws, that exception is suppressed (not lost).
// You can retrieve suppressed exceptions from the primary exception:
// Throwable[] suppressed = primaryException.getSuppressed();

Throwing Exceptions

// throw - used to throw an exception object at runtime
public void validate(int age) {
    if (age < 0) {
        throw new IllegalArgumentException("Age cannot be negative: " + age);
    }
}

// throws - used in the method signature to declare checked exceptions
public void readFile(String path) throws IOException {
    FileReader fr = new FileReader(path);
}

// A method can declare multiple checked exceptions
public void process() throws IOException, SQLException {
    // ...
}

// Overriding rules for declared exceptions (frequently tested)
class Parent {
    public void method() throws IOException { }
}

class Child extends Parent {
    // ALLOWED: throw the same exception
    public void method() throws IOException { }

    // ALLOWED: throw a subclass of the declared exception
    // public void method() throws FileNotFoundException { }

    // ALLOWED: declare no exception at all
    // public void method() { }

    // NOT ALLOWED: throw a broader checked exception
    // public void method() throws Exception { }  // Compile error

    // ALLOWED: throw any unchecked exception regardless of parent declaration
    // public void method() throws RuntimeException { }  // OK
}

Custom Exceptions

// Custom checked exception - callers must handle or declare it
public class BusinessException extends Exception {
    public BusinessException() {
        super();
    }

    public BusinessException(String message) {
        super(message);
    }

    // Always include a cause constructor to support exception chaining
    public BusinessException(String message, Throwable cause) {
        super(message, cause);
    }
}

// Custom unchecked exception - no handling required by callers
public class ValidationException extends RuntimeException {
    private final String field;  // Custom field to carry extra context

    public ValidationException(String field, String message) {
        super(message);
        this.field = field;
    }

    public String getField() {
        return field;
    }
}

// Using custom exceptions in application code
public void createUser(String email) throws BusinessException {
    if (email == null || email.isBlank()) {
        throw new ValidationException("email", "Email is required");
    }
    if (userExists(email)) {
        throw new BusinessException("User already exists: " + email);
    }
}

// Exception chaining - wrap a low-level exception in a higher-level one
// This preserves the original cause for debugging while presenting a
// meaningful exception type to the caller
try {
    connectToDatabase();
} catch (SQLException e) {
    throw new BusinessException("Database connection failed", e);
}

Common Exception Patterns

// Re-throwing the same exception after logging it
try {
    process();
} catch (Exception e) {
    logger.error("Error processing", e);
    throw e;  // Re-throws the original exception unchanged
}

// Wrapping and re-throwing as a different type
// Use this to convert a low-level exception into a domain-level one
try {
    process();
} catch (SQLException e) {
    throw new RuntimeException("Processing failed", e);  // Cause is preserved
}

// finally block with return - a common exam trap
public int getValue() {
    try {
        return 1;   // Execution starts to return 1...
    } finally {
        return 2;   // ...but finally runs and returns 2 instead
    }
    // The method always returns 2, regardless of the try block return
}

// Similarly, a return in finally suppresses any exception from try or catch:
public int riskyMethod() {
    try {
        throw new RuntimeException("Error");
    } finally {
        return 42;  // Exception is silently discarded - method returns 42
    }
}

// Assertions versus exceptions
// Use assert for:
//   - Verifying internal logic invariants during development
//   - Conditions that should never occur if the code is correct
//   - Note: assertions can be disabled at runtime with the -da JVM flag

// Use exceptions for:
//   - Validating arguments passed in by callers
//   - Handling external conditions such as missing files or network failures
//   - Business logic errors that calling code must respond to