1Z0-829 Practice Test 31 — 15 Questions

Question 1

A team is writing a Java 17 class `TemperatureReader` whose constructor opens a hardware sensor. The constructor declares `throws IOException` and may fail after acquiring the sensor. They want the class to be usable in a try-with-resources statement so the sensor is always released. Which change should they make?

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

Accepted Answer

Have `TemperatureReader` implement `java.lang.AutoCloseable` and provide a `public void close()` method.. The try-with-resources statement accepts any resource whose type implements `AutoCloseable` or `Closeable`. Implementing `AutoCloseable` with a public `close()` method gives the constructor-acquired sensor deterministic release semantics and makes the class directly usable as a resource. Finalization, protected methods, and static helpers do not satisfy that compile-time contract.

Answer

Declare a `protected abstract void close()` method so subclasses can release the sensor.

Answer

Add a `static void close(TemperatureReader r)` method and call it from a `finally` block.

Answer

Override the `finalize()` method to release the sensor, because finalization runs before garbage collection.

Question 2

A payment processing system defines an abstract class `PaymentProcessor` with an abstract method `process(double amount)` and a concrete method `logTransaction(String id)`. A developer writes a subclass `CreditCardProcessor` that extends `PaymentProcessor` but does not implement `process`. What is the result when compiling the `CreditCardProcessor` class?

Accepted Answer

Compilation fails because `CreditCardProcessor` must be declared abstract or implement the abstract method `process`.. A concrete class that extends an abstract class must implement all inherited abstract methods. Since `CreditCardProcessor` is concrete and does not implement `process`, the compiler forces it to be abstract or to provide the method. The other options misstate Java's compile-time enforcement or confuse concrete and abstract method obligations.

Answer

Compilation succeeds, and calling `process` on a `CreditCardProcessor` instance throws `UnsupportedOperationException` at runtime.

Answer

Compilation fails because the subclass must also override the concrete method `logTransaction` to match the abstract class contract.

Answer

Compilation succeeds because `PaymentProcessor` is abstract and the abstract method is inherited but not required to be implemented.

Question 3

A developer is designing a class hierarchy for a banking application. They need to ensure that the `Account` class provides a common implementation for `deposit()` and `withdraw()` but also declares an abstract method `calculateInterest()`. Additionally, they want to prevent any further subclassing of a specific `SavingsAccount` class. Which two statements are true about the use of abstract and final modifiers in this design? (Choose two.)

Accepted Answer

An abstract class can have both abstract and concrete methods.. An abstract class can mix abstract and concrete methods, allowing shared code and enforced implementation. It also cannot be instantiated directly. A final class cannot be extended, and a final method cannot be overridden. A class cannot be both abstract and final because their meanings conflict.

Answer

A final method can be overridden in a subclass.

Answer

A final class can be extended if it has a default constructor.

Answer

A class can be both abstract and final.

Question 4

A developer processes a Stream named codes and wants to remove duplicates while preserving the order in which codes first appear. The developer writes: List result = codes.distinct().collect(Collectors.toList()); Which statement about this code is true?

Accepted Answer

It preserves encounter order and removes duplicates based on equals and hashCode of the elements.. For an ordered stream, distinct keeps the first occurrence of each element and discards later duplicates, using equals and hashCode for comparison. Collecting into a List therefore yields unique strings in first-encounter order. The operation does not force unordered processing, does not reject nulls, and does not use identity comparison.

Answer

It uses identity comparison rather than equals, so two different String objects with the same characters are both retained.

Answer

It throws IllegalStateException if the stream contains more than one null element because distinct cannot handle nulls.

Answer

It removes duplicates but does not guarantee order because distinct always returns an unordered stream.

Question 5

A Java 17 method processes a queue of jobs and throws `InterruptedException` when the worker thread is interrupted. The surrounding code catches `Exception` broadly and logs the failure, then continues processing. A reviewer flags this as a defect. Which statement best explains the defect?

Accepted Answer

The broad catch swallows the interrupt status, so the thread continues processing instead of honoring cancellation.. The catch of `Exception` intercepts `InterruptedException` and discards the interrupt signal, because the exception is thrown after the interrupt status is cleared. The worker then continues instead of cooperating with shutdown. The correct remedy is to restore the status with `Thread.currentThread().interrupt()` or to rethrow, so callers can observe cancellation.

