1Z0-829 Practice Test 23 — 15 Questions

Question 1

Given a record `Point(int x, int y)`, which statement is true about the automatically generated constructor?

Accepted Answer

You can define a compact constructor that modifies the parameters before assignment.. In Java records, you can define a compact constructor that omits the parameter list and allows you to modify the implicit parameters before they are assigned to the components. This is the only customization allowed for the canonical constructor; the compact constructor implicitly assigns the (possibly modified) parameters to the components at the end of its body.

Answer

You can define a no-arg constructor by default.

Answer

The generated constructor is package-private.

Answer

The generated constructor throws `NullPointerException` for any null component.

Question 2

Refer to the exhibit. Given the following code:

```java
1: sealed interface Shape permits Circle { }
...
10: class Circle implements Shape { }
```

What is the result?

Accepted Answer

Compilation fails at line 10. In Java 17, when a sealed interface (like `Shape`) declares a `permits` clause listing permitted subclasses (e.g., `Circle`), each permitted subclass must explicitly declare itself as `sealed`, `non-sealed`, or `final`. If the `Circle` class is defined as `class Circle implements Shape` without any of these modifiers, compilation fails at line 10 where that class is defined. The error is that the class is not allowed to extend/implement the sealed interface unless it has the required modifier.

Answer

Compilation fails due to missing permits in Circle

Answer

Runtime exception

Answer

Compilation succeeds

Question 3

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 4

Given an exception chain where a custom exception is created with a cause, which method is used to set the cause after construction?

Accepted Answer

initCause(Throwable). `initCause(Throwable)` is the method provided by the `Throwable` class to set the cause of an exception after the exception has been constructed. This is useful when the exception must be created without a cause (e.g., via a no-arg constructor) and the cause is determined later. The cause can only be set once; a second call will throw an `IllegalStateException`.

Answer

The cause can only be set via constructor.

Answer

setCause(Throwable)

Answer

addSuppressed(Throwable)

Question 5

Given the stack trace, which statement is true about the exception handling?

Accepted Answer

The SQLException is a checked exception, and the code must handle it or declare it.. SQLException is a checked exception (a subclass of Exception but not RuntimeException), so the Java compiler enforces that it must be either caught in a try-catch block or declared in the throws clause of the enclosing method. The stack trace indicates that an SQLException occurred, and the code must handle this checked exception to compile successfully.

Answer

Both exceptions are checked, and the code must handle both.

Answer

The RuntimeException is caused by a checked exception, so it must be declared in the throws clause.

Answer

The RuntimeException is an unchecked exception, so it cannot be caught.

Question 6

Given the following code snippet inside a method:

try {
    // risky code
} catch (IOException | SQLException e) {
    // handle
}

What is the implicit type of the exception variable 'e' in the catch block?

Accepted Answer

It is of type Exception.. In Java, when a multi-catch clause catches multiple exception types (e.g., IOException | SQLException), the compiler infers the catch parameter's type as the closest common superclass that is not Object or Throwable. Since IOException and SQLException both extend Exception directly, the implicit type of 'e' is Exception. This allows the catch block to handle both exception types polymorphically.

Answer

It is of type Object.

Answer

It is of type Throwable.

Answer

It is either IOException or SQLException.

Question 7

A lambda that takes a String and returns its length is assigned to which functional interface?

Accepted Answer

Function. The lambda `(String s) -> s.length()` takes a `String` input and returns an `Integer` (the length). This matches the `Function` functional interface, which defines the abstract method `R apply(T t)`. Option E is correct because `Function` exactly represents a function that accepts a `String` and produces an `Integer`.

Answer

UnaryOperator<String>

Answer

Consumer<String>

Answer

Predicate<String>

Answer

Supplier<Integer>

Question 8

Arrange the steps to create a custom exception class in Java in the correct order.

Accepted Answer

1. Define a class that extends Exception or RuntimeException. 2. Add constructors (default, with message, with cause). 3. Optionally override methods like getMessage() or toString().. Custom exceptions extend Exception (checked) or RuntimeException (unchecked). Constructors typically call super(message) or super(cause).

Answer

1. Add constructors (default, with message, with cause). 2. Define a class that extends Exception or RuntimeException. 3. Optionally override methods.

Answer

1. Define a class (without extending Exception or RuntimeException). 2. Add constructors that call super(message). 3. Optionally override methods.

Answer

1. Override methods like getMessage() or toString(). 2. Define a class extending Exception or RuntimeException. 3. Add constructors.

Question 9

Refer to the exhibit. What is the result?

Accepted Answer

