1Z0-829 Practice Test 4 — 25 Questions

Question 1

Refer to the exhibit. What is the result of compiling and running the Main class?

Accepted Answer

Compilation error at line 8 because makeSound() has protected access.. Option C is correct because the `makeSound()` method in the `Animal` class has `protected` access, and the `Dog` class is in a different package. In Java, a `protected` member is accessible only within the same package or through inheritance in a subclass, but only if the access is via a reference of the subclass type. In the `Main` class, the reference is of type `Animal` (line 8), not `Dog`, so the compiler cannot access the `protected` method from a different package, resulting in a compilation error.

Answer

Runtime exception because makeSound() is not accessible.

Answer

Compilation error because Dog does not override makeSound().

Answer

Prints "Some sound".

Question 2

A developer needs to parse a date string '2024-07-04' into a LocalDate object. Which approach is correct?

Accepted Answer

LocalDate.parse("2024-07-04"). Option C is correct because `LocalDate.parse("2024-07-04")` uses the default ISO-8601 format (yyyy-MM-dd), which matches the given string exactly. The `LocalDate` class provides a static `parse` method that returns a `LocalDate` object without needing an explicit formatter when the input follows the standard pattern.

Answer

LocalDate.of(2024, 07, 04)

Answer

DateFormat.getDateInstance().parse("2024-07-04")

Answer

new LocalDate(2024, 7, 4)

Question 3

A program reads user input as a string and needs to parse it into an integer, handling invalid input gracefully. Which code snippet correctly uses try-catch to parse and prints the result or 'Invalid number'?

Accepted Answer

try { int num = Integer.parseInt(input); System.out.println(num); } catch (NumberFormatException e) { System.out.println("Invalid number"); }. Option D is correct because it uses `Integer.parseInt(input)` which throws a `NumberFormatException` for invalid input, and the catch block specifically catches that exception to print 'Invalid number'. This is the standard, idiomatic Java approach for parsing integers with error handling, as it directly addresses the requirement without unnecessary overhead or false positives.

Answer

try { int num = Integer.valueOf(input).intValue(); System.out.println(num); } catch (Exception e) { System.out.println("Invalid number"); }

Answer

int num = Integer.parseInt(input); System.out.println(num);

Answer

if (input.matches("\d+")) { int num = Integer.parseInt(input); System.out.println(num); } else { System.out.println("Invalid number"); }

Question 4

Given: ZonedDateTime zdt = ZonedDateTime.of(2024, 3, 10, 2, 30, 0, 0, ZoneId.of("America/New_York")); In the US, on March 10, 2024, clocks spring forward at 2:00 AM to 3:00 AM. What is the output of System.out.println(zdt);?

Accepted Answer

2024-03-10T03:30-04:00[America/New_York]. When a ZonedDateTime is created for a time that falls within a DST gap (2:00 AM to 3:00 AM on March 10, 2024, in America/New_York), the Java API automatically adjusts the time forward to the next valid offset. The local time 2:30 AM does not exist because clocks spring forward to 3:00 AM, so the ZonedDateTime is normalized to 3:30 AM with the DST offset -04:00. This behavior is defined by the ZonedDateTime.of method, which resolves invalid local times by shifting to the offset after the gap.

Answer

Throws DateTimeException

Answer

2024-03-10T02:30-05:00[America/New_York]

Answer

2024-03-10T02:30-04:00[America/New_York]

Question 5

Which two of the following are valid ways to create a LocalDate representing the current date in the system's default timezone? (Choose two.)

Accepted Answer

LocalDate.now(). Option C is correct because `LocalDate.now()` is the standard, straightforward method to obtain the current date in the system's default timezone, as defined in the Java Time API (JSR-310). It internally uses the system clock and the default timezone to return a `LocalDate` instance without requiring any additional parameters.

Answer

LocalDate.from(Instant.now())

Answer

new LocalDate()

Answer

LocalDate.ofEpochDay(System.currentTimeMillis() / (24*60*60*1000))

Question 6

Which TWO statements about creating custom exceptions are correct? (Choose two.)

Accepted Answer

It is good practice to provide a constructor that takes a String message and a Throwable cause.. Option D is correct because it is a well-established best practice in Java to provide a constructor that accepts both a String message and a Throwable cause, enabling precise error reporting and chaining of exceptions. This allows developers to pass a human-readable description along with the underlying cause, which is essential for debugging and logging.

Answer

Custom exceptions should extend Error to indicate fatal errors.

Answer

Custom exception classes should be declared final to prevent subclassing.

Answer

