Exception handling மற்றும் checked/unchecked வேறுபாடு எவ்வாறு செயல்படுகிறது?

Question

Accepted Answer

Java **`try`/`catch`/`finally`** உடன் பிழைகளை கையாளுகிறது மற்றும் தனித்துவமாக **checked** exceptions (அறிவிக்கப்பட வேண்டும் அல்லது கையாளப்பட வேண்டும்) **unchecked** exceptions (runtime, கட்டாயமாக இல்லை) வேறுபடுத்துகிறது. இந்த வேறுபாட்டைப் புரிந்துகொள்வது Java பிழை கையாளுதலுக்கு மையமாக உள்ளது.

## அடிப்படை கட்டமைப்பு

```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` எப்போதும் செயல்படுகிறது (சுத்தம்), 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) மீட்டெடுக்கக்கூடிய, எதிர்பார்க்கப்பட்ட நிலைமைகளைக் குறிப்பிடுகிறது (ஒரு கோப்பு இல்லை, நெட்வொர்க் தோல்வி). Compiler உங்களை அவற்றைக் கையாளவோ அறிவிக்கவோ *கட்டாயப்படுத்துகிறது* — வெளிப்புற-தோல்வி கையாளுதல் தெளிவாக்குகிறது.

## 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) பொதுவாக நிரலாக்க பிழைகளைக் குறிக்கிறது — நீங்கள் bug சரிசெய்து அதை எல்லா இடங்களிலும் பிடிக்க மாட்டீர்கள். Compiler கையாளுதலைக் கட்டாயப்படுத்தாது.

## try-with-resources (auto-சுத்தம்)

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

## இது ஏன் முக்கியமானது

வலுவான பிழை கையாளுதல் அপরिहार்यம், மற்றும் Java இன் **checked/unchecked வேறுபாடு ஒரு வரையறுக்கும் (மற்றும் விவாদிக்கப்பட்ட) feature** ஆழமாக புரிந்துகொள்ளுதல் மதிப்புள்ளது.

Checked exceptions எதிர்பார்க்கப்பட்ட வெளிப்புற தோல்விகளின் (I/O, DB) தெளிவான கையாளுதலைக் கட்டாயப்படுத்துகிறது — நம்பகத்தன்மையை ஊக்குவிக்கிறது ஆனால் சில சமயம் verbose என்று விமர்சிக்கப்படுகிறது; unchecked exceptions நிয়மிதமாக பிடிப்பதற்கு பதிலாக சரிசெய்ய வேண்டிய bugs ஐ குறிக்கிறது.

Hierarchy, ஒவ்வொரு வகை எப்போது பயன்படுகிறது, `try/catch/finally` semantics, மற்றும் தற்போதைய **try-with-resources** தெரிந்துகொள்வது சரியான, நம்பகமான Java எழுத — மற்றும் உங்கள் சொந்த exceptions பொருத்தமாக வடிவமைக்கிற அடிப்படை.

வேறுபாடு Java APIs எவ்வாறு வடிவமைக்கப்படுகிறது மற்றும் ஒரு பொதுவான interview மற்றும் code-review topic.