Multiple catch blocks in Java - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of multiple catch blocks in Java?

Multiple catch blocks allow a program to handle different types of exceptions separately, providing specific responses for each exception type.

beginner

How does Java decide which catch block to execute when an exception occurs?

Java checks the exception type thrown and matches it with the first compatible catch block in order. It executes the first matching catch block and skips the rest.

beginner

Can you have multiple catch blocks for a single try block in Java?

Yes, you can have multiple catch blocks after a single try block to handle different exception types separately.

intermediate

What happens if a more general exception catch block is placed before a more specific one?

The compiler will give an error because the more general catch block will catch all exceptions of that type and its subclasses, making the specific catch block unreachable.

beginner

Write a simple Java try-catch example with multiple catch blocks for ArithmeticException and NullPointerException.

try { int result = 10 / 0; String text = null; System.out.println(text.length()); } catch (ArithmeticException e) { System.out.println("Cannot divide by zero."); } catch (NullPointerException e) { System.out.println("Null value encountered."); }

What will happen if an exception is thrown that does not match any catch block?

A The program will terminate with an uncaught exception error.

B The first catch block will handle it anyway.

C The program will ignore the exception and continue.

D Java will automatically create a catch block.

If no catch block matches the thrown exception, the program terminates with an uncaught exception error.

Which catch block will execute if both ArithmeticException and Exception catch blocks are present and an ArithmeticException is thrown?

A The catch block for Exception.

B The catch block for ArithmeticException.

C Both catch blocks execute.

D None will execute.

Java executes the first matching catch block. Since ArithmeticException is more specific, its catch block runs.

Is it valid to have multiple catch blocks for the same exception type?

A No, it causes a compile-time error.

B No, Java merges them automatically.

C Yes, but only if they are in different try blocks.

D Yes, to handle the same exception differently.

Having multiple catch blocks for the same exception type in the same try block causes a compile-time error.

What is the correct order of catch blocks?

A Only one catch block is allowed.

B From most general to most specific exception.

C Order does not matter.

D From most specific to most general exception.

Catch blocks must be ordered from most specific to most general to avoid unreachable code errors.

Can a try block have no catch blocks?

A Yes, but only in Java 17+.

B No, catch blocks are mandatory.

C Yes, if it has a finally block.

D No, try blocks must always have catch blocks.

A try block can have no catch blocks if it has a finally block to handle cleanup.

Explain how multiple catch blocks work in Java and why their order matters.

Think about how Java matches exceptions to catch blocks.

Write a Java try-catch example with at least two catch blocks for different exceptions and explain what each block does.

Use ArithmeticException and NullPointerException for clarity.

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