Custom exceptions must implement the Exception interface.

Question 7

Which TWO statements about try-with-resources are correct? (Choose two.)

Accepted Answer

Resources are closed in the reverse order of their declaration.. Option A is correct because the Java Language Specification (JLS §14.20.3) mandates that resources declared in a try-with-resources statement are closed in the reverse order of their declaration. This ensures that if a resource depends on another declared earlier, the dependent resource is closed first, preventing resource leaks or inconsistent states.

Answer

Resources are closed in the same order as their declaration.

Answer

Resources declared in try-with-resources must implement the Closeable interface.

Answer

Resources declared earlier in the try clause are closed first.

Question 8

A Java application uses a custom resource class implementing AutoCloseable. The close() method throws a checked exception. In a try-with-resources block, if both the try block and the close() method throw exceptions, which exception is propagated to the caller? Assume the resource is declared in try-with-resources.

Accepted Answer

The exception from the try block is the primary exception, and the close() exception is added as a suppressed exception.. In a try-with-resources block, when both the try block and the close() method throw exceptions, the exception from the try block is the primary exception propagated to the caller. The exception thrown by close() is added to the primary exception's suppressed exception list, as defined by the Java Language Specification (JLS §14.20.3.2). This ensures that the most relevant exception (the one from the application logic) is not masked by a resource-closing failure.

Answer

The exception from close() is always the primary exception.

Answer

Both exceptions are thrown simultaneously as a multi-catch exception.

Answer

The exception from the try block is always suppressed.

Question 9

Which TWO are valid multi-catch statements in Java 17? (Choose two.)

Accepted Answer

catch (SQLException | IOException e). Option A is correct because Java 17 allows a multi-catch clause to handle multiple exception types in a single catch block, provided the exception types are unrelated in the class hierarchy. SQLException and IOException are both checked exceptions that do not inherit from each other, so they can be caught together in a multi-catch statement.

Answer

catch (Exception | RuntimeException e)

Answer

catch (SQLException | Exception e)

Answer

catch (IOException | FileNotFoundException e)

Question 10

A developer needs to read all lines from a text file named "data.txt" that uses UTF-8 encoding. Which code correctly reads the file using the NIO.2 API?

Accepted Answer

Files.readAllLines(Path.of("data.txt"), StandardCharsets.UTF_8). Option D is correct because `Files.readAllLines()` reads all lines from a file into a `List<String>`, and it accepts a `Path` and a `Charset` (here `StandardCharsets.UTF_8`) to handle encoding. This method is part of the NIO.2 API and directly fulfills the requirement to read all lines from a UTF-8 encoded file.

Answer

Files.lines(Path.of("data.txt"), StandardCharsets.UTF_8).collect(Collectors.toList())

Answer

Files.readString(Path.of("data.txt"), StandardCharsets.UTF_8)

Answer

Files.readAllBytes(Path.of("data.txt")).toString()

Question 11

Which three actions help secure a Java application that uses serialization? (Select three.)

Accepted Answer

Overriding resolveClass() in ObjectInputStream to validate class names.. Option A is correct because overriding `resolveClass()` in `ObjectInputStream` allows you to validate the class name before it is deserialized. This prevents deserialization attacks where an attacker sends a malicious class that could execute arbitrary code. By checking the class name against a whitelist, you can block untrusted classes from being loaded.

Answer

Using SecureRandom to generate serialVersionUID.

Answer

Declaring serialVersionUID explicitly as a long constant.

Question 12

Refer to the exhibit. What is the most likely cause of this exception?

Accepted Answer

The class definition has changed and the serialVersionUID is not explicitly defined.. Option D is correct because when a class definition changes (e.g., adding/removing fields) and the class does not explicitly declare a `serialVersionUID`, the JVM computes one automatically based on the class structure. After deserialization, if the computed UID differs from the UID stored in the serialized stream, an `InvalidClassException` is thrown. This is the most common cause of deserialization failures in practice.

Answer

The serialized object is corrupted.

Answer

The JVM versions are incompatible.

Answer

The file contains data that is not a serialized object.

Question 13

Which TWO statements are true regarding reading files with the NIO.2 API?

Accepted Answer

Files.newBufferedReader() provides buffered character input.. Option B is correct because `Files.newBufferedReader()` returns a `BufferedReader` that wraps a `FileReader` (or underlying `FileChannel`), providing efficient buffered character input. This method is designed for reading text files line-by-line with reduced I/O operations, making it suitable for large or stream-oriented text processing.

Answer

Files.readAllLines() is memory efficient for large files.

