Pass the Oracle Java SE 1z0-830 Questions and answers with ExamsMirror

1. private Access Modifier

The private access modifiercan only be used for inner classes(nested classes).

Top-level classes cannot be private.

Example ofinvaliduse:

java

private class MyClass {} // Compilation error

Example ofvaliduse (for inner class):

java

class Outer {

private class Inner {}

}

2. protected Access Modifier

Top-level classes cannot be protected.

protectedonly applies to members (fields, methods, and constructors).

Example ofinvaliduse:

java

protected class MyClass {} // Compilation error

Example ofvaliduse (for methods/fields):

java

class Parent {

protected void display() {}

}

3. public Access Modifier

Atop-level class can be public, butonly one public class per file is allowed.

Example ofvaliduse:

java

public class MyClass {}

Example ofinvaliduse:

java

public class A {}

public class B {} // Compilation error: Only one public class per file

4. final Modifier

finalcan be used with classes, but not all kinds of classes.

Interfaces cannot be final, because they are meant to be implemented.

Example ofinvaliduse:

java

final interface MyInterface {} // Compilation error

Thus,none of the statements are fully correct, making the correct answer:None

References:

Java SE 21 - Access Modifiers

Java SE 21 - Class Modifiers

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

Option A (Map<String, ArrayList<String>> authorsMap1 = new HashMap<>();)

❌Compilation Fails

frenchAuthors is declared as List,notArrayList.

The correct way to declare a Map that allows storing List is to use List as the generic type,notArrayList.

Fix:

java

Map> authorsMap1 = new HashMap<>();

authorsMap1.put("FR", frenchAuthors);

Reason:The type ArrayList is more specific than List, and this would cause atype mismatcherror.

Option B (Map<String, ? extends List<String>> authorsMap2 = new HashMap<String, ArrayList<String>>();)

❌Compilation Fails

? extends Listmakes the map read-onlyfor adding new elements.

The line authorsMap2.put("FR", frenchAuthors); causes acompilation errorbecause wildcard (? extends List) prevents modifying the map.

Fix:Remove the wildcard:

java

Map> authorsMap2 = new HashMap<>();

authorsMap2.put("FR", frenchAuthors);

Option C (var authorsMap3 = new HashMap<>();)

Compiles Successfully

The var keyword allows the compiler to infer the type.

However,the inferred type is HashMap<Object, Object>, which may cause issues when retrieving values.

Option D (Map<String, List<String>> authorsMap4 = new HashMap<String, ArrayList<String>>();)

Compiles Successfully

Valid declaration:HashMap can be assigned to Map.

Using new HashMap>() with Map> isalloweddue to polymorphism.

Correct syntax:

java

Map> authorsMap4 = new HashMap>();

authorsMap4.put("FR", frenchAuthors);

Option E (Map<String, List<String>> authorsMap5 = new HashMap<String, List<String>>();)

Compiles Successfully

HashMap> isa valid instantiation.

Correct usage:

java

Map> authorsMap5 = new HashMap<>();

authorsMap5.put("FR", frenchAuthors);

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

References:

Java SE 21 - Generics and Type Inference

Java SE 21 - var Keyword

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()

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 ArrayDeque Behavior

ArrayDequeis a double-ended queue (deque), working as aFIFO (queue) and LIFO (stack).

Thedefault behaviorisqueue-like (FIFO)unless explicitly used as a stack.

Step-by-Step Execution

java

var deque = new ArrayDeque<>();

deque.add(1);

deque.add(2);

deque.add(3);

deque.add(4);

deque.add(5);

Deque after additions→ [1, 2, 3, 4, 5]

Operations Breakdown

deque.peek()→ Returns thehead(first element)without removal.

makefile

Output: 1

deque.poll()→ Removes and returns thehead.

go

Output: 1, Deque after poll → `[2, 3, 4, 5]`

deque.pop()→Same as removeFirst(); removes and returns thehead.

perl

Output: 2, Deque after pop → `[3, 4, 5]`

deque.element()→ Returns thehead(same as peek(), but throws an exception if empty).

makefile

Output: 3

Final Output

1 1 2 3

Thus, the correct answer is:1 1 2 3

References:

Java SE 21 - ArrayDeque

Java SE 21 - Queue Operations

Analyzing the thrower() Method Execution

java

int i = 0;

