Checked Exception

// ── Compiler enforces handling for checked exceptions: ────────────────

// This will NOT compile — IOException is checked and must be handled:
public void readFile() {
    FileReader reader = new FileReader("data.txt");  // COMPILE ERROR
    // java: unreported exception java.io.FileNotFoundException;
    // must be caught or declared to be thrown
}

// ── Option 1: Handle with try-catch: ─────────────────────────────────
public void readFile() {
    try {
        FileReader reader = new FileReader("data.txt");
        // read file...
    } catch (FileNotFoundException e) {
        System.err.println("File not found: " + e.getMessage());
        // recovery logic: use default values, log, alert user, etc.
    }
}

// ── Option 2: Declare with throws — propagate to caller: ─────────────
public void readFile() throws FileNotFoundException {
    FileReader reader = new FileReader("data.txt");
    // This method shifts responsibility to its caller.
    // The compiler now requires CALLERS of readFile() to handle or declare it.
}

// ── Propagation chain: ────────────────────────────────────────────────
// If readFile() declares throws FileNotFoundException:
public void processData() throws FileNotFoundException {
    readFile();          // propagates — declares too
}

public void run() throws FileNotFoundException {
    processData();       // propagates again
}

public static void main(String[] args) {
    try {
        new App().run(); // must eventually be caught
    } catch (FileNotFoundException e) {
        System.err.println("Cannot start: " + e.getMessage());
    }
}

// ── Checked exceptions extend Exception (not RuntimeException): ───────
IOException          ioe = new IOException("IO failed");
FileNotFoundException fnf = new FileNotFoundException("file.txt");
SQLException         sqe = new SQLException("DB error");
ParseException       pe  = new ParseException("parse failed", 0);

// All are checked — compiler requires handling:
System.out.println(ioe instanceof Exception);     // true
System.out.println(ioe instanceof RuntimeException); // false — checked!

// ── Common checked exceptions and where they come from: ─────────────

// IOException and subclasses — file and stream operations:
try {
    FileReader   reader = new FileReader("data.txt");     // FileNotFoundException
    BufferedReader br   = new BufferedReader(reader);
    String line         = br.readLine();                   // IOException
    br.close();                                            // IOException
} catch (FileNotFoundException e) {
    System.err.println("File does not exist: " + e.getMessage());
} catch (IOException e) {
    System.err.println("IO error: " + e.getMessage());
}

// InterruptedException — thread operations:
try {
    Thread.sleep(1000);           // InterruptedException
    Object lock = new Object();
    synchronized(lock) {
        lock.wait();              // InterruptedException
    }
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();  // restore interrupt flag — critical!
    System.out.println("Thread was interrupted");
}

// SQLException — database operations:
try {
    Connection conn   = DriverManager.getConnection(url, user, pass);
    PreparedStatement ps = conn.prepareStatement("SELECT * FROM users");
    ResultSet rs      = ps.executeQuery();
    while (rs.next()) {
        System.out.println(rs.getString("name"));
    }
} catch (SQLException e) {
    System.err.println("Database error: " + e.getMessage());
}

// ParseException — date/number parsing:
try {
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    Date date = sdf.parse("2025-05-30");    // ParseException
} catch (ParseException e) {
    System.err.println("Date parse error at position " + e.getErrorOffset());
}

// ClassNotFoundException — reflection:
try {
    Class<?> cls = Class.forName("com.example.SomeClass"); // ClassNotFoundException
} catch (ClassNotFoundException e) {
    System.err.println("Class not found: " + e.getMessage());
}

// ── Multi-catch — same handling for different exceptions: ─────────────
try {
    Connection conn = DriverManager.getConnection(url);
    FileReader  fr  = new FileReader("config.txt");
} catch (SQLException | IOException e) {   // multi-catch
    System.err.println("Initialisation failed: " + e.getMessage());
    // e is implicitly final in multi-catch
}

// ── NEVER swallow exceptions silently: ───────────────────────────────
// BAD — exception silently ignored, failure undetectable:
try {
    config = loadConfig("settings.properties");
} catch (IOException e) {
    // Do nothing — this hides the failure completely
}

// SLIGHTLY BETTER — at least log it:
try {
    config = loadConfig("settings.properties");
} catch (IOException e) {
    logger.error("Failed to load config: {}", e.getMessage(), e);
    config = Config.defaults();    // use fallback
}

// ── Exception translation — convert to appropriate abstraction: ────────
// BAD — exposes SQL details to service layer:
public User findUser(String id) throws SQLException {
    return database.query("SELECT * FROM users WHERE id = ?", id);
}

// GOOD — translate to domain exception, preserve cause:
public User findUser(String id) throws UserNotFoundException {
    try {
        User user = database.query("SELECT * FROM users WHERE id = ?", id);
        if (user == null) throw new UserNotFoundException(id);
        return user;
    } catch (SQLException e) {
        throw new UserNotFoundException(id, e);  // preserve cause
    }
}

// ── Do not declare throws Exception or catch Exception broadly: ────────
// BAD — hides what can actually go wrong:
public void processOrder(Order order) throws Exception {
    validateOrder(order);    // throws ValidationException
    chargeCustomer(order);   // throws PaymentException
    fulfillOrder(order);     // throws FulfillmentException
}

// GOOD — declare specific exceptions:
public void processOrder(Order order)
        throws ValidationException, PaymentException, FulfillmentException {
    validateOrder(order);
    chargeCustomer(order);
    fulfillOrder(order);
}

// ── Restore interrupt status when catching InterruptedException: ───────
// WRONG — swallows interrupt, thread never knows it was interrupted:
try {
    Thread.sleep(5000);
} catch (InterruptedException e) {
    // Do nothing — VERY BAD in thread management
}

// CORRECT — restore interrupt flag so callers can check it:
try {
    Thread.sleep(5000);
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();   // restore interrupted status
    // Now clean up and return, or propagate
    return;
}