Update exceptions.md

Author: Anasss

exceptions.md

@@ -286,3 +286,141 @@ try (Resource1 res1 = new Resource1();
 
 ---
 
+## 🃏 Exception Chaining and Return Statement Flow
+
+**Key Rule:** Exceptions thrown in **catch blocks are NOT caught** by subsequent catch blocks in the same try-catch structure. Only exceptions from the **try block** can be caught.
+
+```java
+public class FamilyReunion {
+    public static void main(String[] args) {
+        try {
+            callGrandpa();  // This will throw an exception from TRY block
+        } catch (IndexOutOfBoundsException father) {
+            System.out.println("Father");           // Step 2: Catches exception from try block
+            throw new NullPointerException();       // Step 3: Throws NEW exception from CATCH block
+        } catch (NullPointerException mother) {
+            System.out.println("Mother");           // ❌ WON'T EXECUTE! Exception not from try block
+            return;                                 
+        } catch (Exception grandma) {
+            System.out.println("Grandma");          // ❌ WON'T EXECUTE! Exception not from try block
+        } finally {
+            System.out.println("Sister");           // Step 4: Always executes
+        }
+        System.out.println("FAMILY_GATHERING");    // ❌ WON'T EXECUTE! NullPointerException propagates
+    }
+    
+    static void callGrandpa() {
+        System.out.println("Grandpa speaks");      // Step 1: Always executes first
+        throw new IndexOutOfBoundsException("Grandpa is grumpy!");
+    }
+}
+
+// Output:
+// Grandpa speaks
+// Father  
+// Sister
+// Exception in thread "main" java.lang.NullPointerException
+```
+
+**Step-by-Step Execution Flow:**
+
+```java
+// Detailed execution breakdown:
+public class FamilyReunion {
+    public static void main(String[] args) {
+        try {
+            callGrandpa();                          // Step 1: Call method - throws IndexOutOfBoundsException
+        } catch (IndexOutOfBoundsException father) {
+            System.out.println("Father");           // Step 2: Catches exception FROM TRY BLOCK
+            throw new NullPointerException();       // Step 3: NEW exception FROM CATCH BLOCK
+        } catch (NullPointerException mother) {     // ❌ CANNOT catch exceptions from catch blocks!
+            System.out.println("Mother");           // NEVER executes - exception not from try block
+            return;                                 
+        } catch (Exception grandma) {               // ❌ CANNOT catch exceptions from catch blocks!
+            System.out.println("Grandma");          // NEVER executes - exception not from try block  
+        } finally {
+            System.out.println("Sister");           // Step 4: Always executes before exception propagates
+        }
+        System.out.println("FAMILY_GATHERING");    // NEVER executes - uncaught exception terminates method
+    }
+    
+    static void callGrandpa() {
+        System.out.println("Grandpa speaks");      // Step 1a: Method execution
+        throw new IndexOutOfBoundsException("Grandpa is grumpy!");  // Step 1b: Exception FROM TRY BLOCK
+    }
+}
+```
+
+**🚨 Critical Concept:** **Only exceptions thrown in the TRY block can be caught by catch blocks!**
+
+**Exception Source Matters:**
+```java
+try {
+    throw new IOException("From try block");     // ✅ CAN be caught by catch blocks below
+} catch (IOException e) {
+    System.out.println("Caught from try");      // ✅ Executes - exception from try block
+    throw new SQLException("From catch block"); // ❌ CANNOT be caught by catch blocks below  
+} catch (SQLException e) {
+    System.out.println("Caught from catch");    // ❌ NEVER executes - exception from catch block
+} catch (Exception e) {
+    System.out.println("Caught anything");      // ❌ NEVER executes - exception from catch block
+}
+// SQLException propagates up - uncaught!
+```
+
+**Key Exception Catching Rules:**
+
+**✅ Exceptions that CAN be caught:**
+```java
+try {
+    throw new RuntimeException("From try block");     // ✅ From try block
+    methodThatThrows();                               // ✅ From method called in try block  
+} catch (RuntimeException e) {
+    // Will catch exceptions from try block
+}
+```
+
+**❌ Exceptions that CANNOT be caught:**
+```java
+try {
+    normalMethod(); // No exception from try block
+} catch (IOException e) {
+    throw new SQLException("From catch block");       // ❌ From catch block - won't be caught
+} catch (SQLException e) {
+    // NEVER executes - SQLException came from catch block
+} finally {
+    throw new IllegalStateException("From finally");  // ❌ From finally block - won't be caught  
+}
+```
+
+**Nested Try-Catch Example:**
+```java
+// To catch exceptions from catch blocks, you need NESTED try-catch:
+try {
+    try {
+        throw new IOException("Original problem");
+    } catch (IOException e) {
+        System.out.println("Caught original");
+        throw new SQLException("New problem");        // This gets thrown to outer try
+    }
+} catch (SQLException e) {                           // ✅ This CAN catch it - different try block!
+    System.out.println("Caught from inner catch");
+}
+```
+
+**💡 Learning Tips:**
+- **Try block rule:** "Only try block exceptions are catchable" - catch blocks can't catch exceptions from other catch blocks
+- **Finally guarantee:** "Finally runs then exception propagates" - finally executes but doesn't catch exceptions
+- **Propagation path:** "Up and out" - uncaught exceptions from catch/finally blocks propagate to calling method
+- **Nested solution:** "Try within try" - use nested try-catch to handle exceptions from catch blocks
+
+**Common Exam Traps:**
+1. **Catch block exceptions** - Thinking subsequent catch blocks will handle exceptions thrown in earlier catch blocks
+2. **Finally block exceptions** - Assuming finally can catch its own exceptions
+3. **Exception propagation** - Not realizing uncaught exceptions terminate the method
+4. **Nested try confusion** - Not understanding when you need nested try-catch structures
+
+**Q:** Can a catch block catch an exception thrown by another catch block in the same try-catch structure?  
+**A:** No! Only exceptions thrown in the try block can be caught by catch blocks. Exceptions from catch blocks propagate up uncaught.
+
+---