Try–catch block in Java - Step-by-Step Execution

Concept Flow - Try–catch block

Start

↓

Try block

↓

Exception occurs?

No→Try block ends normally

Yes↓

Catch block

↓

Continue after catch

↓

End

The program tries code in the try block. If an error happens, it jumps to the catch block to handle it, then continues.

Execution Sample

Java

try {
    int result = 10 / 0;
    System.out.println("Result: " + result);
} catch (ArithmeticException e) {
    System.out.println("Cannot divide by zero!");
}

This code tries to divide 10 by 0, which causes an error, so it prints a message from the catch block.

Execution Table

Step	Action	Evaluation	Result
1	Enter try block	int result = 10 / 0	Error: ArithmeticException (divide by zero)
2	Exception caught	Catch block for ArithmeticException	Print: 'Cannot divide by zero!'
3	Continue after catch	No more code in try-catch	Program ends normally

💡 Exception occurs at division, caught by catch block, program continues after catch.

Variable Tracker

Variable	Start	After Step 1	After Step 2	Final
result	undefined	Error (not assigned)	undefined	undefined

Key Moments - 2 Insights

Why doesn't the program crash when dividing by zero?

Because the error is caught in the catch block (see execution_table step 2), so the program handles it instead of crashing.

Is the variable 'result' assigned when the exception happens?

No, the assignment fails at step 1 due to the exception, so 'result' remains undefined (see variable_tracker).

Visual Quiz - 3 Questions

Look at the execution table, what happens at step 1?

A An exception occurs during division

B The division succeeds and result is assigned 0

C The catch block runs first

D The program ends

💡 Hint

Check execution_table row 1 where division causes an ArithmeticException

According to variable_tracker, what is the value of 'result' after step 2?

A 10

B undefined

C 0

D Exception object

💡 Hint

See variable_tracker row for 'result' after step 2, it remains undefined because assignment failed

If the division was 10 / 2 instead, what would happen in the execution table?

A Exception occurs and catch block runs

B Program crashes immediately

C Try block ends normally, catch block is skipped

D Catch block runs twice

💡 Hint

Without exception, the catch block is skipped (see concept_flow and execution_table logic)

Concept Snapshot

try {
  // code that might cause error
} catch (ExceptionType e) {
  // code to handle error
}

- Code in try runs first.
- If error occurs, catch runs.
- Program continues after catch.

Full Transcript

This example shows how a try-catch block works in Java. The program tries to divide 10 by 0 inside the try block. This causes an ArithmeticException error. Instead of crashing, the program jumps to the catch block that handles this specific error. The catch block prints a message: 'Cannot divide by zero!'. After that, the program continues normally. The variable 'result' is never assigned because the error happens during its assignment. This way, try-catch helps programs handle errors safely and keep running.

Practice

1. What is the main purpose of a try-catch block in Java?

easy

A. To create new classes

B. To handle errors and prevent program crashes

C. To declare variables

D. To repeat code multiple times

Solution

1. Step 1: Understand the role of try block

   The try block contains code that might cause an error during execution.

2. Step 2: Understand the role of catch block

   The catch block runs only if an error occurs, allowing the program to handle it gracefully.

3. Final Answer:

   To handle errors and prevent program crashes -> Option B

4. Quick Check:

   try-catch handles errors = D [OK]

Hint: Try-catch is for error handling, not loops or declarations [OK]

Common Mistakes:

• Confusing try-catch with loops
• Thinking try-catch declares variables
• Assuming try-catch creates classes

2. Which of the following is the correct syntax to catch an exception in Java?

easy

A. try { /* code */ } catch (e) { /* handle */ }

B. try { /* code */ } catch Exception e { /* handle */ }

C. try { /* code */ } catch { /* handle */ }

D. try { /* code */ } catch (Exception e) { /* handle */ }

Solution

1. Step 1: Check catch syntax

   The catch block must specify the exception type in parentheses, like catch (Exception e).

2. Step 2: Identify correct option

   try { /* code */ } catch (Exception e) { /* handle */ } correctly uses parentheses and exception type; others miss parentheses or type.

3. Final Answer:

   try { /* code */ } catch (Exception e) { /* handle */ } -> Option D

4. Quick Check:

   Correct catch syntax = A [OK]

Hint: Catch must have parentheses with exception type [OK]

Common Mistakes:

• Omitting parentheses in catch
• Not specifying exception type
• Using wrong catch syntax

3. What will be the output of this code?

try {
  int a = 5 / 0;
  System.out.println("Result: " + a);
} catch (ArithmeticException e) {
  System.out.println("Error caught");
}

medium

A. Error caught

B. Result: 0

C. 5

D. Compilation error

Solution

1. Step 1: Identify the error in try block

   Dividing by zero causes an ArithmeticException at runtime.

2. Step 2: Check catch block response

   The catch block catches ArithmeticException and prints "Error caught".

3. Final Answer:

   Error caught -> Option A

4. Quick Check:

   Division by zero triggers catch = A [OK]

Hint: Division by zero triggers catch block output [OK]

Common Mistakes:

• Expecting normal output despite error
• Thinking code crashes without catch
• Confusing compile-time and runtime errors

4. Find the error in this code snippet:

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

medium

A. Array size is too small

B. No error, code runs fine

C. Catch block syntax is wrong

D. Exception type is incorrect

Solution

1. Step 1: Analyze array usage

   Array declared with size 3, valid indices are 0,1,2; index 5 is out of bounds.

2. Step 2: Understand exception thrown

   Accessing index 5 causes ArrayIndexOutOfBoundsException, which is correctly caught.

3. Final Answer:

   Array size is too small -> Option A

4. Quick Check:

   Index 5 invalid for size 3 = C [OK]

Hint: Check array size vs accessed index to find error [OK]

Common Mistakes:

• Thinking catch syntax is wrong
• Assuming no error occurs
• Confusing exception types

5. You want to read an integer from user input safely. Which code correctly uses try-catch to handle invalid input?

import java.util.Scanner;

Scanner sc = new Scanner(System.in);
int num;
try {
  num = sc.nextInt();
  System.out.println("You entered: " + num);
} catch (Exception e) {
  System.out.println("Invalid input");
}

hard

A. Missing finally block causes error

B. Should catch IOException instead of Exception

C. Correctly handles invalid input with try-catch

D. Try block should be outside Scanner usage

Solution

1. Step 1: Understand input reading

   Using sc.nextInt() reads integer input; invalid input throws InputMismatchException, a subclass of Exception.

2. Step 2: Check try-catch usage

   The try block attempts input; catch block handles any Exception, printing "Invalid input" if input is wrong.

3. Final Answer:

   Correctly handles invalid input with try-catch -> Option C

4. Quick Check:

   Try-catch handles input errors = B [OK]

Hint: Catch Exception to handle all input errors safely [OK]

Common Mistakes:

• Thinking finally is mandatory
• Catching wrong exception type
• Placing try block incorrectly