1. The Hook (The "Byte-Sized" Intro)
In a Nutshell: The try-catch block is Java's mechanism for handling exceptions. Code that might throw an exception goes in the try block; error-handling code goes in the catch block. You can have multiple catch blocks for different exception types, and Java 7+ supports multi-catch with the pipe (|) operator.
Think of goalie in soccer. The try block is the game (risky plays). The catch block is the goalkeeper (stops the ball if things go wrong). Multiple catch blocks = specialized goalies for different shot types!
2. Conceptual Clarity (The "Simple" Tier)
💡 The Analogy: The Quality Control Station
Factory assembly line:
- try block: Production (might produce defects)
- catch blocks: Specialized inspectors
- Inspector A: Checks electronics
- Inspector B: Checks packaging
- Inspector C: Handles everything else
3. Technical Mastery (The "Deep Dive")
Syntax Variations
// 1. Single catch
try {
// risky code
} catch (ExceptionType e) {
// handle
}
// 2. Multiple catch
try {
// risky code
} catch (IOException e) {
// handle IO errors
} catch (SQLException e) {
// handle DB errors
}
// 3. Multi-catch (Java 7+)
try {
// risky code
} catch (IOException | SQLException e) {
// handle both
}Catch Order Rules
MUST go from specific to general (subclass before superclass):
try {
// code
} catch (FileNotFoundException e) { // ✅ Specific first
} catch (IOException e) { // ✅ More general
} catch (Exception e) { // ✅ Most general last
}4. Interactive & Applied Code
public class TryCatchDemo {
public static void main(String[] args) {
// Example 1: Single catch
singleCatch();
// Example 2: Multiple catch
multipleCatch();
// Example 3: Multi-catch (Java 7+)
multiCatch();
}
static void singleCatch() {
try {
int[] arr = {1, 2, 3};
System.out.println(arr[10]); // ❌ ArrayIndexOutOfBoundsException
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("❌ Array index error: " + e.getMessage());
}
System.out.println("✅ Continued after exception");
}
static void multipleCatch() {
String str = null;
try {
System.out.println(str.length()); // NullPointerException
int result = 10 / 0; // ArithmeticException
} catch (NullPointerException e) {
System.out.println("❌ Null reference");
} catch (ArithmeticException e) {
System.out.println("❌ Math error");
}
}
static void multiCatch() {
try {
// Might throw either exception
if (Math.random() > 0.5) {
throw new java.io.IOException("IO error");
} else {
throw new java.sql.SQLException("DB error");
}
} catch (java.io.IOException | java.sql.SQLException e) {
System.out.println("❌ Either IO or SQL error: " + e.getMessage());
}
}
}5. The Comparison & Decision Layer
| Feature | Single Catch | Multiple Catch | Multi-Catch |
|---|---|---|---|
| Syntax | catch (E e) | Multiple blocks | catch (E1 | E2 e) |
| Use Case | One exception type | Different handling per type | Same handling for multiple |
| Java Version | All | All | 7+ |
6. The "Interview Corner" (The Edge)
The "Killer" Interview Question: "What happens if you put a general exception before a specific one?" Answer: Compile error! The specific catch becomes unreachable:
try {
} catch (Exception e) { // Catches everything
} catch (IOException e) { // ❌ ERROR: Unreachable!
}Java enforces "specific to general" ordering at compile time.
Pro-Tip: Access exception details:
catch (Exception e) {
e.getMessage(); // Error message
e.printStackTrace(); // Full stack trace
e.getCause(); // Root cause
}