Question 435 of 509

Controlling Program Flow →hardMultiple ChoiceObjective-mapped

Quick Answer

The answer is that the process() method throws an Error instead of an Exception, which causes the loop to terminate prematurely. In Java’s exception handling hierarchy, Throwable branches into Exception (including RuntimeException) and Error; a catch block for Exception does not catch Error or its subclasses like OutOfMemoryError or StackOverflowError. Because the Error propagates uncaught, it exits the loop entirely rather than allowing the try-catch to log and continue. On the Oracle Certified Professional Java SE 17 Developer 1Z0-829 exam, this tests your understanding of the Throwable hierarchy and the critical distinction between checked/unchecked exceptions and errors—a common trap where developers assume all failures are Exception types. Remember the mnemonic: “Errors are exceptional, but not Exceptions”—if you catch only Exception, an Error will escape and break your flow.

1Z0-829 Controlling Program Flow Practice Question

This 1Z0-829 practice question tests your understanding of controlling program flow. Read the scenario carefully and evaluate each option against the stated constraints before committing to an answer. After answering, compare your reasoning against the explanation and wrong-answer breakdown below. Once you have made your selection, read the full explanation to reinforce the concept and understand why each distractor is designed to mislead on exam day.

A Java developer is writing a batch processing application that reads records from a database and processes them. The processing must continue even if some records cause exceptions (e.g., data conversion errors). However, the application must log each failed record and its error, then continue with the next record. The developer uses a for loop to iterate over a list of records. Inside the loop, a try-catch block wraps the processing logic. After implementing, the developer notices that when an exception occurs, the loop terminates prematurely instead of continuing. The code structure is:

List<Record> records = fetchRecords();

for (Record rec : records) {

try { process(rec);

} catch (Exception e) {

log.error("Failed to process: " + rec.getId(), e);

}
}

What is the most likely reason for the premature termination?

Clue words in this question

Noticing these words before you look at the options changes how you read each choice.

Clue: "most likely"
Why it matters: Probability qualifier — the question wants the most probable cause or outcome, not a guaranteed one. Eliminate low-probability options.

Question 1hardmultiple choice

Read the full NAT/PAT explanation →

A
The records list contains null elements, causing a NullPointerException that is not caught.
Why wrong: NullPointerException is an Exception, so it would be caught.
B
The process() method throws an Error instead of an Exception.
Errors are not caught by catch(Exception), causing the loop to terminate.
C
The log.error() method itself throws an unchecked exception that is not caught.
Why wrong: If log.error throws an unchecked exception, it would propagate out of the catch block and terminate the loop, but this is less likely than an Error from process().
D
The try-catch block is incorrectly placed inside the for loop, causing the loop to break on any exception.
Why wrong: The try-catch inside the loop is correct for continuing after exceptions; it does not cause termination.

Full breakdown with real-world context →

Answer choices

Why each option matters

Answer the question above first, then reveal the full breakdown to understand why each option is right or wrong.

Correct answer & explanation

✓

The process() method throws an Error instead of an Exception.

The code catches `Exception`, but `Error` (and its subclasses like `OutOfMemoryError`, `StackOverflowError`, or custom `Error` types) are not subclasses of `Exception`. In Java, `Throwable` has two main branches: `Exception` (including `RuntimeException`) and `Error`. Since `Error` is not caught by `catch (Exception e)`, it propagates up and terminates the loop. This is the most likely reason for premature termination because the developer assumed all failures would be `Exception` types.

Key principle: Answer the scenario, not the keyword: identify the specific constraint before choosing the most familiar-sounding option.

Answer analysis

Option-by-option breakdown

For each option: why learners choose it and why it is or isn't the right answer here.

✗
The records list contains null elements, causing a NullPointerException that is not caught.
Why it's wrong here
NullPointerException is an Exception, so it would be caught.
✓
The process() method throws an Error instead of an Exception.
Why this is correct
Errors are not caught by catch(Exception), causing the loop to terminate.
Clue confirmation
The clue word "most likely" in the question point toward this answer.
Related concept
Read the scenario before looking for a memorised answer.
✗
The log.error() method itself throws an unchecked exception that is not caught.
Why it's wrong here
If log.error throws an unchecked exception, it would propagate out of the catch block and terminate the loop, but this is less likely than an Error from process().
✗
The try-catch block is incorrectly placed inside the for loop, causing the loop to break on any exception.
Why it's wrong here
The try-catch inside the loop is correct for continuing after exceptions; it does not cause termination.

Common exam traps

Common exam trap: answer the scenario, not the keyword

The trap here is that candidates assume all exceptions are caught by `catch (Exception e)`, forgetting that `Error` is a separate branch of `Throwable` and is not caught by that handler, leading to premature loop termination when an `Error` is thrown.

Detailed technical explanation

How to think about this question

