Multiple catch blocks in Java - Mini Project: Build & Apply

Handling Multiple Exceptions with Multiple Catch Blocks in Java

📖 Scenario: Imagine you are writing a simple Java program that reads numbers from an array and divides a fixed number by each element. Sometimes, the array might contain zero or invalid data, which can cause errors.

🎯 Goal: You will create a Java program that uses try with multiple catch blocks to handle different types of exceptions separately.

📋 What You'll Learn

Create an integer array called numbers with the values 10, 0, 5, -3

Create an integer variable called fixedNumber and set it to 100

Use a for loop with variable i to iterate over numbers

Inside the loop, use a try block to divide fixedNumber by numbers[i]

Add catch blocks to handle ArithmeticException and ArrayIndexOutOfBoundsException

Print specific messages inside each catch block

Print the result of the division inside the try block if no exception occurs

💡 Why This Matters

🌍 Real World

Handling multiple exceptions is common in real-world programs where different errors can happen, such as file errors, network problems, or invalid user input.

💼 Career

Knowing how to use multiple catch blocks helps you write robust Java applications that don't crash unexpectedly and provide clear error messages.

1

Create the data setup

Create an integer array called numbers with the values 10, 0, 5, -3 and an integer variable called fixedNumber set to 100.

Java

int[] numbers = {10, 0, 5, -3};
int fixedNumber = 100;
// Your code here

Hint

Use int[] numbers = {10, 0, 5, -3}; to create the array and int fixedNumber = 100; for the fixed number.

2

Add a for loop to iterate over the array

Add a for loop with variable i that goes from 0 to numbers.length - 1 to iterate over the numbers array.

Java

public class Main {
    public static void main(String[] args) {
        int[] numbers = {10, 0, 5, -3};
        int fixedNumber = 100;
        for (int i = 0; i < numbers.length; i++) {
            // Your code here
        }
    }
}

Hint

Use for (int i = 0; i < numbers.length; i++) to loop through the array.

3

Add try block with multiple catch blocks

Inside the for loop, add a try block that divides fixedNumber by numbers[i] and prints the result. Add two catch blocks: one for ArithmeticException that prints "Cannot divide by zero at index i" and one for ArrayIndexOutOfBoundsException that prints "Index i is out of bounds".

Java

public class Main {
    public static void main(String[] args) {
        int[] numbers = {10, 0, 5, -3};
        int fixedNumber = 100;
        for (int i = 0; i < numbers.length; i++) {
            try {
                // Your code here
            } catch (ArithmeticException e) {
                // Your code here
            } catch (ArrayIndexOutOfBoundsException e) {
                // Your code here
            }
        }
    }
}

Hint

Use try to attempt the division. Catch ArithmeticException to handle division by zero and ArrayIndexOutOfBoundsException for invalid indexes.

4

Print the output

Run the program and print the output to the console. Use System.out.println inside the try and catch blocks as already written.

Java

public class Main {
    public static void main(String[] args) {
        int[] numbers = {10, 0, 5, -3};
        int fixedNumber = 100;
        for (int i = 0; i < numbers.length; i++) {
            try {
                int result = fixedNumber / numbers[i];
                System.out.println("Result: " + result);
            } catch (ArithmeticException e) {
                System.out.println("Cannot divide by zero at index " + i);
            } catch (ArrayIndexOutOfBoundsException e) {
                System.out.println("Index " + i + " is out of bounds");
            }
        }
    }
}
// Run the program to see the output

Hint

Run the program. You should see results for valid divisions and messages for division by zero.

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