Answer

`InterruptedException` is an unchecked exception, so the compiler should have rejected the catch clause.

Answer

Catching `Exception` prevents the JVM from ever delivering an `InterruptedException` to the method.

Answer

Logging the exception is itself wrong; interrupted threads must always call `System.exit()` to terminate.

Question 6

A developer needs to read a file's content as a String in a single call, assuming the file is small (a few kilobytes) and encoded in UTF-8. Which method is most appropriate?

Accepted Answer

Files.readString(Path, Charset). Files.readString(Path, Charset) is purpose-built to read an entire file into a String using a specified charset. It handles opening, reading, and closing the file internally, and throws IOException on failure. For small UTF-8 files, it is the simplest and most direct API. Other methods either split lines, require stream handling, or involve manual byte-to-String conversion, making them less suitable for this straightforward requirement.

Answer

Files.lines(Path, Charset) and collect with Collectors.joining()

Answer

Files.readAllLines(Path, Charset) and join the lines

Answer

new String(Files.readAllBytes(Path), Charset)

Question 7

A company defines `public sealed interface Vehicle permits Car, Truck { }`. A developer writes `public final class Car implements Vehicle` in the same package. Which statement about this code is true?

Accepted Answer

The code compiles because Car is listed in the permits clause and is declared final, satisfying the sealed hierarchy requirement.. Sealed types restrict which subtypes may extend or implement them, and each permitted subtype must itself be final, sealed, or non-sealed. Because Car is explicitly listed in the permits clause, implements Vehicle, and is declared final, it fully satisfies the rules. The hierarchy is valid and compiles, so the accurate statement is the one acknowledging successful compilation under these conditions.

Answer

The code fails to compile because Car must be declared non-sealed since it is a class rather than an interface.

Answer

The code compiles only if Car is declared in a different package than Vehicle.

Answer

The code fails to compile because a sealed interface cannot permit a class; it can only permit other interfaces.

Question 8

A developer needs to iterate over an array of sensor readings and print each reading until a reading equal to -1 is encountered, at which point iteration must stop immediately and no further readings should be printed. Which loop construct best matches this requirement?

Accepted Answer

A for-each loop over the array that checks for -1 inside the body and uses break to exit.. A for-each loop paired with break stops iteration the instant the sentinel is detected and prints nothing further. The for-each construct handles traversal safely, and break provides the required early exit. Alternatives that skip a single element or guarantee a first execution fail to honour the immediate termination specified for the sensor readings.

Answer

A while loop with a manually incremented index that never compares the current element to -1.

Answer

A for-each loop over the array that checks for -1 and uses continue instead of break.

Answer

A do-while loop that processes the array at least once regardless of whether the first element is -1.

Question 9

A developer writes the following method to print a countdown for a rocket launch:

```java
public static void countdown() {
    for (int i = 5; i > 0; i--) {
        if (i == 3) {
            continue;
        }
        System.out.print(i + " ");
    }
    System.out.print("Liftoff");
}
```

What is printed when countdown() is invoked?

Accepted Answer

5 4 2 1 Liftoff. The continue statement abandons the remainder of the current iteration and moves to the update expression, so the value 3 is never printed while 5, 4, 2, and 1 are. After the loop ends, the trailing print statement executes normally, appending 'Liftoff'. The result is the countdown with the single skipped value followed by the final message.

Answer

5 4 2 1 Liftoff, then the loop repeats

Answer

5 4 2 1

Answer

5 4 3 2 1 Liftoff

Question 10

A team is modeling a payment hierarchy. They need a base type that enforces all subclasses to implement a `process()` method, but also want to provide a concrete `log()` method that reuses a default implementation. The base type should not allow multiple inheritance of state. Which Java construct best fits these requirements?

Accepted Answer

An abstract class with an abstract process() method and a concrete log() method.. An abstract class allows a mix of abstract and concrete methods, so process() can be left abstract for subclasses to implement while log() is inherited as-is. Because Java permits only single inheritance of classes, multiple inheritance of state is avoided. Interfaces can provide default methods, but they cannot enforce implementation if a default is supplied, and they cannot hold instance state.

Answer