In Java, `Error` and `Exception` both extend `Throwable`, but `Error` is reserved for serious system-level failures (e.g., `OutOfMemoryError`, `StackOverflowError`) that applications should not attempt to catch. However, a developer could throw a custom `Error` subclass, and if the `process()` method throws such an `Error`, it will bypass the `catch (Exception e)` block entirely. This is a subtle but critical distinction: `catch (Exception)` does not catch `Error` or `Throwable`. To catch all throwables, one would need `catch (Throwable t)`, but that is generally discouraged for `Error` types.

KKey Concepts to Remember

Read the scenario before looking for a memorised answer.
Find the constraint that changes the correct option.
Eliminate answers that are true in general but not in this case.

TExam Day Tips

Watch for words such as best, first, most likely and least administrative effort.
Review why wrong options are wrong, not only why the correct option is correct.

Key takeaway

Answer the scenario, not the keyword: identify the specific constraint before choosing the most familiar-sounding option.

Real-world example

How this comes up in practice

A small business has 20 workstations on the 192.168.1.0/24 network and one public IP from its ISP. The router uses PAT (NAT overload) so all 20 devices share one public address using different source ports. NAT questions test whether you understand the four address terms and which direction each translation applies.

What to study next

Got this wrong? Here's your next step.

Identify which exam domain this question belongs to, review the core concept, then practise similar questions from the same domain.

Related 1Z0-829 practice-question pages

Use these pages to review the topic behind this question. This is how one missed question becomes focused revision.

Handling Date, Time, Text, Numeric and Boolean Values practice questions

Practise 1Z0-829 questions linked to Handling Date, Time, Text, Numeric and Boolean Values.

Controlling Program Flow practice questions

Practise 1Z0-829 questions linked to Controlling Program Flow.

Utilizing Java Object-Oriented Approach practice questions

Practise 1Z0-829 questions linked to Utilizing Java Object-Oriented Approach.

Handling Exceptions practice questions

Practise 1Z0-829 questions linked to Handling Exceptions.

Working with Arrays and Collections practice questions

Practise 1Z0-829 questions linked to Working with Arrays and Collections.

Working with Streams and Lambda Expressions practice questions

Practise 1Z0-829 questions linked to Working with Streams and Lambda Expressions.

Java Platform Overview and Packaging practice questions

Practise 1Z0-829 questions linked to Java Platform Overview and Packaging.

Java I/O API and Securing Applications practice questions

Practise 1Z0-829 questions linked to Java I/O API and Securing Applications.

1Z0-829 fundamentals practice questions

Practise 1Z0-829 questions linked to 1Z0-829 fundamentals.

1Z0-829 scenario practice questions

Practise 1Z0-829 questions linked to 1Z0-829 scenario.

1Z0-829 troubleshooting practice questions

Practise 1Z0-829 questions linked to 1Z0-829 troubleshooting.

Practice this exam

Start a free 1Z0-829 practice session

Short sessions build daily habit. Longer sessions build exam-day stamina. Try a timed session to simulate real conditions.

10 questions 20 questions 30 questions 50 questions Timed 30

1Z0-829 practice-test guide →Study guide →Browse all practice tests

FAQ

Questions learners often ask

What does this 1Z0-829 question test?

Controlling Program Flow — This question tests Controlling Program Flow — Read the scenario before looking for a memorised answer..

What is the correct answer to this question?

The correct answer is: The process() method throws an Error instead of an Exception. — The code catches `Exception`, but `Error` (and its subclasses like `OutOfMemoryError`, `StackOverflowError`, or custom `Error` types) are not subclasses of `Exception`. In Java, `Throwable` has two main branches: `Exception` (including `RuntimeException`) and `Error`. Since `Error` is not caught by `catch (Exception e)`, it propagates up and terminates the loop. This is the most likely reason for premature termination because the developer assumed all failures would be `Exception` types.

What should I do if I get this 1Z0-829 question wrong?

Identify which exam domain this question belongs to, review the core concept, then practise similar questions from the same domain.

Are there clue words in this question I should notice?

Yes — watch for: "most likely". Probability qualifier — the question wants the most probable cause or outcome, not a guaranteed one. Eliminate low-probability options.

What is the key concept behind this question?

Read the scenario before looking for a memorised answer.

About these practice questions

Courseiva creates original exam-style practice questions with explanations and wrong-answer analysis. It does not publish real exam questions, exam dumps, or protected exam content. Learn why practice questions differ from exam dumps →

How Courseiva writes practice questions · Editorial policy

Keep practising

Question Discussion

Share a tip, memory trick, or ask about the reasoning behind this question. Do not post real exam questions, leaked content, braindumps, or copyrighted exam material. Comments are moderated and may be removed without notice.

Loading comments…

This 1Z0-829 practice question is part of Courseiva's free Oracle certification practice question bank. Courseiva provides original exam-style practice questions with explanations, topic-based practice, mock exams, readiness tracking, and study analytics to help learners prepare for the 1Z0-829 exam.