Oracle 1Z0-830 Online Practice Questions and Exam Preparation

Oracle 1Z0-830 Online Questions & Answers

• Question 51:

  Given:

  java

  sealed class Vehicle permits Car, Bike {

  }

  non-sealed class Car extends Vehicle {

  }

  final class Bike extends Vehicle {

  }

  public class SealedClassTest {

  public static void main(String[] args) {

  Class vehicleClass = Vehicle.class;

  Class carClass = Car.class;

  Class bikeClass = Bike.class;

  System.out.print("Is Vehicle sealed? " + vehicleClass.isSealed() +

  "; Is Car sealed? " + carClass.isSealed() +

  "; Is Bike sealed? " + bikeClass.isSealed());

  }

  }

  What is printed?

  A. Is Vehicle sealed? true; Is Car sealed? true; Is Bike sealed? true
  B. Is Vehicle sealed? false; Is Car sealed? false; Is Bike sealed? false
  C. Is Vehicle sealed? true; Is Car sealed? false; Is Bike sealed? false
  D. Is Vehicle sealed? false; Is Car sealed? true; Is Bike sealed? true
  C. Is Vehicle sealed? true; Is Car sealed? false; Is Bike sealed? false

  ---

  Explanation

  Understanding Sealed Classes in Java

  A sealed class restricts which other classes can extend it.

  A sealed class must explicitly declare its permitted subclasses using the permits keyword.

  Subclasses can be declared as:

  sealed(restricts further extension).

  non-sealed(removes the restriction, allowing unrestricted subclassing).

  final(prevents further subclassing).

  Analyzing the Given Code

  Vehicle is declared as sealed with permits Car, Bike, meaning only Car and Bike can extend it.

  Car is declared as non-sealed, which means it is no longer sealed and can have subclasses.

  Bike is declared as final, meaning it cannot be subclassed .

  Using isSealed() Method

  vehicleClass.isSealed() # true because Vehicle is explicitly marked as sealed.

  carClass.isSealed() # false because Car is marked non-sealed.

  bikeClass.isSealed() # false because Bike is final, and a final class is not considered sealed .

  Final Output

  csharp

  Is Vehicle sealed? true; Is Car sealed? false; Is Bike sealed? false

  Thus, the correct answer is:"Is Vehicle sealed? true; Is Car sealed? false; Is Bike sealed? false"

  References:

  Java SE 21 - Sealed Classes Java SE 21 - isSealed() Method

