1z0-830 Practice Exam Questions with Answers Java SE 21 Developer Professional Certification

Understanding Multi-line Strings in Java (""" Text Blocks)

Java 13 introducedtext blocks ("""), allowing multi-line stringswithout needing explicit \n for new lines.

In a text block,each line is preserved as it appears in the source code.

Analyzing the Options

Option A: \ (Backslash Continuation)

The backslash (\) at the end of a lineprevents a new line from being added, meaning:

nginx

red green blue

Incorrect.

Option B: \s (Whitespace Escape)

\s represents asingle space,not a new line.

The output would be:

nginx

red green blue

Incorrect.

Option C: \t (Tab Escape)

\t inserts atab, not a new line.

The output would be:

nginx

red green blue

Incorrect.

Option D: Correct Text Block

java

String colors = """

red

green

blue

""";

Thispreserves the new lines, producing:

nginx

red

green

blue

Correct.

Thus, the correct answer is:"String colors = """ red green blue """."

References:

Java SE 21 - Text Blocks

Java SE 21 - String Formatting

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.

In this scenario, we have a Person class that extends ListResourceBundle and a properties file named Person.properties. Both define a resource with the key "name" but with different values:

Person class (ListResourceBundle):Defines the key "name" with the value "Jeanne".

Person.properties file:Defines the key "name" with the value "James".

When the ResourceBundle.getBundle("Person") method is called, the Java runtime searches for a resource bundle with the base name "Person". The search order is as follows:

Class-Based Resource Bundle:The runtime first looks for a class named Person (i.e., Person.class).

Properties File Resource Bundle:If the class is not found, it then looks for a properties file named Person.properties.

In this case, since the Person class is present and accessible, the runtime will load the Person class as the resource bundle. Therefore, the getBundle method returns an instance of the Person class.

Subsequently, when bundle.getString("name") is called, it retrieves the value associated with the key "name" from the Person class, which is "Jeanne".

Thus, the output of the program is:

nginx

Jeanne

Why does the compilation fail?

TheJava switch statement does not support primitive type pattern matchingin switch expressions as of Java 21.

The case pattern case int i -> "integer"; isinvalidbecausepattern matching with primitive types (like int or long) is not yet supported in switch statements.

The error occurs at case int i -> "integer";, leading to acompilation failure.

Correcting the Code

Since myVar is of type Object,autoboxing converts 0 into an Integer.

To make the code compile, we should use Integer instead of int:

java

Object myVar = 0;

String print = switch (myVar) {

case Integer i -> "integer";

case Long l -> "long";

case String s -> "string";

default -> "";

};

System.out.println(print);

Output:

bash

integer

Thus, the correct answer is:Compilation fails.

References:

Java SE 21 - Pattern Matching for switch

Java SE 21 - switch Expressions

1. Understanding Supplier Functional Interfaces

The Supplier interface is part of java.util.function and provides valueswithout taking any arguments.

Java also provides primitive specializations of Supplier:

BooleanSupplier? Returns a boolean. Exists

DoubleSupplier? Returns a double. Exists

LongSupplier? Returns a long. Exists

Supplier<T>? Returns a generic T. Exists

2. What about BiSupplier<T, U, R>?

There is no BiSupplier<T, U, R> in Java.

In Java, suppliers donot take arguments, so abi-supplierdoes not exist.

If you need a function thattakes two arguments and returns a value, use BiFunction.

Thus, the correct answer is:BiSupplier<T, U, R> does not exist.

References:

Java SE 21 - Supplier

Java SE 21 - Functional Interfaces

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

In Java, FileOutputStream and ObjectOutputStream are used for writing data to files, but they have different purposes and methods. Let's analyze each statement:

fos.write("Today");

The FileOutputStream class is designed to write raw byte streams to files. The write method in FileOutputStream expects a parameter of type int or byte[]. Since "Today" is a String, passing it directly to fos.write("Today"); will cause a compilation error because there is no write method in FileOutputStream that accepts a String parameter.

fos.writeObject("Today");

The FileOutputStream class does not have a method named writeObject. The writeObject method is specific to ObjectOutputStream. Therefore, attempting to call fos.writeObject("Today"); will result in a compilation error.

oos.write("Today");

The ObjectOutputStream class is used to write objects to an output stream. However, it does not have a write method that accepts a String parameter. The available write methods in ObjectOutputStream are for writing primitive data types and objects. Therefore, oos.write("Today"); will cause a compilation error.

oos.writeObject("Today");

The ObjectOutputStream class provides the writeObject method, which is used to serialize objects and write them to the output stream. Since String implements the Serializable interface, "Today" can be serialized. Therefore, oos.writeObject("Today"); is valid and compiles successfully.

In summary, the only statement that compiles without errors is oos.writeObject("Today");.

References:

Java SE 21 & JDK 21 - ObjectOutputStream

Java SE 21 & JDK 21 - FileOutputStream

In Java, the ConcurrentHashMap class provides several constructors that allow for the customization of its initial capacity, load factor, and concurrency level. To configure a ConcurrentHashMap with an initial capacity of 42 and a concurrency level of 10, you can use the following constructor:

java

public ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel)

Parameters:

initialCapacity: The initial capacity of the hash table. This is the number of buckets that the hash table will have when it is created. In this case, it is set to 42.

loadFactor: A measure of how full the hash table is allowed to get before it is resized. The default value is 0.75, but in this case, it is set to 0.88.

concurrencyLevel: The estimated number of concurrently updating threads. This is used as a hint for internal sizing. In this case, it is set to 10.

Therefore, to create a ConcurrentHashMap with an initial capacity of 42, a load factor of 0.88, and a concurrency level of 10, you can use the following code:

java

var concurrentHashMap = new ConcurrentHashMap<>(42, 0.88f, 10);

Option Evaluations:

A. var concurrentHashMap = new ConcurrentHashMap(42);: This constructor sets the initial capacity to 42 but uses the default load factor (0.75) and concurrency level (16). It does not meet the requirement of setting the concurrency level to 10.

B. None of the suggestions.: This is incorrect because option E provides the correct configuration.

C. var concurrentHashMap = new ConcurrentHashMap();: This uses the default constructor, which sets the initial capacity to 16, the load factor to 0.75, and the concurrency level to 16. It does not meet the specified requirements.

D. var concurrentHashMap = new ConcurrentHashMap(42, 10);: This constructor sets the initial capacity to 42 and the load factor to 10, which is incorrect because the load factor should be a float value between 0 and 1.

E. var concurrentHashMap = new ConcurrentHashMap(42, 0.88f, 10);: This correctly sets the initial capacity to 42, the load factor to 0.88, and the concurrency level to 10, meeting all the specified requirements.

Therefore, the correct answer is option E.

In the verifyNotNull method, the following operations are performed:

Assertion to Enable Assertions:

java

boolean enabled = false;

assert enabled = true;

assert enabled;

The variable enabled is initially set to false.

The first assertion assert enabled = true; assigns true to enabled if assertions are enabled. If assertions are disabled, this assignment does not occur.

The second assertion assert enabled; checks if enabled is true. If assertions are enabled and the previous assignment occurred, this assertion passes. If assertions are disabled, this assertion is ignored.

Dereferencing the input Object:

java

System.out.println(input.toString());

This line attempts to call the toString() method on the input object. If input is null, this will throw a NullPointerException.

Assertion to Check input for null:

java

assert input != null;

This assertion checks that input is not null. If input is null and assertions are enabled, this assertion will fail, throwing an AssertionError. If assertions are disabled, this assertion is ignored.

Analysis:

If Assertions Are Enabled:

The enabled variable is set to true by the first assertion, and the second assertion passes.

If input is null, calling input.toString() will throw a NullPointerException before the final assertion is reached.

If input is not null, input.toString() executes without issue, and the final assertion assert input != null; passes.

If Assertions Are Disabled:

The enabled variable remains false, but the assertions are ignored, so this has no effect.

If input is null, calling input.toString() will throw a NullPointerException.

If input is not null, input.toString() executes without issue.

Conclusion:

A NullPointerException is thrown if input is null, regardless of whether assertions are enabled or disabled. Therefore, the correct answer is:

C. Only if assertions are disabled and the input argument is null

Understanding Inner Classes in Java

Aninner class (non-static nested class)requires an instance of the outer classbefore it can be instantiated.

Incorrect instantiationof the inner class at n1:

java

InnerClass innerObject = new InnerClass(); // Compilation error

Since InnerClass is anon-staticinner class, itmust be created from an instance of OuterClass.

Correct Way to Instantiate the Inner Class

java

OuterClass outerObject = new OuterClass();

OuterClass.InnerClass innerObject = outerObject.new InnerClass(); // Correct

Thiscorrectly associatesthe inner class with an instance of OuterClass.

Why Does Compilation Fail?

The error occurs atline n1because InnerClass is beinginstantiated incorrectly.

Thus, the correct answer is:Compilation fails at line n1.

References:

Java SE 21 - Nested and Inner Classes

Java SE 21 - Accessing Outer Class Members

1. Why does the compilation fail?

The interface Special contains bar as int bar = 1;.

In Java, all interface fields are implicitly public, static, and final.

This means that bar is a constant (final variable).

The method add() contains bar--, which attempts to modify bar.

Since bar is final, it cannot be modified, causing acompilation error.

2. Correcting the Code

To make the code compile, bar must not be final. One way to fix this:

java

class SpecialImpl implements Special {

int bar = 1;

}

Or modify the add() method:

java

int add() {

return --foo + bar; // No modification of bar

}

Thus, the correct answer is:Compilation fails.

References:

Java SE 21 - Interfaces

Java SE 21 - Final Variables

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 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.

In this code, the try block throws an IOException. The catch block catches this exception and throws a new RuntimeException. Regardless of exceptions thrown in the try or catch blocks, the finally block is always executed. In this case, the finally block throws an ArithmeticException.

When an exception is thrown in a finally block, it overrides any previous exceptions that were thrown in the try or catch blocks. Therefore, the ArithmeticException thrown in the finally block is the exception that propagates out of the method. As a result, the program terminates with an ArithmeticException.

In this code, an ArrayDeque named deque is created, and the integers 1 and 2 are added to it using the offer method. The offer method inserts the specified element at the end of the deque.

State of deque after offers:[1, 2]

The peek method retrieves, but does not remove, the head of the deque, returning 1. Therefore, i1 is assigned the value 1.

State of deque after peek:[1, 2]

Value of i1:1

The poll method retrieves and removes the head of the deque, returning 1. Therefore, i2 is assigned the value 1.

State of deque after poll:[2]

Value of i2:1

Another peek operation retrieves the current head of the deque, which is now 2, without removing it. Therefore, i3 is assigned the value 2.

State of deque after second peek:[2]

Value of i3:2

The System.out.println statement then outputs the values of i1, i2, and i3, resulting in 1 1 2.

In this code, the SmartPhone interface declares a method ring() with a boolean return type. The Iphone15 class implements the SmartPhone interface and provides an implementation for the ring() method.

However, in the Iphone15 class, the ring() method is declared without the public access modifier. In Java, when a class implements an interface, it must provide implementations for all the interface's methods with the same or a more accessible access level. Since interface methods are implicitly public, the implementing methods in the class must also be public. Failing to do so results in a compilation error.

Therefore, the Iphone15 class does not compile because the ring() method is not declared as public.

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.

In the provided code, four StringBuilder instances are being created using different constructors:

stringBuilder1: new StringBuilder()

This constructor creates an empty StringBuilder with an initial capacity of 16 characters.

stringBuilder2: new StringBuilder(10)

This constructor creates an empty StringBuilder with a specified initial capacity of 10 characters.

stringBuilder3: new StringBuilder("Java")

This constructor creates a StringBuilder initialized to the contents of the specified string "Java".

stringBuilder4: new StringBuilder(new char[]{'J', 'a', 'v', 'a'})

This line attempts to create a StringBuilder using a char array. However, the StringBuilder class does not have a constructor that accepts a char array directly. The available constructors are:

StringBuilder()

StringBuilder(int capacity)

StringBuilder(String str)

StringBuilder(CharSequence seq)

Since a char array does not implement the CharSequence interface, and there is no constructor that directly accepts a char array, this line will cause a compilation error.

To initialize a StringBuilder with a char array, you can convert the char array to a String first:

java

var stringBuilder4 = new StringBuilder(new String(new char[]{'J', 'a', 'v', 'a'}));

This approach utilizes the String constructor that accepts a char array, and then passes the resulting String to the StringBuilder constructor.

In the provided code, a list abc is created containing the strings "a", "b", and "c". The first forEach operation attempts to convert each element to uppercase by assigning x = x.toUpperCase();. However, this assignment only changes the local variable x within the lambda expression and does not modify the elements in the original list abc. Strings in Java are immutable, meaning their values cannot be changed once created. Therefore, the original list remains unchanged.

The second forEach operation iterates over the original list and prints each element. Since the list was not modified, the output will be the concatenation of the original elements: abc.

To achieve the output ABC, you would need to collect the transformed elements into a new list, as shown below:

java

List abc = List.of("a", "b", "c");

List upperCaseAbc = abc.stream()

map(String::toUpperCase)

collect(Collectors.toList());

upperCaseAbc.forEach(System.out::print);

In this corrected version, the map operation creates a new stream with the uppercase versions of the original elements, which are then collected into a new list upperCaseAbc. The forEach operation then prints ABC.

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