Multiple catch blocks in Java - Step-by-Step Execution

Concept Flow - Multiple catch blocks

Try block starts

↓

Exception occurs?

No→Try block ends normally

Yes↓

Check first catch block

↓

Matches exception?

No→Check next catch block

Yes↓

Execute catch block

↓

Continue after try-catch

The program tries code in the try block. If an exception happens, it checks each catch block in order to find a match and runs the matching one.

Execution Sample

Java

try {
    int[] arr = new int[2];
    System.out.println(arr[5]);
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("Index error");
} catch (Exception e) {
    System.out.println("General error");
}

This code tries to access an invalid array index, catches the specific index error first, and prints a message.

Execution Table

Step	Action	Exception Thrown	Catch Block Checked	Catch Block Matches?	Output
1	Enter try block	None	None	N/A
2	Access arr[5]	ArrayIndexOutOfBoundsException	First catch (ArrayIndexOutOfBoundsException)	Yes
3	Execute first catch block	Handled	First catch	Yes	Index error
4	Exit try-catch	Handled	None	N/A

💡 Exception handled by first catch block, program continues after try-catch.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
arr	null	new int[2]	new int[2]	new int[2]	new int[2]
Exception	none	none	ArrayIndexOutOfBoundsException	handled	none

Key Moments - 2 Insights

Why does the first catch block run instead of the second?

Because the exception thrown is ArrayIndexOutOfBoundsException, which matches the first catch block exactly, so Java runs it and skips the others (see execution_table step 2 and 3).

What happens if no catch block matches the exception?

The exception would propagate up and could crash the program if not handled elsewhere. In this example, all exceptions are caught by the second catch block if the first doesn't match.

Visual Quiz - 3 Questions

Look at the execution table, which catch block handles the exception at step 3?

A The first catch block (ArrayIndexOutOfBoundsException)

B The second catch block (Exception)

C No catch block handles it

D Both catch blocks handle it

💡 Hint

Check the 'Catch Block Matches?' and 'Output' columns at step 3 in the execution_table.

At which step is the exception first detected?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at the 'Exception Thrown' column in the execution_table.

If the first catch block was removed, which catch block would handle the exception?

A No catch block would handle it

B A new catch block would be needed

C The second catch block (Exception)

D The program would crash immediately

💡 Hint

See that the second catch block catches Exception, which is a parent of ArrayIndexOutOfBoundsException.

Concept Snapshot

try {
  // code that might throw exceptions
} catch (SpecificException e) {
  // handle specific exception
} catch (GeneralException e) {
  // handle other exceptions
}
Multiple catch blocks let you handle different errors separately, checked in order.

Full Transcript

This example shows how Java tries code inside a try block. If an error happens, it looks at each catch block in order to find one that matches the error type. The first matching catch block runs, handling the error. Here, accessing an invalid array index throws ArrayIndexOutOfBoundsException, which matches the first catch block, so it prints 'Index error'. The program then continues normally after the try-catch. If no catch block matches, the error would go up and might crash the program. Multiple catch blocks let you handle different errors in different ways.

Practice

1.

What is the main purpose of using multiple catch blocks in Java?

easy

A. To handle different types of exceptions separately

B. To run all catch blocks regardless of exception type

C. To improve program speed by skipping exceptions

D. To avoid using try blocks

Solution

1. Step 1: Understand exception handling

   Multiple catch blocks allow handling different exceptions in different ways.

2. Step 2: Identify the purpose

   Each catch block targets a specific exception type, so only the matching one runs.

3. Final Answer:

   To handle different types of exceptions separately -> Option A

4. Quick Check:

   Multiple catch blocks = handle exceptions separately [OK]

Hint: Multiple catch blocks handle different exceptions separately [OK]

Common Mistakes:

• Thinking all catch blocks run for one exception
• Believing catch blocks improve speed
• Confusing catch blocks with try blocks

2.

