Free Practice Questions for Oracle 1z0-830 Exam

In this code, the Calculable interface defines a single abstract method calculate that takes an int parameter and returns a long. The main method contains three lambda expressions assigned to variables c1, c2, and c3 of type Calculable.

Line 1:Calculable c1 = i -> i + 1;

This lambda expression takes an integer i and returns the result of i + 1. Since the expression i + 1 results in an int, and Java allows implicit widening conversion from int to long, this line compiles successfully.

Line 2:Calculable c2 = i -> Long.valueOf(i);

Here, the lambda expression takes an integer i and returns the result of Long.valueOf(i). The Long.valueOf(int i) method returns a Long object. However, Java allows unboxing of the Long object to a long primitive type when necessary. Therefore, this line compiles successfully.

Line 3:Calculable c3 = i -> { throw new ArithmeticException(); };

This lambda expression takes an integer i and throws an ArithmeticException. Since the method calculate has a return type of long, and throwing an exception is a valid way to exit the method without returning a value, this line compiles successfully.

Since all three lines adhere to the method signature defined in the Calculable interface and there are no type mismatches or syntax errors, the program compiles successfully.

The var keyword and identifier rules:

The var keyword is used for local variable type inference introduced inJava 10.

However,Java does not allow _ (underscore) as an identifiersinceJava 9.

If we try to use _ as a variable name, the compiler will throw an error:

pgsql

error: as of release 9, '_' is a keyword, and may not be used as an identifier

The $ symbol as an identifier:

The $ characteris a valid identifierin Java.

However, since _ is not allowed, the codefails to compile before even reaching $.

Thus,the correct answer is "Compilation fails."

References:

Java SE 21 - var Local Variable Type Inference

Java SE 9 - Restrictions on _ Identifier

Understanding LongStream.range(1, 1945).boxed().toList();

LongStream.range(1, 1945) generates a stream of numbersfrom 1 to 1944.

.boxed() converts the primitive long values to Long objects.

.toList() (introduced in Java 16)creates an immutable list.

Understanding Executors.newVirtualThreadPerTaskExecutor()

Java 21 introducedvirtual threadsto improve concurrency.

Executors.newVirtualThreadPerTaskExecutor()creates a new virtual thread per submitted task, allowing highly concurrent execution.

Execution Behavior

cannesFestivalfeatureFilms.stream().limit(25) → Limits the stream to thefirst 25 numbers(1 to 25).

.forEach(film -> executor.submit(() -> System.out.println(film)))

Each film is printed inside a virtual thread.

Virtual threads execute asynchronously, meaning numbers arenot guaranteed to print sequentially.

Output will contain numbers from 1 to 25, but their order is random due to concurrent execution.

Possible Output (Random Order)

python-repl

3

1

5

2

4

7

25

The ordermay differ in each rundue to concurrent execution.

Thus, the correct answer is:"Numbers from 1 to 25 randomly."

References:

Java SE 21 - Virtual Threads

Java SE 21 - Executors.newVirtualThreadPerTaskExecutor()

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.

In this code, two LocalDate instances are created representing May 4, 2023, and May 4, 2024. The Period.between() method is used to calculate the period between these two dates, and the Duration.between() method is used to calculate the duration between them.

Period Calculation:

The Period.between() method calculates the amount of time between two LocalDate objects in terms of years, months, and days. In this case, the period between May 4, 2023, and May 4, 2024, is exactly one year. Therefore, p is P1Y, which stands for a period of one year. Printing p will output P1Y.

Duration Calculation:

The Duration.between() method is intended to calculate the duration between two temporal objects that have time components, such as LocalDateTime or Instant. However, LocalDate represents a date without a time component. Attempting to use Duration.between() with LocalDate instances will result in an UnsupportedTemporalTypeException because Duration requires time-based units, which LocalDate does not support.

Exception Details:

The UnsupportedTemporalTypeException is thrown when an unsupported unit is used. In this case, Duration.between() internally attempts to access time-based fields (like seconds), which are not supported by LocalDate. This behavior is documented in the Java Bug System underJDK-8170275.

Correct Usage:

To calculate the duration between two dates, including time components, you should use LocalDateTime or Instant. For example:

java

LocalDateTime start = LocalDateTime.of(2023, Month.MAY, 4, 0, 0);

LocalDateTime end = LocalDateTime.of(2024, Month.MAY, 4, 0, 0);

Duration d = Duration.between(start, end);

System.out.println(d); // Outputs: PT8784H

