Jak funguje zpracování výjimek a rozdíl mezi kontrolovanými a nekontrolovanými výjimkami?

Question

Accepted Answer

Java zpracovává chyby pomocí **`try`/`catch`/`finally`** a jedinečně rozlišuje mezi **kontrolovanými** výjimkami (musí být deklarovány nebo zpracovány) a **nekontrolovanými** výjimkami (běhové, nevynucované). Pochopení tohoto rozlišení je ústředním bodem zpracování chyb v Javě.

## Základní 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 vždy provede (čištění), i když je výjimka vyvolána nebo dojde k `return`.

## Hierarchie výjimek

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

## Kontrolované výjimky — vynucované kompilátorem

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

**Kontrolované** výjimky (IOException, SQLException) reprezentují zotavitelné, očekávané stavy (chybějící soubor, selhání sítě). Kompilátor *vás nutí* je zpracovat nebo deklarovat — činí zpracování externí chyby explicitním.

## Nekontrolované výjimky — běhové, nevynucované

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

**Nekontrolované** (podtřídy RuntimeException) obvykle signalizují chyby v programu — oprávíte chybu spíše než ji všude chytáte. Kompilátor nezpůsobuje zpracování.

## try-with-resources (automatické čištění)

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

## Osvědčené postupy

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

## Proč je to důležité

Robustní zpracování chyb je nezbytné a **rozlišení kontrolovaných/nekontrolovaných v Javě je charakteristická (a debatovaná) vlastnost** která stojí za hlubokému pochopení.

Kontrolované výjimky vynucují explicitní zpracování očekávaných externích selhání (I/O, DB) — podporují spolehlivost ale někdy jsou kritizovány za podrobnost; nekontrolované výjimky reprezentují chyby k opravě spíše než rutinně zachytávat.

Znalost hierarchie, kdy se každý typ uplatňuje, sémantika `try/catch/finally` a moderní **try-with-resources** pro automatické čištění je základem pro psaní správné a spolehlivé Javy — a pro vhodný návrh vlastních výjimek.

Toto rozlišení formuje, jak jsou Java API navržena a je frequentním tématem pohovorů a code-review."},