1Z0-829 Practice Test 27 — 15 Questions

Question 1

A developer compiles a modular application with javac -d out --module-source-path src $(find src -name '*.java'). The source tree contains src/com.example.inventory/module-info.java and several packages. Later, a colleague runs the application with java --module-path out --module com.example.inventory/com.example.inventory.Main. The main class is in package com.example.inventory. Which statement describes what must be true for this launch to succeed?

Choose an answer to begin — your selection is scored in the full session.

Accepted Answer

The main class must be specified as module/class, and the module must be observable on the module path at launch time.. Launching a modular application requires the module to be observable on the module path and the entry point to be identified with module/class syntax. The launcher performs resolution, then loads the named class from that resolved module. Exports and opens govern access for other modules, not the launcher's ability to invoke the main class, so they do not determine success in this scenario.

Answer

The module must export com.example.inventory or open it to at least the launching code.

Answer

The compiled output directory must be packaged as a modular JAR before the java command can use it.

Answer

The module must declare requires java.base explicitly, otherwise resolution fails.

Question 2

A reporting service must print a monetary amount stored in a double using the Locale for Germany, so that the output uses a comma as the decimal separator and a period as the grouping separator. Which approach produces correctly localized output for that locale?

Accepted Answer

String.format(Locale.GERMANY, "%,.2f", amount). Localized numeric formatting requires supplying the target locale to the formatting API. String.format with a leading Locale argument and the %,.2f conversion applies German grouping and decimal separators, whereas the overload without a locale, a locale-less DecimalFormat pattern, and manual character replacement all fall back to the JVM default or fail to add grouping.

Answer

String.format("%,.2f", amount)

Answer

new DecimalFormat("#,###.00").format(amount)

Answer

Double.toString(amount).replace('.', ',')

Question 3

A Java 17 application is packaged as a modular JAR with a module-info.class that declares 'requires transitive java.logging;'. The application is then placed on the module path along with another module that requires the application module. Which two statements are true about the readability of java.logging? (Choose two.)

Accepted Answer

The application module can read java.logging.. The 'requires transitive' directive in a module descriptor has two effects: it makes the dependency readable by the declaring module, and it propagates that readability to any module that requires the declaring module. Therefore, both the application module and its dependents can read java.logging. The other options incorrectly suggest that explicit requires are needed or that readability is restricted.

Answer

Modules that require the application module must also explicitly require java.logging to use its types.

Answer

Only modules that explicitly require java.logging can read it.

Answer

The application module cannot read java.logging because it is not exported.

Question 4

A developer needs to create a class that cannot be instantiated directly but can be subclassed. Which keyword should be used in the class declaration?

Accepted Answer

abstract. The abstract modifier makes a class non-instantiable while still allowing it to be extended. Subclasses can provide implementations for any abstract methods. The other modifiers either prevent subclassing (final), are invalid for top-level classes (static), or restrict subclassing without preventing instantiation (sealed).

Answer

final

Answer

static

Answer

sealed

Question 5

A scheduler must execute one of several actions depending on a legacy integer status code, and the developer writes:

```java
int status = 2;
switch (status) {
    case 1:
        System.out.print("A");
    case 2:
        System.out.print("B");
    case 3:
        System.out.print("C");
        break;
    default:
        System.out.print("D");
}
```

What is printed?

Accepted Answer

BC. In a colon-form switch statement, matching a label transfers control to that label and execution continues downward through subsequent labels until a break is reached or the switch ends. Matching case 2 prints B, falls through into case 3 printing C, and the break there exits. Default is not evaluated because a matching label already redirected execution.

Answer

B

Answer

BCD

Answer

Compilation fails because case 2 lacks a break statement.

Question 6

A software company is designing a library of geometric shapes. They define an interface `Shape` with a method `double area()`. They want to provide a default implementation for a method `void printDescription()` that outputs a generic description, but allow specific shapes like `Circle` to override it if needed. Which feature of Java interfaces should they use?

Accepted Answer

