Kaip veikia išimčių tvarkymas ir patikrinta/nepatikrinta diskriminacija?

Question

Accepted Answer

Java tvarko klaidas naudodama **`try`/`catch`/`finally`** ir unikaliai atskiria **patikrintas išimtis** (turi būti deklaruota arba tvarkoma) nuo **nepatikrintų išimčių** (runtime, nėra priverstina). Šios diskriminacijos supratimas yra pagrindinė Java klaidų tvarkymo dalis.

## Pagrindinė 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
}
```

`finally` visada vykdomas (valimas), net jei išimtis yra išmesta arba atsiranda `return`.

## Išimčių hierarchija

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

## Patikrintos išimtys — kompiliatoriaus priverstina

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

**Patikrintos išimtys** (IOException, SQLException) reiškia atstatytas, numatytas sąlygas (trūkstamas failas, tinklo gedimas). Kompiliatorius *priverčia* jus jas tvarkyti arba deklaruoti — darydama išorinės klaidos tvarkymą aiškią.

## Nepatikrintos išimtys — runtime, nėra priverstina

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

**Nepatikrintos** (RuntimeException subklasės) paprastai signalizuoja programavimo klaidas — jūs pataitate klaidą, o ne ją joje. Kompiliatorius nepriverčia tvarkymo.

## try-with-resources (automatinis valimas)

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

## Geroji praktika

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

## Kodėl tai svarbu

Robustus klaidų valdymas yra būtinas, o Java **patikrinta/nepatikrinta diskriminacija yra apibrėžianti (ir diskutuojama) savybė**, verta gilaus supratimo.

Patikrintos išimtys priverstina aiškią numatytų išorinių klaidų (I/O, DB) tvarkymą — skatina patikimumą, bet kartais kritikuojama kaip žodi; nepatikrintos išimtys reiškia klaidas, kurias reikia pataisyti, o ne įprastai pagauti.

Hierachijos žinojimas, kada kiekvienas tipas taikomas, `try/catch/finally` semantika ir modernus **try-with-resources** automatiniam valymui yra pagrindinė teisingo, patikimo Java rašymo žinia — ir jūsų pačių išimčių projektavimui atitinkamai.

Diskriminacija formuoja, kaip Java API yra suprojektuota ir yra dažnas pokalbio ir kodų peržiūros dalykas.