1Z0-829 sample questions

Question 1

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

```java
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:

```java
// 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 2

**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 3

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:

```java
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 -> {
if (d.amount() > 10000) yield 2;
yield 1;
}
case Withdrawal w -> {
if (w.amount() > 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.

Question 4

A developer is designing a system to model hierarchical configurations. A `ConfigNode` can contain other `ConfigNode` objects. The design must ensure that only specific, predefined types of nodes (`FileNode`, `DirectoryNode`, `PropertyNode`) can extend `ConfigNode`. Additionally, `DirectoryNode` itself must be extensible, but only by `RootDirectoryNode`. Which class and interface structure best achieves these requirements?

Accepted Answer

```java
public sealed class ConfigNode permits FileNode, DirectoryNode, PropertyNode {}
public final class FileNode extends ConfigNode {}
public non-sealed class DirectoryNode extends ConfigNode {}
public final class PropertyNode extends ConfigNode {}
public final class RootDirectoryNode extends DirectoryNode {}
```

Answer

```java
public abstract class ConfigNode {}
public final class FileNode extends ConfigNode {}
public non-sealed class DirectoryNode extends ConfigNode {}
public final class PropertyNode extends ConfigNode {}
public final class RootDirectoryNode extends DirectoryNode {}
```

Answer

```java
public sealed interface ConfigNode permits FileNode, DirectoryNode, PropertyNode {}
public final record FileNode() implements ConfigNode {}
public sealed class DirectoryNode implements ConfigNode permits RootDirectoryNode {}
public final record PropertyNode() implements ConfigNode {}
public final class RootDirectoryNode extends DirectoryNode {}
```

Answer

```java
public sealed class ConfigNode permits FileNode, DirectoryNode, PropertyNode {}
public final class FileNode extends ConfigNode {}
public sealed class DirectoryNode extends ConfigNode {}
public final class PropertyNode extends ConfigNode {}
public final class RootDirectoryNode extends DirectoryNode {}
```

Question 5

A developer is modeling a system for handling financial transactions using a sealed interface. The goal is to ensure that all possible transaction types are handled in a `switch` expression without requiring a `default` case. Given the following sealed hierarchy, what is the problem with the `processTransaction` method?

```java
sealed interface Transaction permits Deposit, Withdrawal, FxTrade {}
final record Deposit(double amount) implements Transaction {}
final record Withdrawal(double amount) implements Transaction {}
// FxTrade is a non-sealed class to allow for future extension
non-sealed class FxTrade implements Transaction {}
class SpotTrade extends FxTrade {}

public class TransactionProcessor {
public static String processTransaction(Transaction tx) {
return switch (tx) {
case Deposit d -> "Processing Deposit";
case Withdrawal w -> "Processing Withdrawal";
case FxTrade f -> "Processing FX Trade";
};
}
}
```

Accepted Answer

The code fails to compile because the `switch` expression is not exhaustive and requires a `default` case.

Answer

The code compiles successfully because all directly permitted subtypes of `Transaction` are covered in the `case` labels.

Answer

The code fails to compile because `FxTrade` is a class and cannot be used in a `case` label with records like `Deposit` and `Withdrawal`.

Answer

The code fails to compile because a `case` for `SpotTrade` must also be included.

Question 6

**Case Study** A development team at a logistics company is modeling various types of shipping containers. The requirements are as follows: 1. There are three primary types of containers: `Standard`, `Refrigerated`, and `OpenTop`. 2. All container types must have a `capacity` and a `containerId`. 3. `Refrigerated` containers must also have a `temperature` setting. 4. The system must be able to handle these specific container types exhaustively in `switch` expressions for processing logic. 5. In the future, a subcontractor may need to introduce a new `HeavyDuty` container type that extends the `Standard` container's functionality. This new type should NOT break the exhaustiveness of existing `switch` statements. Which class hierarchy design best fulfills all these requirements using modern Java features? ```mermaid classDiagram direction LR class ShipmentProcessor { +process(Container c) } class Container { > +double capacity +String containerId } class Standard { +double capacity +String containerId } class Refrigerated { +double capacity +String containerId +double temperature } class OpenTop { +double capacity +String containerId } class HeavyDuty { +double maxLoad } Container <|.. Standard Container <|.. Refrigerated Container <|.. OpenTop Standard <|-- HeavyDuty ShipmentProcessor ..> Container : processes ```

Accepted Answer

```java
public sealed interface Container permits Standard, Refrigerated, OpenTop {}
public non-sealed class Standard implements Container { ... }
public final record Refrigerated(double capacity, String containerId, double temperature) implements Container {}
public final record OpenTop(double capacity, String containerId) implements Container {}
public final class HeavyDuty extends Standard { ... }
```

Answer

```java
public abstract class Container { ... }
public final class Standard extends Container { ... }
public final class Refrigerated extends Container { ... }
public final class OpenTop extends Container { ... }
public final class HeavyDuty extends Standard { ... } // Compilation Error
```

Answer

```java
public sealed interface Container permits Standard, Refrigerated, OpenTop {}
public non-sealed record Standard(double capacity, String containerId) implements Container {}
public final record Refrigerated(double capacity, String containerId, double temperature) implements Container {}
public final record OpenTop(double capacity, String containerId) implements Container {}
public final record HeavyDuty(double capacity, String containerId, double maxLoad) extends Standard { ... } // Compilation Error
```

Answer

```java
public interface Container { ... }
public final record Standard(double capacity, String containerId) implements Container {}
public final record Refrigerated(double capacity, String containerId, double temperature) implements Container {}
public final record OpenTop(double capacity, String containerId) implements Container {}
// No way to extend Standard
```

Question 7

A developer is implementing a `sealed` interface to model different types of application events. A `switch` expression is used to process these events. What is the result of compiling and running the following code?

```java
sealed interface AppEvent permits LoginEvent, LogoutEvent, ErrorEvent {
String getUserId();
}