A sealed interface permitting specific payment classes and declaring process() as abstract.

Answer

An interface with a default process() method and a private log() method.

Answer

A concrete class with a process() method that throws UnsupportedOperationException.

Question 11

A developer needs to partition a stream of `Employee` objects into two groups: those with a salary greater than 100000 and those with a salary less than or equal to 100000. The result must be a `Map>`. Which collector should be used?

Accepted Answer

Collectors.partitioningBy(e -> e.getSalary() > 100000). partitioningBy is the only collector that guarantees a Map with both Boolean keys present, returning empty lists for partitions with no elements. This matches the requirement of a two-way split into salary above and at-or-below 100000. groupingBy can produce a similar map but may omit keys, and toMap cannot handle duplicate Boolean keys or produce lists, so partitioningBy is uniquely correct here.

Answer

Collectors.groupingBy(e -> e.getSalary() > 100000)

Answer

Collectors.toMap(e -> e.getSalary() > 100000, e -> e)

Answer

Collectors.groupingBy(e -> e.getSalary() > 100000, Collectors.toList())

Question 12

A Java 17 service defines a custom checked exception named InventoryException that extends Exception. A developer writes the following method:

public void reserve() {
    throw new InventoryException("out of stock");
}

What is the result when compiling this class?

Accepted Answer

Compilation fails because InventoryException must be declared in the throws clause of reserve().. InventoryException extends Exception, making it a checked exception. Java's compiler requires every checked exception thrown by a method body to be either caught inside that method or listed in its throws clause. Because reserve() does neither, the class fails to compile, regardless of whether the exception would ever be thrown at runtime.

Answer

Compilation succeeds, but the exception is silently ignored at runtime.

Answer

Compilation succeeds because a method may throw any exception type without declaring it.

Answer

Compilation succeeds, and the exception is automatically wrapped in a RuntimeException at runtime.

Question 13

A developer is implementing a secure Java 17 application that uses serialization to persist objects to disk. To mitigate deserialization vulnerabilities, the developer wants to apply multiple layers of defense. Which two actions should be taken? (Choose two.)

Accepted Answer

Set the jdk.serialFilter system property to a strict whitelist pattern.. Implementing ObjectInputFilter provides a programmatic whitelist for deserialization, while setting the jdk.serialFilter system property enforces a global whitelist. Together, they create multiple layers of defense against deserialization attacks.

Answer

Use the java.io.Serializable interface and ensure all fields are transient.

Answer

Prefer using java.nio.file.Files to read serialized data instead of java.io.FileInputStream.

Answer

Use ObjectOutputStream to write objects and ObjectInputStream to read them, ensuring both are from the same package.

Question 14

A developer uses a TreeMap<String, Integer> and inserts keys "10", "2", "1", and "apple". The developer then iterates over the map's keySet and prints each key. In what order are the keys printed?

Accepted Answer

"1", "10", "2", "apple". TreeMap sorts keys by natural ordering, and for String that means lexicographic comparison by Unicode values. Digits sort before letters, and among digit strings the comparison is character by character, so "1" precedes "10", which precedes "2". The keySet reflects this sorted order, producing "1", "10", "2", "apple".

Answer

The insertion order: "10", "2", "1", "apple"

Answer

A ClassCastException is thrown when "apple" is inserted.

Answer

"1", "2", "10", "apple"

Question 15

A Java 17 application is packaged as a modular JAR `app.jar` containing `module-info.class` for `module com.example.app`. A developer runs `java --module-path mods --module com.example.app/com.example.app.Main`. The module path `mods` contains `app.jar`. What must be true for the launch to succeed?

Accepted Answer

The main class `com.example.app.Main` must declare `public static void main(String[] args)` and the module must be resolvable on the module path.. Launching a named module with `java --module-path ... --module module/class` requires the module to be resolvable from the module path and the main class to expose a standard `public static void main(String[])` entry point. Exports are irrelevant for the module's own main class. Additional module resolution flags are not needed because the specified module becomes the root of the module graph.

Answer

`com.example.app` must export the package containing `Main` to all modules.

Answer

The application must be started with `--add-modules ALL-MODULE-PATH` to make `com.example.app` available.

Answer

`app.jar` must be placed on the class path instead of the module path for the `--module` option to work.