1Z0-829 Sample Questions & Answers

Utilizing Java Object-Oriented Approach · Java Inheritance

• A

  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 {}
  

• B

  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 {}
  

• C

  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 {}
  

• D

  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 {}
  

Utilizing Java Object-Oriented Approach · Java Inheritance

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";
};
}
}

• A

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

• B

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

• C

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

• D

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

Utilizing Java Object-Oriented Approach · Java Inheritance

• A

  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
  

• B

  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
  

• C

  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 { ... }
  

• D

  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
  

Utilizing Java Object-Oriented Approach · Java Inheritance

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
};
}
}

• A

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

• B

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

• C

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

• D

  The code fails to compile because records cannot implement interfaces.

Handling date, time, text, numeric and boolean values · Manipulate date, time, duration, period, instant and time-zone objects using Date-Time API

• A

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

• B

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

• C

  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.

• D

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

Packaging and deploying Java code and use the Java Platform Module System · Define modules and their dependencies, expose module content including for reflection. Define services, producers, and consumers

• A

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

• B

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

• C

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

• D

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

• E

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

Managing concurrent code execution · Develop thread-safe code, using different locking mechanisms and concurrent API

• A

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

• B

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

• C

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

• D

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

Implementing Localization · Implement localization using locales, resource bundles, parse and format messages, dates, times, and numbers including currency and percentage values

• A

  The code will throw an IllegalArgumentException because currency symbols are not specified.

• B

  $12,345.67
  12.345,67 €

• C

  $12,345.67
  €12.345,67

• D

  12345.67 USD
  12345.67 EUR

Working with Streams and Lambda expressions · Use Java object and primitive Streams, including lambda expressions implementing functional interfaces, to supply, filter, map, consume, and sort data

• A

  list.stream()
  .filter(Optional::isPresent)
  .map(Optional::get)
  .collect(Collectors.toList());
  

• B

  list.stream()
  .flatMap(Optional::stream)
  .collect(Collectors.toList());
  

• C

  list.stream()
  .map(o -> o.orElse(""))
  .filter(s -> !s.isEmpty())
  .collect(Collectors.toList());
  

• D

  list.stream()
  .map(Optional::get)
  .collect(Collectors.toList());
  

Utilizing Java Object-Oriented Approach · Java Inheritance

• A

  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; }
  

• B

  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 {}
  

• C

  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 {}
  

• D

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