Question 439 of 509

Handling Exceptions →hardMultiple ChoiceObjective-mapped

Quick Answer

The correct approach is to catch InsufficientFundsException and NetworkException in separate catch blocks, handling each locally so that processPayment returns normally after logging. This works because catching both the unchecked InsufficientFundsException and the checked NetworkException prevents them from propagating up the call stack, while the nested try-catch around logFailure—which itself throws Exception—ensures that even if the audit logging fails, a fallback logger records the error and the method still completes without throwing. On the 1Z0-829 exam, this scenario tests your understanding of multi-catch versus separate catch blocks, the distinction between checked and unchecked exceptions in a custom hierarchy, and the importance of recovery without breaking a method’s throws clause. A common trap is forgetting that logFailure throws a checked Exception, which must be caught locally to avoid forcing processPayment to declare it. Remember the mnemonic: “Catch locally, log fully, fallback safely—never let logging break your flow.”

1Z0-829 Handling Exceptions Practice Question

This 1Z0-829 practice question tests your understanding of handling exceptions. 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.

You are developing a microservice that processes order payments. The service uses a custom exception hierarchy: PaymentException (checked), InsufficientFundsException (unchecked, extends RuntimeException), and NetworkException (checked, extends PaymentException). The processPayment method is declared as: public void processPayment(Order order) throws PaymentException. Inside, a call to an external payment gateway may throw InsufficientFundsException or NetworkException. The requirement is to log all payment failures to an audit system, but the service must continue processing other orders. The audit logging method is: public void logFailure(String message) throws Exception. Which approach best handles exceptions while meeting the requirements?

Clue words in this question

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

Clue: "best"
Why it matters: Signals that multiple options may be partially correct. Choose the option that most directly solves the exact problem described, not the one that sounds most complete.

Question 1hardmultiple choice

Full question →

A
Wrap the call to the payment gateway in a try-catch-finally block. In the catch block, log the error using logFailure. In the finally block, return from the method.
Why wrong: Incorrect: Even if the method returns, the catch block must handle the exception properly; logFailure is declared to throw Exception, so it must be caught or declared.
B
Add a throws clause to processPayment for InsufficientFundsException and NetworkException, and let the caller handle them.
Why wrong: Incorrect: The caller would need to handle these exceptions, and the requirement is to continue processing, not propagate.
C
Catch InsufficientFundsException and NetworkException in separate catch blocks. Inside each, try to call logFailure; if logFailure throws an exception, catch it and log a generic message to a fallback logger. Then return normally from processPayment without throwing.
Correct: This handles all exceptions, logs the failure, and allows the method to return normally so the service continues.
D
Catch InsufficientFundsException and NetworkException separately, log the error using logFailure, and then throw a new RuntimeException to indicate failure.
Why wrong: Incorrect: Throwing a RuntimeException propagates the error, stopping processing of other orders.

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

✓

Catch InsufficientFundsException and NetworkException in separate catch blocks. Inside each, try to call logFailure; if logFailure throws an exception, catch it and log a generic message to a fallback logger. Then return normally from processPayment without throwing.

Option C is correct because it ensures that both checked (NetworkException) and unchecked (InsufficientFundsException) exceptions are caught locally, allowing the service to log the failure via logFailure (which itself throws Exception) without propagating the exception up the call stack. By catching any exception from logFailure and falling back to a generic logger, the method guarantees that processPayment returns normally, meeting the requirement to continue processing other orders. This approach respects the checked exception contract of processPayment (throws PaymentException) while handling all failure scenarios internally.

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.

✗
Wrap the call to the payment gateway in a try-catch-finally block. In the catch block, log the error using logFailure. In the finally block, return from the method.
Why it's wrong here
Incorrect: Even if the method returns, the catch block must handle the exception properly; logFailure is declared to throw Exception, so it must be caught or declared.
✗
Add a throws clause to processPayment for InsufficientFundsException and NetworkException, and let the caller handle them.
Why it's wrong here
Incorrect: The caller would need to handle these exceptions, and the requirement is to continue processing, not propagate.
✓
Catch InsufficientFundsException and NetworkException in separate catch blocks. Inside each, try to call logFailure; if logFailure throws an exception, catch it and log a generic message to a fallback logger. Then return normally from processPayment without throwing.
Why this is correct
Correct: This handles all exceptions, logs the failure, and allows the method to return normally so the service continues.
Clue confirmation
The clue word "best" in the question point toward this answer.
Related concept
Read the scenario before looking for a memorised answer.
✗
Catch InsufficientFundsException and NetworkException separately, log the error using logFailure, and then throw a new RuntimeException to indicate failure.
Why it's wrong here
Incorrect: Throwing a RuntimeException propagates the error, stopping processing of other orders.

Common exam traps

Common exam trap: answer the scenario, not the keyword

The trap here is that candidates often think they must either propagate all exceptions (option B) or convert them to runtime exceptions (option D), but the requirement to 'continue processing other orders' means the method must not throw any exception after logging, which is achieved by catching all exceptions locally and ensuring the method returns normally.

Detailed technical explanation

How to think about this question

Under the hood, Java's exception handling ensures that checked exceptions must be either caught or declared, while unchecked exceptions can propagate unchecked. In this scenario, logFailure throws a checked Exception, so any call to it must be wrapped in a try-catch or the enclosing method must declare it. The fallback logger in option C ensures that even if logFailure fails, the original payment exception is still handled gracefully, preventing the loss of audit information. In a real-world microservice, this pattern is critical for maintaining resilience: a failure in the audit system should not cause the payment processing to fail, and the service should log the audit failure separately.

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 practitioner preparing for the 1Z0-829 exam encounters this exact type of scenario on the job. The correct answer here is not the most general option — it is the best answer for the specific constraint described. Answer the scenario, not the keyword: identify the specific constraint before choosing the most familiar-sounding option. Real exam questions reward reading the full scenario before eliminating options, because the constraint defines which answer fits.

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?

Handling Exceptions — This question tests Handling Exceptions — Read the scenario before looking for a memorised answer..

What is the correct answer to this question?

The correct answer is: Catch InsufficientFundsException and NetworkException in separate catch blocks. Inside each, try to call logFailure; if logFailure throws an exception, catch it and log a generic message to a fallback logger. Then return normally from processPayment without throwing. — Option C is correct because it ensures that both checked (NetworkException) and unchecked (InsufficientFundsException) exceptions are caught locally, allowing the service to log the failure via logFailure (which itself throws Exception) without propagating the exception up the call stack. By catching any exception from logFailure and falling back to a generic logger, the method guarantees that processPayment returns normally, meeting the requirement to continue processing other orders. This approach respects the checked exception contract of processPayment (throws PaymentException) while handling all failure scenarios internally.

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: "best". Signals that multiple options may be partially correct. Choose the option that most directly solves the exact problem described, not the one that sounds most complete.

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

Last reviewed: Jun 11, 2026

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.