Si funksionon menaxhimi i përjashtimeve dhe dallimi midis kontrolluar/pakontrolluar?

Question

Accepted Answer

Java menaxhon gabimet me **`try`/`catch`/`finally`** dhe në mënyrë unike dallon **përjashtimet e kontrolluar** (duhet të deklarohen ose të trajtohen) nga **përjashtimet e pakontrolluar** (në kohën e ekzekutimit, nuk zbatohen). Kuptimi i këtij dallimi është qendror për menaxhimin e gabimeve në Java.

## Struktura bazë

```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` ekzekutohet gjithmonë (pastrimi), edhe nëse një përjashtim hidhet ose ndodh një `return`.

## Hierarkia e përjashtimeve

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

## Përjashtimet e kontrolluar — detyrim i kompajlerit

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

**Përjashtimet e kontrolluar** (IOException, SQLException) përfaqësojnë kushte të rikuperueshme, të pritshme (skedar që mungon, dështim i rrjetit). Kompajleri ju *detyron* t'i trajtonit ose deklaronit — duke bërë trajtimin e dështimeve të jashtme eksplicite.

## Përjashtimet e pakontrolluar — ekzekutim, nuk zbatohen

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

**Përjashtimet e pakontrolluar** (nënklasa e RuntimeException) zakonisht sinjalizojnë gabime të programimit — ju rregulloni gabimin në vend që ta kapni kudo. Kompajleri nuk detyron trajtimin.

## try-with-resources (pastrimi automatik)

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

## Praktikat më të mira

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

## Pse ka rëndësi

Menaxhimi i qëndrueshëm i gabimeve është thelbësor, dhe **dallimi midis përjashtimeve të kontrolluar/pakontrolluar është një tipar përcaktues (dhe i diskutuar) në Java** që vlen të kuptohet thellësisht.

Përjashtimet e kontrolluar detyrojnë trajtimin eksplicite të dështimeve të pritshme të jashtme (I/O, DB) — duke promovuar besueshmërinë, por ndonjëherë kritikuhen si të verbozë; përjashtimet e pakontrolluar përfaqësojnë gabime që duhet rregulluar në vend që t'i kapni rutinisht.

Njohja e hierarkisë, kur zbatohet secila lloj, semantika e `try/catch/finally` dhe **try-with-resources** modern për pastrimin automatik është themelore për shkrimin e Java-s të saktë, të qëndrueshme — dhe për hartimin e përjashtimeve tuaja në mënyrë të përshtatshme.

Dallimi formon mënyrën e hartimit të API-ve Java dhe është një temë e shpeshtë e intervistës dhe rishikimit të kodit.