This will correctly calculate the duration as PT8784H, representing 8,784 hours (which is 366 days, accounting for a leap year).

Conclusion:

The output of the given code will be:

pgsql

P1Y

Exception in thread "main" java.time.temporal.UnsupportedTemporalTypeException: Unsupported unit: Seconds

Therefore, the correct answer is D:

nginx

P1Y

UnsupportedTemporalTypeException

In Java, the Stream API provides several methods to create streams. However, not all approaches are valid.

The Java Platform Module System (JPMS), introduced in Java 9, modularizes the Java platform and applications. Understanding the behavior of named and unnamed modules is crucial.

B. The unnamed module exports all of its packages.

Correct. The unnamed module, which includes all code on the classpath, exports all of its packages. This means that any code can access the public types in these packages. However, the unnamed module cannot be explicitly required by named modules.

C. If a package is defined in both a named module and the unnamed module, then the package in the unnamed module is ignored.

Correct. In cases where a package is present in both a named module and the unnamed module, the version in the named module takes precedence. The package in the unnamed module is ignored to maintain module integrity and avoid conflicts.

F. If a request is made to load a type whose package is not defined in any known module, then the module system will attempt to load it from the classpath.

Correct. When the module system cannot find a requested type in any known module, it defaults to searching the classpath (i.e., the unnamed module) to locate the type.

Incorrect Options:

A. Code in an explicitly named module can access types in the unnamed module.

Incorrect. Named modules cannot access types in the unnamed module. The unnamed module can read from named modules, but the reverse is not allowed to ensure strong encapsulation.

D. We must add a module descriptor to make an application developed using a Java version prior to SE9 run on Java 11.

Incorrect. Adding a module descriptor (module-info.java) is not mandatory for applications developed before Java 9 to run on Java 11. Such applications can run in the unnamed module without modification.

E. The unnamed module can only access packages defined in the unnamed module.

Incorrect. The unnamed module can access all packages exported by all named modules, in addition to its own packages.

In Java, the final keyword can be applied to classes, methods, and variables to impose certain restrictions.

Final Classes:

Definition:A class declared with the final keyword is known as a final class.

Purpose:Declaring a class as final prevents it from being subclassed. This is useful when you want to ensure that the class's implementation remains unchanged and cannot be extended or modified through inheritance.

Option Evaluations:

A. The final keyword in its declaration must go right before the class keyword.

This is correct. The syntax for declaring a final class is:

java

public final class ClassName {

// class body

}

However, this statement is about syntax rather than the core characteristic of a final class.

B. It must contain at least a final method.

Incorrect. A final class can have zero or more methods, and none of them are required to be declared as final. The final keyword at the class level prevents inheritance, regardless of the methods' finality.

C. It cannot be extended by any other class.

Correct. The primary characteristic of a final class is that it cannot be subclassed. Attempting to do so will result in a compilation error.

D. It cannot implement any interface.

Incorrect. A final class can implement interfaces. Declaring a class as final restricts inheritance but does not prevent the class from implementing interfaces.

E. It cannot extend another class.

Incorrect. A final class can extend another class. The final keyword prevents the class from being subclassed but does not prevent it from being a subclass itself.

Therefore, the correct statement about a final class is option C: "It cannot be extended by any other class."

In this code, now is assigned the current date using LocalDate.now(). The goal is to format this date to the ISO week date format, which represents dates in the YYYY-'W'WW-E pattern, where:

YYYY: Week-based year

'W': Literal 'W' character

WW: Week number

E: Day of the week

Given that the present day is December 31, 2024, this date falls in the first week of the week-based year 2025. Therefore, the ISO week date representation would be 2025-W01-2, where '2' denotes Tuesday.

Among the provided formatters:

format1: This line attempts to create a DateTimeFormatter using a constructor, which is incorrect because DateTimeFormatter does not have a public constructor that accepts a pattern directly. This would result in a compilation error.

format2: This is correctly assigned the predefined DateTimeFormatter.ISO_WEEK_DATE, which formats dates in the ISO week date format.

format3: This line attempts to create a DateFormat instance using a field, which is incorrect because DateFormat does not have such a constructor. This would result in a compilation error.

format4: This line attempts to get a DateFormat instance using an integer field, which is incorrect because DateFormat.getDateInstance() does not accept such parameters. This would result in a compilation error.

Therefore, the only correct and applicable formatter is format2. Using format2 in the now.format() method will produce the desired output: 2025-W01-2.