Hogyan működik a kivételkezelés és a checked/unchecked megkülönböztetés?

Question

Accepted Answer

Java a **`try`/`catch`/`finally`** segítségével kezeli a hibákat, és egyedi módon megkülönbözteti a **checked** kivételeket (deklarálni vagy kezelni kell) az **unchecked** kivételektől (runtime, nem kényszerített). Ennek a megkülönböztetésnek a megértése a Java hibakezelés központja.

## Az alapvető struktúra

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

A `finally` mindig végrehajtódik (tisztítás), még ha kivétel lezajlott vagy `return` történt.

## A kivételek hierarchiája

```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 kivételek — fordító által kényszerített

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

A **checked** kivételek (IOException, SQLException) helyreállítható, elvárt feltételeket képviselnek (hiányzó fájl, hálózati hiba). A fordító *kényszeríti* Önt, hogy kezelje vagy deklarálja őket — a külső hiba kezelését kifejezővé téve.

## Unchecked kivételek — runtime, nem kényszerített

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

Az **unchecked** (RuntimeException alosztályok) általában programozási hibákat jeleznek — a hibát javítod meg ahelyett, hogy mindenhol elkapnád. A fordító nem kényszeríti a kezelést.

## try-with-resources (automatikus tisztítás)

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

## Legjobb gyakorlatok

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

## Miért fontos

A robusztus hibakezelés elengedhetetlen, és a Java **checked/unchecked megkülönböztetése egy meghatározó (és vitatott) funkció**, amelyet mélyen meg kell érteni.

A checked kivételek kényszerítik az elvárt külső hibák (I/O, DB) explicit kezelésére — támogatja a megbízhatóságot, de néha bőbeszédűsége miatt kritizálják; az unchecked kivételek olyan hibákat képviselnek, amelyeket meg kell javítani, ahelyett, hogy rendszeresen elkapnák őket.

A hierarchia ismerete, amikor az egyes típusok alkalmazandók, a `try/catch/finally` szemantika és a modern **try-with-resources** az automatikus tisztításhoz alapvetően fontosak a helyes, megbízható Java írásához — és saját kivételek megfelelő megtervezéséhez.

A megkülönböztetés alakítja, hogy a Java API-k hogyan terveződnek, és gyakori interjú és kódáttekintési téma.