Throw keyword in Java - Step-by-Step Execution

Concept Flow - Throw keyword

Start

↓

Check condition

Yes|No↓

Throw Exception

↓

Exception Propagates

↓

Catch or Program Ends

The program checks a condition, and if true, it throws an exception which propagates until caught or program ends.

Execution Sample

Java

public class Test {
  public static void main(String[] args) {
    int age = 15;
    if (age < 18) {
      throw new IllegalArgumentException("Age must be 18 or older");
    }
  }
}

This code throws an exception if age is less than 18.

Execution Table

Step	Action	Condition	Result	Exception Thrown
1	Set age = 15	-	age = 15	No
2	Check if age < 18	15 < 18	True	No
3	Throw IllegalArgumentException	-	-	Yes: "Age must be 18 or older"
4	Program stops or exception propagates	-	-	Exception propagates

💡 Exception thrown at step 3 stops normal execution

Variable Tracker

Variable	Start	After Step 1	After Step 2	Final
age	undefined	15	15	15

Key Moments - 2 Insights

Why does the program stop after the throw statement?

Because at step 3 in the execution_table, the throw keyword creates an exception that interrupts normal flow and propagates unless caught.

Is the exception thrown even if the condition is false?

No, at step 2 the condition is checked; if false, the throw statement is skipped and no exception is thrown.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'age' at step 2?

A 15

B undefined

C 0

D null

💡 Hint

Check variable_tracker row for 'age' after Step 2

At which step does the exception get thrown?

A Step 2

B Step 3

C Step 1

D Step 4

💡 Hint

See execution_table 'Exception Thrown' column

If age was 20, how would the execution_table change?

A Exception thrown at step 3

B Program throws exception at step 1

C Condition at step 2 would be false, no exception thrown

D Program stops at step 2 with exception

💡 Hint

Refer to step 2 condition and exception thrown columns

Concept Snapshot

Throw keyword in Java:
- Used to throw an exception explicitly
- Syntax: throw new ExceptionType("message");
- Stops normal flow and propagates exception
- Usually inside condition checks
- Must be caught or declared to avoid program crash

Full Transcript

This example shows how the throw keyword works in Java. The program sets an integer variable age to 15. It then checks if age is less than 18. Since 15 is less than 18, the condition is true. The program then throws an IllegalArgumentException with a message. Throwing the exception stops the normal program flow and the exception propagates unless caught. The variable age remains 15 throughout. If the age was 20, the condition would be false and no exception would be thrown. This shows how throw interrupts execution when a condition requires it.

Practice

1.

What does the throw keyword do in Java?

easy

A. It catches an exception and handles it.

B. It sends an exception to stop normal program flow when an error occurs.

C. It declares a method can throw exceptions.

D. It creates a new thread for parallel execution.

Solution

1. Step 1: Understand the role of throw

   The throw keyword is used to send an exception object explicitly when an error happens.

2. Step 2: Differentiate from other keywords

   throw does not catch exceptions (that's catch), nor declare exceptions (that's throws), nor create threads.

3. Final Answer:

   It sends an exception to stop normal program flow when an error occurs. -> Option B

4. Quick Check:

   throw sends exception = B [OK]

Hint: Remember: throw sends, catch handles exceptions [OK]

Common Mistakes:

• Confusing throw with throws keyword
• Thinking throw catches exceptions
• Mixing throw with thread creation

2.

Which of the following is the correct way to throw a new IllegalArgumentException in Java?

?

easy

A. throws new IllegalArgumentException("Invalid argument");

B. throw IllegalArgumentException("Invalid argument");

C. throw new IllegalArgumentException("Invalid argument");

D. throw new IllegalArgumentException;

Solution

1. Step 1: Check syntax for throwing exceptions

   To throw an exception, use throw new ExceptionType("message") with parentheses and semicolon.

2. Step 2: Identify correct option

   throw new IllegalArgumentException("Invalid argument"); uses correct syntax with new, parentheses, and semicolon. Options B and D miss parentheses or new. throws new IllegalArgumentException("Invalid argument"); uses throws which is for method declarations, not throwing.

3. Final Answer:

   throw new IllegalArgumentException("Invalid argument"); -> Option C

4. Quick Check:

   throw + new + parentheses = A [OK]

Hint: Throw exceptions with 'throw new ExceptionType()' syntax [OK]

Common Mistakes:

• Omitting 'new' keyword
• Using 'throws' instead of 'throw'
• Missing parentheses after exception class

3.

What will be the output of the following Java code?

public class TestThrow {
    public static void main(String[] args) {
        try {
            throw new RuntimeException("Error happened");
        } catch (RuntimeException e) {
            System.out.println(e.getMessage());
        }
    }
}

medium

A. Error happened

B. RuntimeException

C. Compilation error

D. No output

Solution

1. Step 1: Analyze the try block

   The code throws a new RuntimeException with message "Error happened".

2. Step 2: Analyze the catch block

   The catch block catches the exception and prints its message using e.getMessage(), which is "Error happened".

3. Final Answer:

   Error happened -> Option A

4. Quick Check:

   Exception message printed = C [OK]

Hint: Catch prints exception message with getMessage() [OK]

Common Mistakes:

• Expecting exception type name instead of message
• Thinking code causes compilation error
• Assuming no output without catch

4.

Identify the error in the following code snippet:

public class Example {
    public static void main(String[] args) {
        throw new Exception("Problem");
    }
}

medium

A. Missing try-catch block or throws declaration for checked exception.

B. Incorrect exception message format.

C. Cannot throw exceptions in main method.

D. Exception class does not exist.

Solution

1. Step 1: Identify exception type

   The code throws Exception, which is a checked exception in Java.

2. Step 2: Check handling of checked exceptions

   Checked exceptions must be either caught in a try-catch block or declared with throws in the method signature. This code does neither, causing a compile error.

3. Final Answer:

   Missing try-catch block or throws declaration for checked exception. -> Option A

4. Quick Check:

   Checked exceptions need handling = D [OK]

Hint: Checked exceptions require try-catch or throws declaration [OK]

Common Mistakes:

• Ignoring checked exception rules
• Thinking main cannot throw exceptions
• Confusing checked and unchecked exceptions

5.

Consider this method that throws an exception if the input is negative:

public void checkNumber(int num) {
    if (num < 0) {
        throw new IllegalArgumentException("Negative number not allowed");
    }
    System.out.println("Number is " + num);
}

How should you call this method safely in your code?

hard

A. Use throw keyword again when calling checkNumber.

B. Call checkNumber without any try-catch because IllegalArgumentException is checked.

C. Declare throws IllegalArgumentException in the calling method and do not catch.

D. Call checkNumber inside a try-catch block catching IllegalArgumentException.

Solution

1. Step 1: Identify exception type thrown

   The method throws IllegalArgumentException, which is an unchecked exception.

2. Step 2: Decide safe calling practice

   Although unchecked exceptions do not require declaration, to handle errors safely, call the method inside a try-catch block catching IllegalArgumentException.

3. Final Answer:

   Call checkNumber inside a try-catch block catching IllegalArgumentException. -> Option D

4. Quick Check:

   Catch unchecked exceptions to handle errors safely = A [OK]

Hint: Catch exceptions even if unchecked for safer code [OK]

Common Mistakes:

• Thinking unchecked exceptions must be declared
• Not catching exceptions leading to crashes
• Misusing throw keyword when calling methods