Oracle Java SE 21 Developer Professional 1z0-830 Exam Dumps: Updated Questions & Answers (September 2025)

Correct module descriptor file name

A module declaration must be placed inside a file namedmodule-info.java.

The incorrect filename module-info.perfumery.shop.javais invalid(Option A).

The incorrect filename module.javais invalid(Option C).

Correct module declaration

The module declaration must match the name of the module (perfumery.shop).

The requires perfumery.provider; directive specifies that perfumery.shop depends on perfumery.provider.

The exports perfumery.shop.eaudeparfum; statement allows the perfumery.shop.eaudeparfum package to beaccessible by other modules.

The incorrect syntax exports perfumery.shop.eaudeparfum.*; in Option A isinvalid, as wildcards (*) arenot allowedin module exports.

Thus, the correct answer is:File name: module-info.java

References:

Java SE 21 - Modules

Java SE 21 - module-info.java File

In this code, a Stream of String elements is created containing "United" and "States". A BinaryOperator named operator is defined to concatenate the first string (s1) with the uppercase version of the second string (s2). The reduce method is then used with "-" as the identity value and operator as the accumulator.

The reduce method processes the elements of the stream as follows:

Initial Identity Value: "-"

First Iteration:

Accumulator Operation: "-".concat("United".toUpperCase())

Result: "-UNITED"

Second Iteration:

Accumulator Operation: "-UNITED".concat("States".toUpperCase())

Result: "-UNITEDSTATES"

Therefore, the final result stored in result is "-UNITEDSTATES", and the output of theSystem.out.println(result); statement is -UNITEDSTATES.

1. Valid Use Cases of var

var is alocal variable type inferencefeature.

The compilerinfers the type from the assigned value.

Example of valid use:

java

var a = 10; // Type inferred as int

var str = "Hello"; // Type inferred as String

2. Analyzing the Given Statements

Statement

Valid/Invalid

Reason

var a = 1;

Valid

Type inferred as int.

var b = 2, c = 3.0;

❌Invalid

var doesnot allow multiple declarationsin one statement.

var d[] = new int[4];

❌Invalid

Array brackets []are not allowedwith var.

var e;

❌Invalid

varrequires an initializer(cannot be declared without assignment).

var f = { 6 };

❌Invalid

{ 6 } is anarray initializer, which must have an explicit type.

var h = (g = 7);

Valid

g is assigned 7, and h gets its value.

Thus, the correct answers are:B, C, D, E

References:

Java SE 21 - Local Variable Type Inference (var)

Java SE 21 - var Restrictions

In this code, the Test class has a static integer field count and a constructor that is declared with the synchronized modifier. In Java, the synchronized modifier can be applied to methods to control access to critical sections, but it cannot be applied directly to constructors. Attempting to declare a constructor as synchronized will result in a compilation error.

Compilation Error Details:

The Java Language Specification does not permit the use of the synchronized modifier on constructors. Therefore, the compiler will produce an error indicating that the synchronized modifier is not allowed in this context.

Correct Usage:

If you need to synchronize the initialization of instances, you can use a synchronized block within the constructor:

java

public class Test {

static int count;

Test() {

synchronized (Test.class) {

count++;

}

}

public static void main(String[] args) throws InterruptedException {

Runnable task = Test::new;

Thread t1 = new Thread(task);

Thread t2 = new Thread(task);

t1.start();

t2.start();

t1.join();

t2.join();

System.out.println(count);

}

}

In this corrected version, the synchronized block within the constructor ensures that the increment operation on count is thread-safe.

Conclusion:

The original program will fail to compile due to the illegal use of the synchronized modifier on the constructor. Therefore, the correct answer is E: Compilation fails.

In this code, we have two interfaces and a class with a main method:

WithDefaultMethod Interface:

Declares a default method print() that outputs "default".

WithStaticMethod Interface:

Extends WithDefaultMethod.

Declares a static method print() that outputs "static".

DefaultAndStaticMethods Class:

Contains the main method, which calls WithStaticMethod.print().

Key Points:

Static Methods in Interfaces:

Static methods in interfaces are not inherited by implementing or extending classes or interfaces. They belong solely to the interface in which they are declared.

Default Methods in Interfaces:

Default methods can be inherited by implementing classes, but they cannot be overridden by static methods in subinterfaces.

Execution Flow:

The main method calls WithStaticMethod.print().

This invokes the static method print() defined in the WithStaticMethod interface, which outputs "static".

Therefore, the program compiles successfully and prints static.

Understanding post++ (Post-increment)

post++uses the value first, then increments it.

postResult = post++ + 10;

post starts as 5.

post++ returns 5, then post is incremented to 6.