Bark
Playing. The code compiles and runs without error. The object referenced by a1 is a Dog instance. The code first calls the bark() method, which prints 'Bark' (defined in Dog). Then it calls the play() method, which is not overridden in Dog, so it invokes the inherited play() method from Animal, printing 'Playing'. Therefore, the output is 'Bark' followed by 'Playing', which matches option B.

Answer

Compilation fails

Answer

Runtime exception

Answer

Bark

Question 10

Arrange the steps to create and use a generic method in Java.

Accepted Answer

Declare the method with a type parameter in angle brackets before the return type, then use the type parameter for parameters and return type, then implement the method body using the type parameter, then invoke the method either with explicit type argument or type inference.. Generic methods allow type-safe operations on different types. The type parameter is placed before the return type.

Answer

Write the method body first using a specific type, then replace the specific type with a type parameter, then add the type parameter declaration in the method signature, then call the method with the specific type.

Answer

Declare the method with a type parameter after the return type, then use the type parameter in the method body, then call the method with type inference.

Answer

Use a wildcard (?) in the method signature instead of a type parameter, then implement the method body, then call the method with different types.

Question 11

Given: int x=1; switch(x) { case 1: System.out.print("A"); case 2: System.out.print("B"); break; default: System.out.print("C"); } What is printed?

Accepted Answer

AB. The switch statement does not have a break after case 1, so execution falls through to case 2 after printing 'A'. Case 2 prints 'B' and then hits the break, exiting the switch. The default case is skipped because a matching case was found. Thus, 'AB' is printed.

Answer

C

Answer

ABC

Answer

A

Question 12

Which is the best practice for securing a Java application that reads sensitive configuration files?

Accepted Answer

Restrict access to the file using operating system permissions.. Restricting access to sensitive files using operating system permissions is a fundamental security practice that applies regardless of the Java version. In Java 17, the Security Manager is deprecated for removal (JEP 411), so relying on a Java security policy file (Option B) is no longer considered a best practice. OS-level permissions provide a robust, platform-native access control that does not depend on deprecated features. Options C and D are insufficient: making a file read-only does not prevent unauthorized access, and storing credentials in source code is highly insecure.

Answer

Define a Java security policy file with FilePermission for the configuration file.

Answer

Make the file read-only at the OS level.

Answer

Store credentials in the source code and use encryption.

Question 13

A developer needs to read a very large text file (over 1 GB) efficiently with minimal memory overhead. Which approach is most suitable?

Accepted Answer

Use FileChannel with a ByteBuffer to read in chunks.. FileChannel with a ByteBuffer allows reading a large file in configurable chunks, leveraging the operating system's native I/O for high throughput and minimal memory overhead. This approach avoids loading the entire file into memory and reduces context switching compared to stream-based readers.

Answer

Use Scanner to read tokens.

Answer

Use BufferedReader to read lines.

Answer

Use FileInputStream and read byte by byte.

Question 14

What will be the result of the following code?
Object[] arr = new Integer[5];
arr[0] = "String";

Accepted Answer

ArrayStoreException at runtime. The code creates an array of type `Integer[]` referenced by an `Object[]` variable. At runtime, the array's actual component type is `Integer`, so attempting to store a `String` violates the array's type constraint and throws an `ArrayStoreException`.

Answer

Successfully stores "String"

Answer

Compilation error

Answer

ClassCastException

Question 15

Your team manages a high-throughput financial transaction system running on Java 17. Recently, the application experiences intermittent slowdowns and increased CPU usage during peak hours. Monitoring reveals that exception handling code is invoked frequently due to validation errors in incoming data. The system uses a central exception handler that logs every exception and throws a custom ApplicationException. In many places, the code catches generic Exception and rethrows the custom exception after logging. Additionally, method signatures include throws Exception. The team wants to improve performance and maintainability without changing the external behavior significantly. Which course of action best addresses the performance and maintainability issues?

Accepted Answer

Define specific custom checked exception classes for each validation error and catch them precisely, avoiding generic Exception catches.. Catching generic `Exception` forces the JVM to build a full stack trace for every validation error, which is expensive in a high-throughput system. By defining specific custom checked exception classes and catching them precisely, the team reduces unnecessary stack trace generation and makes the code more maintainable by clearly documenting which errors are expected. This approach aligns with Java best practices for exception handling, improving both performance and code clarity without altering external behavior.

Answer

Change all catch blocks to catch Throwable and ignore irrecoverable errors to reduce logging.

Answer

Add a try-catch block around every method call that might throw an exception to handle locally.

Answer

Wrap all exceptions in a single custom unchecked exception to simplify exception handling.