Answer

Files.newInputStream() wraps a FileChannel for high performance.

Answer

Files.readAllBytes() is the best choice for large binary files.

Question 14

Which THREE are recommended practices to prevent privilege escalation when using doPrivileged in a security-sensitive Java application?

Accepted Answer

Restrict the codebase URLs in policy files to only trusted code locations.. Option A is correct because restricting codebase URLs in policy files to only trusted code locations limits the sources from which privileged code can be loaded. This prevents an attacker from injecting malicious code from an untrusted URL that could otherwise be granted elevated permissions via doPrivileged. By narrowing the codebase, you reduce the attack surface for privilege escalation attacks.

Answer

Use SubjectDomainCombiner to merge multiple protection domains.

Answer

Always use a SecurityManager to enforce the policy.

Question 15

A financial application deserializes objects received over the network using ObjectInputStream. To prevent deserialization attacks, which secure coding practice should be implemented?

Accepted Answer

Use an ObjectInputFilter to whitelist allowed classes.. Option A is correct because ObjectInputFilter (introduced in Java 9) allows you to define a filter that whitelists only trusted classes during deserialization. By rejecting untrusted classes before they are deserialized, you prevent deserialization attacks such as remote code execution via gadget chains. This is the recommended secure coding practice per Oracle's secure coding guidelines for the Java I/O API.

Answer

Override readObject() in each serializable class to validate data.

Answer

Declare all fields as transient to prevent unwanted data exposure.

Answer

Encrypt the serialized data with AES before transmission.

Question 16

Refer to the exhibit. Which of the following best describes the effective permissions granted to the application?

Accepted Answer

The application can read and write files under /data/ and connect to any socket.. The exhibit shows a Java security policy granting the application `java.net.SocketPermission` with `connect,resolve` actions and `java.io.FilePermission` with `read,write` actions on `/data/-`. This means the application can connect to any socket (since the target name is `*`) and read/write any file under `/data/`. Option B correctly captures both permissions.

Answer

The application can connect to any network socket.

Answer

The application can only read files under /data/ and connect to sockets.

Answer

The application can read and write any file under /data/.

Question 17

Which TWO approaches are recommended to secure Java I/O operations? (Choose two.)

Accepted Answer

Use try-with-resources to ensure proper resource closure.. Option A is correct because try-with-resources automatically closes each resource declared in its header when the block exits, whether normally or via exception. This eliminates the risk of resource leaks from forgotten or improperly handled close() calls, which is a fundamental security and reliability requirement for I/O operations.

Answer

Use BufferedInputStream to wrap FileInputStream for better performance.

Answer

Use Serializable interface for all data objects.

Answer

Use FileLock to prevent concurrent write access.

Question 18

A company needs to read a large text file (over 2 GB) line by line in a Java application while minimizing memory footprint. Which approach is most efficient?

Accepted Answer

Use Files.lines(path) with try-with-resources. Option D is correct because `Files.lines(path)` returns a `Stream<String>` that lazily reads lines from the file, processing them one at a time without loading the entire file into memory. Combined with try-with-resources, the underlying `BufferedReader` is automatically closed, ensuring efficient resource management even for files over 2 GB.

Answer

Use Files.readAllLines(path)

Answer

Use FileOutputStream with read() loop

Answer

Use Scanner with File and loop hasNextLine()

Question 19

A class implements Serializable. Which modification ensures that a specific field (password) is not included in the serialized stream?

Accepted Answer

Declare the field as transient. The `transient` modifier is the correct mechanism in Java to exclude a specific field from the default serialization process. When a class implements `Serializable`, all non-transient instance fields are serialized by default. Marking the `password` field as `transient` ensures it is skipped during serialization and restored as `null` (or default value) upon deserialization.

Answer

Declare the field as volatile

Answer

Declare the field as static

Answer

Declare the field as final

Question 20

Which TWO secure coding practices should be followed when developing a Java application that handles user input? (Choose two.)

Accepted Answer

Use PreparedStatement for database queries with user input.. Option A is correct because using PreparedStatement with parameterized queries prevents SQL injection by separating SQL logic from user input. The database driver automatically escapes special characters in the input, ensuring that user-supplied data is treated as literal values, not executable SQL code.

Answer

Serialize sensitive data without encryption for performance.

Answer

Grant java.security.AllPermission to the application's codebase.

Answer

Use java.util.Random for generating session tokens.

1Z0-829 Practice Test 4 — 25 Questions

Exhibit

1Z0-829 Practice Test 4 — 25 Questions

Exhibit