Jinsi ya kuangalia exception handling na tofauti ya checked/unchecked?

Question

Accepted Answer

Java inashughulikia hitilafu na **`try`/`catch`/`finally`** na kwa njia maalum inatabanya **exceptions zilizochecked** (lazima zideclare au zihandle) kutoka **unchecked exceptions** (runtime, sio ikubalika). Kuelewa tofauti hii ni muhimu sana kwa exception handling katika Java.

## Muundo wa msingi

```java
try {
    FileReader f = new FileReader("file.txt");   // may throw IOException
    // ... use it ...
} catch (FileNotFoundException e) {
    System.out.println("not found: " + e.getMessage()); // specific first
} catch (IOException e) {
    System.out.println("io error");                      // broader after
} finally {
    System.out.println("always runs — cleanup");         // runs no matter what
}
```

`finally` kila wakati inafanya kazi (kusafisha), hata kama exception inatupwa au `return` inajitokeza.

## Exception hierarchy

```text
Throwable
  ├── Error            — serious JVM problems (OutOfMemoryError) — don't catch
  └── Exception
        ├── RuntimeException  → UNCHECKED (not enforced by the compiler)
        │     NullPointerException, IllegalArgumentException, IndexOutOfBounds...
        └── (other Exceptions) → CHECKED (compiler enforces handling)
              IOException, SQLException...
```

## Checked exceptions — inapokoswa na kichakataji

```java
// MUST either catch it or declare `throws` — the compiler won't let you ignore it
public void readFile() throws IOException {   // declare it
    Files.readAllLines(Paths.get("file.txt")); // throws checked IOException
}
```

**Checked** exceptions (IOException, SQLException) zinawakilisha masuluhisho yanayorindili, matarajio yanayotaka (faili inayokosa, kuganda kwa mtandao). Kichakataji *kinakuwezesha* kuzihandle au zideclare — kurahisisha matendo ya kuhandle kushindwa kwa nje.

## Unchecked exceptions — runtime, sio ikubalika

```java
// NOT required to declare or catch — usually indicate PROGRAMMING BUGS
String s = null;
s.length();                       // NullPointerException (unchecked)
int x = arr[10];                   // ArrayIndexOutOfBoundsException (unchecked)
Integer.parseInt("abc");           // NumberFormatException (unchecked)
```

**Unchecked** (RuntimeException subclasses) kwa kawaida zinaonyesha hitilafu za programu — unasahih bug badala ya kukamatia kila mahali. Kichakataji hakichangamani kuzihandle.

## try-with-resources (kusafisha kiotomatiki)

```java
// resources implementing AutoCloseable are closed automatically
try (FileReader f = new FileReader("file.txt")) {
    // use f
}   // f.close() called automatically, even on exception — no finally needed
```

## Kanuni nzuri

```text
✓ Catch specific exceptions, not bare Exception
✓ Use try-with-resources for files/connections (auto-close)
✓ Don't swallow exceptions silently (empty catch blocks)
✓ Throw meaningful exceptions; include context in messages
✓ Custom exceptions extend Exception (checked) or RuntimeException (unchecked)
```

## Kwa nini kuwa muhimu

Exception handling inayoaminika ni muhimu sana, na **tofauti ya Java kati ya checked/unchecked exceptions ni sifa muhimu (na inataka mijadala)** inayosudiwa kuelewa kwa undani.

Checked exceptions zinakusanya kuhandle kwa njia kama ilivyo masuluhisho yanayotaka ya nje (I/O, DB) — inasaidia utegemezi lakini baadhi huibatilisha kama karibu sana; unchecked exceptions zinawakilisha hitilafu kurekebisha badala ya kukamatia kila wakati.

Kujua hierarchy, lini kila aina inatumika, semantika ya `try/catch/finally` na **try-with-resources** ya sasa kwa kusafisha kiotomatiki ni muhimu kwa kuandika Java sahihi, inayoaminika — na kwa muundo wa exceptions yako inayofaa.

Tofauti inaundilia jinsi Java APIs inaandaliwa na ni mada ya kawaida ya mahojiano na ukaguzi wa msimbo.