Kako deluje obdelava izjem in razlikovanje med preverjenim in nepreverjenim?

Question

Accepted Answer

Java obdeluje napake z **`try`/`catch`/`finally`** in edinstvenega razlikuje **preverjene** izjeme (je treba jih deklarirati ali obdelati) od **nepreverjenih** izjem (izvajalne, niso vsiljene). Razumevanje te razlike je osrednje za obdelavo napak v Javi.

## Osnovna struktura

```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` se vedno izvrši (čiščenje), tudi če je izjema vržena ali se `return` pojavi.

## Hierarhija izjem

```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...
```

## Preverjene izjeme — vsiljene s prevajalnik

```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
}
```

**Preverjene** izjeme (IOException, SQLException) predstavljajo obnovljive, pričakovane stanja (manjkajoča datoteka, napaka omrežja). Prevajalnik vas *prisili*, da jih obdelate ali deklarirati — kar naredi obdelavo zunanjih napak eksplicitno.

## Nepreverjene izjeme — izvajalne, niso vsiljene

```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)
```

**Nepreverjene** (podrazredi RuntimeException) običajno signalizirajo napake pri programiranju — popravite napako namesto da jo loviš povsod. Prevajalnik obdelovanja ne vsili.

## try-with-resources (samodejno čiščenje)

```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
```

## Dobre prakse

```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)
```

## Zakaj je to pomembno

Robustna obdelava napak je bistvena, in **razlikovanje preverjenih in nepreverjenih izjem v Javi je定义na (in obravnavana) lastnost**, ki je vredno temeljito razumeti.

Preverjene izjeme silijo eksplicitno obdelavo pričakovanih zunanjih napak (I/O, DB) — promovira zanesljivost, vendar je včasih kritizirana kot besedna; nepreverjene izjeme predstavljajo napake za popravek namesto da jih rutinsko lovite.

Znanje hierarhije, kdaj se vsaka vrsta uporablja, semantika `try/catch/finally` in sodobne **try-with-resources** za samodejno čiščenje je temeljno za pisanje pravilne, zanesljive Jave — in za primerno oblikovanje svojih lastnih izjem.

Razlikovanje oblikuje način oblikovanja API-jev v Javi in je pogosta tema intervjujev ter pregledov kode.