return i / i;

i / i evaluates to 0 / 0, whichthrows ArithmeticException (/ by zero).

Since catch (NumberFormatException e) doesnot matchArithmeticException, it is skipped.

The finally block always executes, printing:

nginx

Beaujolais Nouveau,

The exceptionpropagates backto main().

Handling the Exception in main()

java

try {

thrower();

System.out.print("Dom Pérignon, ");

} catch (Exception e) {

System.out.print("Chablis, ");

} finally {

System.out.print("Saint-Émilion");

}

Since thrower() throws ArithmeticException, it is caught by catch (Exception e).

"Chablis, "is printed.

Thefinally block always executes, printing "Saint-Émilion".

Final Output

nginx

Beaujolais Nouveau, Chablis, Saint-Émilion

Thus, the correct answer is:Beaujolais Nouveau, Chablis, Saint-Émilion

References:

Java SE 21 - Exception Handling

Java SE 21 - finally Block Execution

Understanding ExecutorService Methods

execute(Runnable command)

Runs the task but only supports Runnable (not Callable).

❌execService.execute(task2); fails because task2 is Callable.

submit(Runnable task)

Submits a Runnable task for execution.

execService.submit(task1); executes "Executing Task-1".

submit(Callable<T> task)

Submits a Callable task for execution.

execService.submit(task2); executes "Executing Task-2".

call() Does Not Exist in ExecutorService

❌execService.call(task1); and execService.call(task2); are invalid.

run() Does Not Exist in ExecutorService

❌execService.run(task1); and execService.run(task2); are invalid.

Correct Code to Print Both Messages:

java

execService.submit(task1);

execService.submit(task2);

Thus, the correct answer is:execService.submit(task1); execService.submit(task2);

References:

Java SE 21 - ExecutorService

Java SE 21 - Callable and Runnable

In Java generics, wildcards are used to relax the type constraints of generic types. The extends wildcard () denotes an upper bounded wildcard, allowing any type that is a subclass of Type. Conversely, the super wildcard () denotes a lower bounded wildcard, allowing any type that is a superclass of Type.

Option A:

java

public List getListSuper() {

return new ArrayList();

}

Here, List represents a list that can hold IOException objects and objects of its supertypes. Since Exception is a superclass of IOException, ArrayList is compatible with List. Therefore, this method compiles successfully.

Option B:

java

public List getListExtends() {

return new ArrayList();

}

In this case, List represents a list that can hold objects of IOException and its subclasses. Since FileNotFoundException is a subclass of IOException, ArrayList is compatible with List. Thus, this method compiles successfully.

Option C:

java

public List getListExtends() {

return new ArrayList();

}

Here, List expects a list of IOException or its subclasses. However, Exception is a superclass of IOException, not a subclass. Therefore, ArrayList is not compatible with List, and this method will not compile.

Option D:

java

public List getListSuper() {

return new ArrayList();

}

In this scenario, List expects a list that can hold IOException objects and objects of its supertypes. Since FileNotFoundException is a subclass of IOException, ArrayList is not compatible with List, and this method will not compile.

Therefore, the methods in options A and B compile successfully, while those in options C and D do not.

Understanding Try-With-Resources (AutoCloseable)

BoomBoom implements AutoCloseable, meaning its close() method isautomatically calledat the end of the try block.

Step-by-Step Execution

Step 1: Enter Try Block

java

try (BoomBoom boomBoom = new BoomBoom()) {

System.out.print("bim ");

throw new Exception();

}

"bim " is printed.

Anexception (Exception) is thrown, butbefore it is handled, the close() method is executed.

Step 2: close() is Called

java

@Override

public void close() throws Exception {

System.out.print("bam ");

throw new RuntimeException();

}

"bam " is printed.

A new RuntimeException is thrown, but it doesnot override the existing Exception yet.

Step 3: Exception Handling

java

} catch (Exception e) {

System.out.print("boom ");

}

The catch (Exception e)catches the original Exception from the try block.

"boom " is printed.

Final Output

nginx

bim bam boom

Theoriginal Exception is caught, not the RuntimeException from close().

TheRuntimeException from close() is ignoredbecause thecatch block is already handling Exception.

Thus, the correct answer is:bim bam boom

References:

Java SE 21 - Try-With-Resources

Java SE 21 - AutoCloseable Interface