• Question 52:

  Consider:

  List names = List.of("Bob","Alice","Eve");

  var sorted = names.stream()

  .sorted(Comparator.comparing(String::length).reversed()

  .thenComparing(Comparator.naturalOrder()))

  .toList();

  System.out.println(sorted);

  What is printed?

  A. [Eve, Bob, Alice]
  B. [Alice, Eve, Bob]
  C. [Alice, Bob, Eve]
  D. [Bob, Eve, Alice]
  B. [Alice, Eve, Bob]

  ---

  Explanation

  Comparator first sorts by length (descending 3 > 3 > 5

• Question 53:

  Which of the following statements about record patterns introduced in Java 21 is correct?

  A. Record patterns can only be used inside switch expressions.
  B. Record patterns support nested deconstruction of records.
  C. Record patterns cannot be used with sealed interfaces.
  D. Record patterns automatically call equals() on components.
  B. Record patterns support nested deconstruction of records.

  ---

  Explanation

  Record patterns in Java 21 allow deconstruction of record components directly in pattern-matching constructs. They can be nested, enabling recursive matching of component records. They can appear in instanceof expressions and switch labels.

• Question 54:

  Given:

  record Box(T value) {}

  public static void main(String[] args) {

  Box b = new Box(10);

  System.out.println(b.value().doubleValue());

  }

  What is printed?

  A. 10.0
  B. Compilation fails
  C. A ClassCastException
  D. null
  A. 10.0

  ---

  Explanation

  The wildcard ? extends Number allows reading as Number; value() returns Integer

• Question 55:

  Consider the following methods to load an implementation of MyService using ServiceLoader. Which of the methods are correct? (Choose all that apply)

  A. MyService service = ServiceLoader.load(MyService.class).iterator().next();
  B. MyService service = ServiceLoader.load(MyService.class).findFirst().get();
  C. MyService service = ServiceLoader.getService(MyService.class);
  D. MyService service = ServiceLoader.services(MyService.class).getFirstInstance();
  A. MyService service = ServiceLoader.load(MyService.class).iterator().next();
  B. MyService service = ServiceLoader.load(MyService.class).findFirst().get();

  ---

  Explanation

  The ServiceLoader class in Java is used to load service providers implementing a given service interface. The following methods are evaluated for their correctness in loading an implementation of MyService:

  A. MyService service = ServiceLoader.load(MyService.class).iterator().next();

  This method uses the ServiceLoader.load(MyService.class) to create a ServiceLoader instance for MyService. Calling iterator().next() retrieves the next available service provider. If no providers are available, a NoSuchElementException will be thrown. This approach is correct but requires handling the potential exception if no providers are found.

  B. MyService service = ServiceLoader.load(MyService.class).findFirst().get();

  This method utilizes the findFirst() method introduced in Java 9, which returns an Optional describing the first available service provider. Calling get() on the Optional retrieves the service provider if present; otherwise, a NoSuchElementException is thrown. This approach is correct and provides a more concise way to obtain the first service provider.

  C. MyService service = ServiceLoader.getService(MyService.class); The ServiceLoader class does not have a method named getService. Therefore, this method is incorrect and will result in a compilation error.

  D. MyService service = ServiceLoader.services(MyService.class).getFirstInstance();

  The ServiceLoader class does not have a method named services or getFirstInstance. Therefore, this method is incorrect and will result in a compilation error.

  In summary, options A and B are correct methods to load an implementation of MyService using ServiceLoader.

• Question 56:

  Given:

  java

  public class Test {

  static int count;

  synchronized Test() {

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

  }

  }

  What is the given program's output?

  A. It's either 1 or 2
  B. It's either 0 or 1
  C. It's always 2
  D. It's always 1
  E. Compilation fails
  E. Compilation fails

  ---

  Explanation

  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.

• Question 57:

  What is the output?

  var map = new HashMap();

  map.put("A", 1);

  map.merge("A", 2, Integer::sum);

  map.merge("B", 3, Integer::sum);

  System.out.println(map);

  A. {A=3, B=3}
  B. {A=2, B=3}
  C. {A=1, B=3}
  D. {A=3}
  A. {A=3, B=3}

  ---

  Explanation

  merge(key,val,remappingFn) adds a new key or combines values. "A"

• Question 58:

  Given:

  java

  package com.vv;

  import java.time.LocalDate;

  public class FetchService {

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

  FetchService service = new FetchService();

  String ack = service.fetch();

  LocalDate date = service.fetch();

  System.out.println(ack + " the " + date.toString());

  }

  public String fetch() {

  return "ok";

  }

  public LocalDate fetch() {

  return LocalDate.now();

  }

  }

  What will be the output?

  A. ok the 2024-07-10T07:17:45.523939600
  B. Compilation fails
  C. An exception is thrown
  D. ok the 2024-07-10
  B. Compilation fails

  ---

  Explanation

  In Java, method overloading allows multiple methods with the same name to exist in a class, provided they have different parameter lists (i.e., different number or types of parameters). However, having two methods with the exact same

  parameter list and only differing in return type is not permitted.

  In the provided code, the FetchService class contains two fetch methods:

  public String fetch()

  public LocalDate fetch()

  Both methods have identical parameter lists (none) but differ in their return types (String and LocalDate, respectively). This leads to a compilation error because the Java compiler cannot distinguish between the two methods based solely on

  return type.

  The Java Language Specification (JLS) states:

  "It is a compile-time error to declare two methods with override-equivalent signatures in a class."

  In this context, "override-equivalent" means that the methods have the same name and parameter types, regardless of their return types.

  Therefore, the code will fail to compile due to the duplicate method signatures, and the correct answer is B: Compilation fails.

• Question 59:

  What do the following print?

  java

  public class Main {

  int instanceVar = staticVar;

  static int staticVar = 666;

  public static void main(String args[]) {

  System.out.printf("%d %d", new Main().instanceVar, staticVar);

  }

  static {

  staticVar = 42;

  }

  }

  A. 666 42
  B. 666 666
  C. 42 42
  D. Compilation fails
  C. 42 42

  ---

  Explanation

  In this code, the class Main contains both an instance variable instanceVar and a static variable staticVar. The sequence of initialization and execution is as follows:

  Static Variable Initialization:

  staticVar is declared and initialized to 666. Static Block Execution:

  The static block executes, updating staticVar to 42. Instance Variable Initialization:

  When a new instance of Main is created, instanceVar is initialized to the current value of staticVar, which is 42. main Method Execution:

  The main method creates a new instance of Main and prints the values of instanceVar and staticVar.

  Therefore, the output of the program is 42 42.

• Question 60:

  What do the following print?

  java

  import java.time.Duration;

  public class DividedDuration {

  public static void main(String[] args) {

  var day = Duration.ofDays(2);

  System.out.print(day.dividedBy(8));

  }

  }

  A. PT6H
  B. PT0H
  C. It throws an exception
  D. PT0D
  E. Compilation fails
  A. PT6H

  ---

  Explanation

  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.