Declare `printDescription()` as a default method in the `Shape` interface.. Default methods in interfaces allow providing a method body that implementing classes inherit automatically. They can choose to override it. This is ideal for adding a generic description method to the `Shape` interface without forcing every shape to implement it. Static and private methods do not serve this purpose, and using an abstract class adds unnecessary complexity.

Answer

Declare `printDescription()` as an abstract method and provide an implementation in an abstract class that implements `Shape`.

Answer

Declare `printDescription()` as a static method in the `Shape` interface.

Answer

Declare `printDescription()` as a private method in the `Shape` interface.

Question 7

Which class should be used to read a text file line by line efficiently, automatically closing the file after use?

Accepted Answer

Files.newBufferedReader(Paths.get("file.txt")) used within a try-with-resources block.. For efficient line-by-line reading of a text file with automatic resource management, Files.newBufferedReader combined with try-with-resources is the best choice. It returns a BufferedReader that provides the lines() method and handles encoding. This approach is both efficient and safe, ensuring the file is closed properly.

Answer

new FileReader("file.txt") wrapped in a BufferedReader, used without try-with-resources.

Answer

new Scanner(new File("file.txt")) used within a try-with-resources block.

Answer

Files.readAllLines(Paths.get("file.txt"))

Question 8

A developer is designing a class `Report` that should prevent direct instantiation from other classes but allow controlled creation through a static factory method. The class also needs to ensure that subclasses cannot change its behavior after construction. Which two changes should the developer make? (Choose two.)

Accepted Answer

Declare the constructor as private.. To prevent direct instantiation, the constructor must be inaccessible, so private is appropriate. To prevent subclasses from altering behavior, the class should not be extensible, so final is appropriate. Together they enforce controlled creation via a static factory and guarantee that the class's behavior cannot be changed through inheritance. The other options either weaken encapsulation or do not prevent extension.

Answer

Declare the class as abstract.

Answer

Declare the static factory method as final.

Answer

Declare all fields as protected.

Question 9

A developer needs to read a text file line by line using the java.nio.file API. The file is encoded in UTF-8. Which method should be used to obtain a Stream<String> where each element is a line from the file?

Accepted Answer

Files.lines(Path, Charset). Files.lines(Path, Charset) is specifically designed to return a Stream<String> of lines from a file, using the given charset. It reads the file lazily, making it suitable for large files. The other options either return a List, require additional steps, or read the entire file into memory. While Files.newBufferedReader().lines() also returns a stream, it involves more code and resource management. The direct method is Files.lines.

Answer

Files.readString(Path, Charset).lines()

Answer

Files.newBufferedReader(Path, Charset).lines()

Answer

Files.readAllLines(Path, Charset)

Question 10

A developer writes a method that throws a custom checked exception `ValidationException` and wants to ensure that a `finally` block executes regardless of whether an exception is thrown. The method contains the following code:

```java
public void validate() throws ValidationException {
    try {
        checkInput();
    } finally {
        cleanup();
    }
}
```

Which statement is true about the execution of the `finally` block?

Accepted Answer

The `finally` block always executes, whether `checkInput()` completes normally or throws an exception.. A `finally` block is guaranteed to execute when the try block exits, whether normally or due to an exception. This makes it ideal for cleanup operations. The only exceptions are if the JVM exits or the thread is abruptly terminated. It does not matter what type of exception is thrown or whether it is caught; the finally block runs before control leaves the try-finally construct.

Answer

The `finally` block executes only if `checkInput()` does not throw any exception.

Answer

The `finally` block executes only if `checkInput()` throws a `ValidationException`.

Answer

The `finally` block executes only if `checkInput()` throws an exception that is not a `ValidationException`.

Question 11

A payment processing system defines a class `Payment` with a method `void process()` that validates and executes a transaction. The development team wants to create a subclass `CreditCardPayment` that adds card-specific validation before calling the generic processing logic. To ensure that all payment types follow the same core processing steps while allowing additional behavior, which approach correctly uses inheritance and method overriding?

Accepted Answer