final record LoginEvent(String userId, String ipAddress) implements AppEvent {}
final record LogoutEvent(String userId, String reason) implements AppEvent {}
final record ErrorEvent(String userId, String errorMsg) implements AppEvent {}

public class EventProcessor {
public String process(AppEvent event) {
return switch (event) {
case LoginEvent le -> "Login from " + le.ipAddress();
case LogoutEvent le -> "Logout because " + le.reason();
// Missing case for ErrorEvent
};
}
}
```

```mermaid
graph TD
A[AppEvent] --> B(LoginEvent)
A --> C(LogoutEvent)
A --> D(ErrorEvent)

style A fill:#f9f,stroke:#333,stroke-width:2px
```

Accepted Answer

The code fails to compile because the `switch` expression is not exhaustive.

Answer

The code compiles successfully, but throws a `java.lang.IncompatibleClassChangeError` at runtime if an `ErrorEvent` is passed.

Answer

The code compiles successfully, but throws a `java.lang.MatchException` at runtime if an `ErrorEvent` is passed.

Answer

The code fails to compile because records cannot implement interfaces.

Question 8

A financial application needs to process transactions from different time zones. A developer writes the following code to handle a transaction timestamp from Tokyo and convert it to the system's default time zone. What is the outcome of executing this code snippet?

Accepted Answer

The code compiles and runs, printing the Tokyo time as 10:00 and the default time adjusted according to the offset difference between the two zones.

Answer

The code fails to compile because `atZone` cannot be called on a `LocalDateTime`.

Answer

The code throws a `DateTimeException` at runtime if the system's default time zone has different DST rules than Tokyo.

Answer

The code compiles and runs, but both printed times will be 10:00 because `withZoneSameInstant` does not change the time-of-day values.

Question 9

A developer is creating a Java module for a billing service. The module `com.example.billing` needs to use a logging framework provided as a service. It also needs to expose its main API package `com.example.billing.api` but keep the implementation package `com.example.billing.internal` hidden. Which `module-info.java` file correctly defines these requirements? (Select TWO)

Accepted Answer

```java
module com.example.billing {
exports com.example.billing.api;
uses com.example.logging.Logger;
}
```

Accepted Answer

```java
module com.example.billing {
requires static com.example.logging;
exports com.example.billing.api;
uses com.example.logging.Logger;
}
```

Answer

```java
module com.example.billing {
opens com.example.billing.api;
requires com.example.logging;
}
```

Answer

```java
module com.example.billing {
exports com.example.billing.api;
provides com.example.logging.Logger with com.example.billing.internal.CustomLogger;
}
```

Answer

```java
module com.example.billing {
exports com.example.billing.*;
uses com.example.logging.Logger;
}
```

Question 10

A developer is implementing a thread-safe counter. To avoid the overhead of explicit locking, they decide to use `java.util.concurrent.atomic.AtomicInteger`. Which statement accurately describes the primary mechanism that makes `AtomicInteger` thread-safe without traditional locks?

Accepted Answer

It uses hardware-level Compare-And-Swap (CAS) operations, which atomically update a value only if it matches an expected value.

Answer

It uses the `volatile` keyword on its internal integer value, which guarantees that all read and write operations are atomic.

Answer

It relies on the `synchronized` keyword for all of its methods, ensuring only one thread can modify the value at a time.

Answer

It uses a `java.util.concurrent.locks.ReentrantLock` internally to protect every read and write operation.

Free 1Z0-829 sample questions

A financial application needs to process transactions from different time zones. A developer writes the following code to handle a transaction timestamp from Tokyo and convert it to the system's default time zone. What is the outcome of executing this code snippet?

A developer is implementing a thread-safe counter. To avoid the overhead of explicit locking, they decide to use `java.util.concurrent.atomic.AtomicInteger`. Which statement accurately describes the primary mechanism that makes `AtomicInteger` thread-safe without traditional locks?

10 more free samples are waiting