Which of the following is the correct syntax for multiple catch blocks in Java?

try {
    // code
} catch (IOException e) {
    // handle IO
} catch (Exception e) {
    // handle general
}

easy

A. try { } catch (Exception e) { } catch (IOException e) { }

B. try { } catch (IOException e) { } catch (Exception e) { }

C. try { } catch IOException e { } catch Exception e { }

D. try { } catch (Exception e) catch (IOException e) { }

Solution

1. Step 1: Check catch block order

   Specific exceptions like IOException must come before general ones like Exception.

2. Step 2: Verify syntax correctness

   Each catch block must have parentheses around exception type and variable.

3. Final Answer:

   try { } catch (IOException e) { } catch (Exception e) { } -> Option B

4. Quick Check:

   Specific before general, correct syntax [OK]

Hint: Put specific exceptions before general ones in catch blocks [OK]

Common Mistakes:

• Placing general exception before specific
• Missing parentheses in catch
• Combining catch blocks without braces

3.

What will be the output of the following code?

try {
    int[] arr = new int[2];
    System.out.println(arr[5]);
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("Index error");
} catch (Exception e) {
    System.out.println("General error");
}

medium

A. No output

B. General error

C. ArrayIndexOutOfBoundsException

D. Index error

Solution

1. Step 1: Identify exception thrown

   Accessing arr[5] causes ArrayIndexOutOfBoundsException.

2. Step 2: Match catch block

   The first catch matches ArrayIndexOutOfBoundsException and prints "Index error".

3. Final Answer:

   Index error -> Option D

4. Quick Check:

   ArrayIndexOutOfBoundsException caught by first catch [OK]

Hint: First matching catch block runs for thrown exception [OK]

Common Mistakes:

• Thinking general catch runs first
• Expecting exception message printed
• Assuming no output on exception

4.

Find the error in this code snippet:

try {
    int a = 5 / 0;
} catch (Exception e) {
    System.out.println("Error");
} catch (ArithmeticException e) {
    System.out.println("Math error");
}

medium

A. Try block missing braces

B. Exception catch block should be removed

C. ArithmeticException catch block should come before Exception catch block

D. No error, code is correct

Solution

1. Step 1: Check catch block order

   More specific exceptions must come before general ones.

2. Step 2: Identify error

   ArithmeticException is a subclass of Exception, so its catch must be first.

3. Final Answer:

   ArithmeticException catch block should come before Exception catch block -> Option C

4. Quick Check:

   Specific before general catch order [OK]

Hint: Place specific exceptions before general ones in catch blocks [OK]

Common Mistakes:

• Putting general catch before specific
• Ignoring catch block order rules
• Assuming no compile error

5.

Consider this code:

try {
    String s = null;
    System.out.println(s.length());
} catch (NullPointerException e) {
    System.out.println("Null pointer caught");
} catch (RuntimeException e) {
    System.out.println("Runtime exception caught");
} catch (Exception e) {
    System.out.println("General exception caught");
}

What will be printed and why is the catch order important here?

hard

A. "Null pointer caught" because NullPointerException is caught first

B. "Runtime exception caught" because RuntimeException is more general

C. "General exception caught" because Exception is the base class

D. Compilation error due to catch order

Solution

1. Step 1: Identify exception thrown

   Calling length() on null throws NullPointerException.

2. Step 2: Check catch order

   NullPointerException is caught by the first catch block, which is specific and placed before general exceptions.

3. Step 3: Understand importance of order

   If general exceptions came first, specific ones would be unreachable causing compile error.

4. Final Answer:

   "Null pointer caught" because NullPointerException is caught first -> Option A

5. Quick Check:

   Specific exceptions first, correct catch order [OK]

Hint: Catch specific exceptions before general ones to avoid errors [OK]

Common Mistakes:

• Assuming general catch runs first
• Ignoring NullPointerException specifics
• Not knowing catch block order matters