1Z0-829 sample questions

Question 1

A developer is writing a JDBC utility to fetch user data. They need to ensure that the `Connection` and `PreparedStatement` are always closed, even if an exception occurs during result set processing. Which code structure provides the most robust and modern approach to achieve this?

Accepted Answer

A `try-with-resources` statement that declares both the `Connection` and `PreparedStatement` in the resource specification block.

Answer

A `try-catch` block for the main logic, with a `finally` block that contains nested `try-catch` blocks to close each resource individually.

Answer

A `try-finally` block where the `try` block handles all operations and the `finally` block closes the resources in reverse order of their creation.

Answer

A single `try-catch` block where `close()` is called on each resource at the end of the `try` block.

Question 2

True or False: In the Java Platform Module System (JPMS), if module `A` requires module `B` (`requires B;`), and module `B` exports package `p1` (`exports p1;`), then module `A` can access public types in package `p1` by default.

Accepted Answer

True

Answer

False

Question 3

A developer is working with a `java.util.concurrent.ExecutorService` to run asynchronous tasks. After submitting all tasks, the developer wants to shut down the service gracefully, allowing currently executing tasks to finish but rejecting any new tasks. Which method should be called on the `ExecutorService` instance?

Accepted Answer

`shutdown()`

Answer

`shutdownNow()`

Answer

`awaitTermination(long timeout, TimeUnit unit)`

Answer

`close()`

Question 4

Consider the following record definition and its usage. What will be the output of this program?

Accepted Answer

10, 20 true

Answer

10, 20 false

Answer

A compilation error occurs because records cannot have constructors with bodies.

Answer

The code throws an `IllegalArgumentException` at runtime.

Question 5

A developer is serializing an object of class `Employee`. The `Employee` class contains a field for a password, which should not be saved to disk for security reasons. The class also needs to maintain a version UID for compatibility. Which two modifications are necessary to achieve this? (Select TWO)

Accepted Answer

Implement the `java.io.Serializable` interface.

Accepted Answer

Mark the `password` field with the `transient` keyword.

Answer

Mark the `password` field with the `volatile` keyword.

Answer

Add a `private static final long serialVersionUID` field.

Answer

Make the `password` field `private static`.

Question 6

**Case Study:** A logistics company is modernizing its package tracking system. The system needs to represent different types of packages, each with specific attributes. The requirements are as follows: 1. There are three and only three types of packages: `Standard`, `Express`, and `Fragile`. 2. No other package types should be permissible in the system to ensure strict domain modeling. 3. A `Standard` package has a weight. 4. An `Express` package has a weight and a priority level (an integer). 5. A `Fragile` package has a weight and special handling instructions (a String). 6. All package types should be immutable data carriers. A senior developer proposes using a combination of sealed interfaces and records to model this domain. The goal is to create a type-safe hierarchy that can be effectively processed, for example, in a `switch` expression for calculating shipping costs. Which code implementation best satisfies all the given requirements?

Accepted Answer

```java public sealed interface Package permits Standard, Express, Fragile {} public record Standard(double weight) implements Package {} public record Express(double weight, int priority) implements Package {} public record Fragile(double weight, String instructions) implements Package {} ```

Answer

```java public abstract class Package {} public class Standard extends Package { double weight; } public class Express extends Package { double weight; int priority; } public class Fragile extends Package { double weight; String instructions; } ```

Answer

```java public interface Package {} public final record Standard(double weight) implements Package {} public final record Express(double weight, int priority) implements Package {} public final record Fragile(double weight, String instructions) implements Package {} ```

Answer

```java public enum PackageType { STANDARD, EXPRESS, FRAGILE } public class Package { PackageType type; double weight; int priority; String instructions; } ```

Question 7

**Case Study** A software architect is designing a system for a payment gateway. The system must handle different types of payment methods. The core requirement is to have a common `PaymentMethod` type, but restrict implementations to a known, fixed set: `CreditCard`, `PayPal`, and `BankTransfer`. No other developers, now or in the future, should be able to create new, unknown implementations of `PaymentMethod` outside of the core payment module. This strict control is necessary for security and compliance audits. The architect wants to model this domain using the most effective and modern object-oriented features available in Java 17 to enforce this restriction at the compiler level. Which design provides the strongest compile-time safety and best expresses the architect's intent?

Accepted Answer

Define `PaymentMethod` as a `sealed` interface that explicitly `permits` only the `CreditCard`, `PayPal`, and `BankTransfer` classes/records to implement it.