In `CreditCardPayment`, override `process()` and call `super.process()` at the beginning of the method.. The correct approach is to override `process()` in the subclass and call `super.process()` to reuse the inherited validation and execution steps. This maintains a single source of truth for core processing while allowing the subclass to add its own validation. It demonstrates proper use of inheritance, method overriding, and the `super` keyword to extend behavior without duplicating code.

Answer

In `CreditCardPayment`, declare a new method `process()` with a different return type, such as `boolean`, to indicate success.

Answer

In `Payment`, mark `process()` as `final`, and in `CreditCardPayment`, define a new method with the same body.

Answer

In `CreditCardPayment`, override `process()` and copy the entire implementation from `Payment`, then add the extra validation.

Question 12

A Java 17 application is deployed as a set of modular JARs. The module com.example.app requires com.example.lib. Which two statements are true about the readability and accessibility between these modules? (Choose two.)

Accepted Answer

If com.example.lib does not export a package, com.example.app cannot access public types in that package.. Readability is granted by the 'requires' directive, but accessibility requires that the providing module exports the relevant package. Therefore, com.example.app can access public types only in packages exported by com.example.lib. Exporting one's own packages is unrelated to reading another module, and requires is not bidirectional.

Answer

com.example.app must also export its own packages to read com.example.lib.

Answer

com.example.app can access all public types in all packages of com.example.lib, regardless of exports.

Answer

The 'requires' directive in com.example.app makes com.example.lib read com.example.app automatically.

Question 13

A Java 17 application is packaged as a modular JAR with a module descriptor that contains `requires transitive com.acme.core;`. A separate module, com.acme.client, declares `requires com.acme.app;`. Which statement is true about the readability of com.acme.core from com.acme.client?

Accepted Answer

com.acme.client can read com.acme.core because the transitive modifier propagates readability to modules that depend on com.acme.app.. The `requires transitive` modifier propagates readability: any module that reads the declaring module also reads the module named in the directive. Since com.acme.client requires com.acme.app, and com.acme.app requires transitive com.acme.core, com.acme.client automatically reads com.acme.core without an additional requires clause.

Answer

The transitive modifier applies only to automatic modules and has no effect on explicit modules.

Answer

com.acme.client can read com.acme.core only if com.acme.core exports the packages that com.acme.client uses.

Answer

com.acme.client cannot read com.acme.core unless it declares its own `requires com.acme.core;` directive.

Question 14

A payroll application must classify each employee's weekly hours into a pay band. The developer writes: ```java int hours = 44; String band = switch (hours) { case 0, 1, 2 -> "NONE"; default -> { if (hours <= 40) yield "STANDARD"; else if (hours <= 50) yield "OVERTIME"; else yield "EXCESSIVE"; } }; System.out.println(band); ``` What is printed?

Accepted Answer

OVERTIME. A switch expression must produce a value on every path, and the default arm here is a block that uses yield to return a result. With hours equal to 44, no constant label matches, so the default block executes; its first condition fails and the second succeeds, yielding OVERTIME. The arrow-form block with yield is the key construct being exercised.

Answer

A compile-time error, because a switch expression cannot use default together with constant case labels.

Answer

EXCESSIVE

Answer

STANDARD

Question 15

A developer needs to concatenate a stream of strings into a single comma-separated string, but also wants to prefix the result with '[' and suffix it with ']'. The code is:

String result = Stream.of("a", "b", "c")
    .collect(Collectors.joining(", ", "[", "]"));

What is the value of result?

Accepted Answer

[a, b, c]. Collectors.joining has three overloads: joining(), joining(delimiter), and joining(delimiter, prefix, suffix). The three-argument version inserts the delimiter only between elements and wraps the entire result with the prefix and suffix. For the stream "a", "b", "c" with delimiter ", ", prefix "[", and suffix "]", the output is "[a, b, c]". The other options omit or misplace the prefix, suffix, or delimiter.

Answer

[a, b, c, ]

Answer

[a, b, c

Answer

a, b, c