Exception handling మరియు checked/unchecked వ్యత్యాసం ఎలా పని చేస్తుంది?

Question

Accepted Answer

Java **`try`/`catch`/`finally`** ఉపయోగించి errors ను నిర్వహిస్తుంది మరియు **checked** exceptions (తప్పనిసరిగా declare లేదా handle చేయాలి) **unchecked** exceptions (runtime, నిర్వహించబడవు) నుండి ప్రత్యేకంగా వేరు చేస్తుంది. ఈ వ్యత్యాసాన్ని అర్థం చేసుకోవడం Java error handling కు కేంద్రీయమైనది.

## ప్రాథమిక నిర్మాణం

```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` ఎల్లప్పుడు నిర్వహణ చేయబడుతుంది (cleanup), exception విసరిన కూడా లేదా `return` సంభవించినా.

## Exception hierarchy

```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 exceptions — compiler-నిర్ణీత

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

**Checked** exceptions (IOException, SQLException) పునరుద్ధరణీయ, ఆశించిన పరిస్థితులను సూచిస్తాయి (missing file, network failure). Compiler మీరు వాటిని handle చేయమని లేదా declare చేయమని *బలవంతం* చేస్తుంది — బాహ్య-failure నిర్వహణను స్పష్టమైనదిగా చేస్తుంది.

## Unchecked exceptions — runtime, నిర్ణీతం కాదు

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

**Unchecked** (RuntimeException subclasses) సాధారణంగా programming errors సూచిస్తాయి — మీరు bug సరిచేయండి, అన్నిచోట్లలో catch చేయవద్దు. Compiler నిర్వహణను బలవంతం చేయదు.

## try-with-resources (auto-cleanup)

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

## సర్వోత్తమ ప్రయోగాలు

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

## ఇది ఎందుకు ముఖ్యమైనది

దృఢమైన error handling చాలా ముఖ్యమైనది, మరియు Java యొక్క **checked/unchecked వ్యత్యాసం ఒక నిర్వచించే (మరియు చర్చించిన) feature** లోతుగా అర్థం చేసుకోవడానికి విలువైనది.

Checked exceptions ఆశించిన external failures (I/O, DB) యొక్క స్పష్ట నిర్వహణను బలవంతం చేస్తాయి — విశ్వసనీయతను ప్రోత్సహిస్తుంది కానీ కొన్నిసార్లు verbose గా విమర్శించబడుతుంది; unchecked exceptions సర్వేసరిగా catch చేయటానికి బదులుగా సరిచేయవలసిన bugs సూచిస్తాయి.

Hierarchy, ప్రతి రకం ఎప్పుడు వర్తిస్తుంది, `try/catch/finally` semantics, మరియు ఆధునిక **try-with-resources** automatic cleanup కోసం తెలుసుకోవడం సరిగ్గా, నమ్మదగిన Java వ్రాయటానికి ప్రాథమికమైనది — మరియు మీ స్వంత exceptions సముచితంగా రూపకల్పన చేయటానికి.

వ్యత్యాసం Java APIs ఎలా రూపకల్పన చేయబడుతుందో ఆకృతి చేస్తుంది మరియు ఒక సాధారణ interview మరియు code-review విషయం.