Answer

Define `PaymentMethod` as a public abstract class. Place `CreditCard`, `PayPal`, and `BankTransfer` in the same package and make their constructors package-private.

Answer

Define `PaymentMethod` as a public interface. Implement it with `final` classes for `CreditCard`, `PayPal`, and `BankTransfer`.

Answer

Create an enum `PaymentType` with values `CREDIT_CARD`, `PAYPAL`, `BANK_TRANSFER`, and a factory class that returns instances of corresponding private classes.

Question 8

A developer is building a system that processes different geometric shapes. The following sealed interface is defined:

sealed interface Shape permits Circle, Rectangle {}
final class Circle implements Shape { /* ... */ }
final class Rectangle implements Shape { /* ... */ }

Later, another developer in a different package tries to define a new shape:

// in another package
public final class Triangle implements Shape { /* ... */ }

What is the result of this attempt?

Accepted Answer

The code fails to compile because `Triangle` is not in the `permits` list of the `Shape` interface.

Answer

The code compiles successfully, but will throw a runtime exception if a `Triangle` is instantiated.

Answer

The code compiles successfully, allowing `Triangle` to be a valid subtype of `Shape`.

Answer

The code fails to compile because `Triangle` must be in the same package as `Shape`.

Question 9

**Case Study** A financial services company is designing a system to model various types of accounts. The system must support `CheckingAccount`, `SavingsAccount`, and `InvestmentAccount`. A key architectural requirement is that the set of account types is fixed and cannot be extended by other development teams or third-party libraries. This ensures that all account processing logic can be handled exhaustively and safely within the core application. The architect wants to create a common supertype called `Account` that all specific account types will implement. The solution must enforce the closed hierarchy at compile time and should use modern Java features for conciseness and type safety. Which code snippet best models this domain according to the requirements? ```mermaid classDiagram direction LR class Account { > +getAccountNumber() +getBalance() } class CheckingAccount class SavingsAccount class InvestmentAccount Account <|.. CheckingAccount : implements Account <|.. SavingsAccount : implements Account <|.. InvestmentAccount : implements ```

Accepted Answer

```java public sealed interface Account permits CheckingAccount, SavingsAccount, InvestmentAccount { /* ... */ } public final record CheckingAccount(...) implements Account { /* ... */ } public final record SavingsAccount(...) implements Account { /* ... */ } public final record InvestmentAccount(...) implements Account { /* ... */ } ```

Answer

```java public abstract class Account { /* ... */ } public final class CheckingAccount extends Account { /* ... */ } public final class SavingsAccount extends Account { /* ... */ } public final class InvestmentAccount extends Account { /* ... */ } ```

Answer

```java public interface Account { /* ... */ } public final class CheckingAccount implements Account { /* ... */ } public final class SavingsAccount implements Account { /* ... */ } public final class InvestmentAccount implements Account { /* ... */ } ```

Answer

```java public enum AccountType { CHECKING, SAVINGS, INVESTMENT } public class Account { private AccountType type; // ... common fields } ```

Question 10

A financial data processing application uses a sealed interface Transaction with three implementing records: Deposit, Withdrawal, and Transfer. A method is designed to process a list of these transactions and calculate a risk score. Examine the following code:

sealed interface Transaction permits Deposit, Withdrawal, Transfer {}
record Deposit(double amount) implements Transaction {}
record Withdrawal(double amount) implements Transaction {}
record Transfer(double amount, String recipient) implements Transaction {}

public class TransactionProcessor {
public int calculateRisk(Transaction tx) {
return switch (tx) {
case Deposit d -&gt; {
if (d.amount() &gt; 10000) yield 2;
yield 1;
}
case Withdrawal w -&gt; {
if (w.amount() &gt; 5000) yield 3;
yield 1;
}
// Missing Transfer case
};
}
}

What is the result of compiling the TransactionProcessor class?

Accepted Answer

The code fails to compile because the `switch` expression does not cover all permitted subtypes of the sealed interface `Transaction`.

Answer

The code compiles successfully, but will throw a `MatchException` at runtime if a `Transfer` object is passed to the `calculateRisk` method.

Answer

The code compiles successfully, and the method will return 0 if a `Transfer` object is passed.

Answer

The code fails to compile because `yield` cannot be used inside an `if` statement within a `switch` expression block.

Java SE 17 Developer (OCP) Practice Questions

Create an account to continue.

Create an account to continue.

Related exams