postResult = 5 + 10 = 15.

Final value of post after this line is 6.

Understanding ++pre (Pre-increment)

++preincrements the value first, then uses it.

preResult = ++pre + 10;

pre starts as 5.

++pre increments pre to 6, then returns 6.

preResult = 6 + 10 = 16.

Final value of pre after this line is 6.

Thus, the final output is:

yaml

postResult: 15, preResult: 16, Final value of post: 6, Final value of pre: 6

References:

Java SE 21 - Operators and Expressions

Java SE 21 - Arithmetic Operators

In this code, a Duration object day is created representing a duration of 2 days using the Duration.ofDays(2) method. The dividedBy(long divisor) method is then called on this Duration object with the argument 8.

The dividedBy(long divisor) method returns a copy of the original Duration divided by the specified value. In this case, dividing 2 days by 8 results in a duration of 0.25 days. In the ISO-8601 duration format used by Java's Duration class, this is represented as PT6H, which stands for a period of 6 hours.

Therefore, the output of the System.out.print statement is PT6H.

Pattern Matching in switch

The switch expression introduced inJava 21supportspattern matchingfor different types.

However,a switch expression must be exhaustive, meaningit must cover all possible cases or provide a default case.

Why does compilation fail?

input is an Object, and the switch expression attempts to pattern-match it to String, Double, and Integer.

If input had been of another type (e.g., Float or Long), there would beno matching case, leading to anon-exhaustive switch.

Javarequires a default caseto ensure all possible inputs are covered.

Corrected Code (Adding a default Case)

java

Object input = 42;

String result = switch (input) {

case String s -> "It's a string with value: " + s;

case Double d -> "It's a double with value: " + d;

case Integer i -> "It's an integer with value: " + i;

default -> "Unknown type";

};

System.out.println(result);

With this change, the codecompiles and runs successfully.

Output:

vbnet

It's an integer with value: 42

Thus, the correct answer is:Compilation failsdue to a missing default case.

References:

Java SE 21 - Pattern Matching for switch

Java SE 21 - switch Expressions

Understanding java.util.function.Predicate<T>

The Predicate interface represents a function thattakes an input and returns a boolean(true or false).

It is often used for filtering operations in functional programming and streams.

Analyzing the Methods:

and(Predicate<? super T> other)→Default method

Combines two predicates usinglogical AND(&&).

java

Predicate startsWithA = s -> s.startsWith("A");

Predicate hasLength3 = s -> s.length() == 3;

Predicate combined = startsWithA.and(hasLength3);

❌isEqual(Object targetRef)→Static method

Not a default method, because it doesnot operate on an instance.

java

Predicate isEqualToHello = Predicate.isEqual("Hello");

negate()→Default method

Negates a predicate (! operator).

java

Predicate notEmpty = s -> !s.isEmpty();

Predicate isEmpty = notEmpty.negate();

❌not(Predicate<? super T> target)→Static method (introduced in Java 11)

Not a default method, since it is static.

or(Predicate<? super T> other)→Default method

Combines two predicates usinglogical OR(||).

❌test(T t)→Abstract method

Not a default method, because every predicatemust implement this method.

Thus, the correct answers are:and(Predicate<? super T> other), negate(), or(Predicate<? super T> other)

References:

Java SE 21 - Predicate Interface

Java SE 21 - Functional Interfaces

In Java, a lambda expression can have two forms for its body:

Single Expression:A concise form where the body consists of a single expression. The result of this expression is implicitly returned.

Example:

java

(a, b) -> a + b

In this example, (a, b) are the parameters, and a + b is the single expression that adds them together.

Statement Block:A more detailed form where the body consists of a block of statements enclosed in braces {}. Within this block, you can have multiple statements, and if a return value is expected, you must explicitly use the return statement.

Example:

java

(a, b) -> {

int sum = a + b;

System.out.println("Sum is: " + sum);

return sum;

}

In this example, the lambda body is a statement block that performs multiple actions: it calculates the sum, prints it, and then returns the sum.

Given the options:

A. Two statements:While a lambda body can contain multiple statements, they must be enclosed within a statement block {}. Simply having two statements without braces is not valid syntax for a lambda expression.

B. An expression and a statement:Similar to option A, if a lambda body contains more than one element (be it expressions or statements), they need to be enclosed in a statement block.

C. A statement block:This is correct. A lambda expression can have a body that is a statement block, allowing multiple statements enclosed in braces.

D. None of the above:This is incorrect since option C is valid.

E. Two expressions:As with options A and B, multiple expressions must be enclosed in a statement block to form a valid lambda body.

Therefore, the correct answer is C: A statement block.