UUS Practice Tests⌕ Search
IT Certifications · 1Z0-830

Oracle Java SE 21 Developer Professional Exam Practice Test

The Oracle Java SE 21 Developer Professional Exam practice covers Java code comprehension: evaluating expressions, tracing control flow, understanding references and inheritance, and interpreting core language features. The available questions include loops, arrays, strings, local variable inference with `var`, static method hiding, and resource cleanup.

Exam overview

Exam providerOracle
Exam code1Z0-830
CategoryIT Certifications

About the Oracle Java SE 21 Developer Professional Exam

Java developer work often requires predicting how code behaves before changing or debugging it. Practice with expression precedence and compound assignment, pre- and post-increment, and the difference between changing an enhanced-for loop variable and changing an array element. Distinguish reference types and object state from primitive values, and determine how static methods are resolved from a reference type rather than dispatched polymorphically. Exception-handling questions call for understanding when `finally` executes and how try-with-resources closes resources. These skills support reviewing unfamiliar Java code, spotting logic errors, and making safe edits. The question bank also samples declarations and basic control flow, so trace each statement in order and account for the exact scope and type of every variable.

Sample Practice Questions

Review a selection from this exam's published US Practice Tests practice bank.

Question 1

What does this code print? `int count = 0; while (count < 3) { count++; } System.out.println(count);`

  1. A2
  2. B3
  3. C4
  4. DThe loop never terminates.
Show answerCorrect answer: B

The loop increments `count` while it is less than 3. After the third increment, `count` is 3, the condition is false, and that value is printed.

Question 2

What is the value of `n` after this statement completes? `int n = 2; n *= 3 + 1;`

  1. A7
  2. B8
  3. C10
  4. D9
Show answerCorrect answer: B

The addition on the right-hand side is evaluated first, producing 4. The compound assignment then multiplies `n` by 4, giving `2 * 4`, or 8.

Question 3

What does the following code print? `int total = 0; for (int n : new int[] {2, 3, 4}) { if (n == 3) continue; total += n; } System.out.println(total);`

  1. A5
  2. B6
  3. C9
  4. DThe code does not compile
Show answerCorrect answer: B

When `n` is 3, `continue` skips the addition for that iteration. The remaining values, 2 and 4, are added, giving 6.

Question 4

Which statement about a Java `String` is correct?

  1. ACalling `toUpperCase()` changes the existing string object.
  2. BA `String` is immutable; operations that alter its text produce a string value rather than modifying the original.
  3. CA `String` can be modified only if it was declared with `var`.
  4. DA `String` becomes mutable after it is assigned `null`.
Show answerCorrect answer: B

Java strings are immutable. Methods such as `toUpperCase()` return a result string and do not change the original string object.

Question 5

Given `class Parent { static String tag() { return "P"; } }` and `class Child extends Parent { static String tag() { return "C"; } }`, what is printed by `Parent item = new Child(); System.out.println(item.tag());`?

  1. AP
  2. BC
  3. Cnull
  4. DThe code does not compile.
Show answerCorrect answer: A

Static methods are hidden rather than dynamically overridden. The method selected is based on the reference's compile-time type, which is `Parent`.

Question 6

Which statement about `var` in a local variable declaration is correct?

  1. AIt can be used as the declared type of an instance field.
  2. BIt requires an initializer from which the compiler can infer a type.
  3. CIt makes the variable dynamically typed at runtime.
  4. DIt can be used for a method's return type.
Show answerCorrect answer: B

For a local variable declared with `var`, the compiler infers a static type from the initializer. `var` is not permitted for fields or method return types.

Question 7

What is the result of this code? `int[] scores = {4, 7, 9}; for (int score : scores) { score *= 2; } System.out.println(scores[1]);`

  1. A7
  2. B14
  3. C0
  4. DThe code does not compile because an enhanced `for` loop cannot use an array.
Show answerCorrect answer: A

For an array of primitive values, the enhanced `for` loop variable receives a copy of each element. Changing `score` does not update the corresponding array element, so `scores[1]` remains 7.

How to use this practice test

Access is free. A session presents up to 20 random questions from the 50 published items in this exam’s bank. Answer by tracing code and applying Java language rules; review the results after the session to identify which concepts need another pass.

Preparation tips

  • For expression questions, write intermediate values for precedence, compound assignment, and pre- versus post-increment before selecting an output.
  • Trace loops one iteration at a time, noting when `continue` skips statements and whether an enhanced-for variable is a copy of an array element’s value.
  • Compare the declared reference type with the runtime object when reasoning about inheritance; check whether a method is static before assuming dynamic dispatch.
  • Review local `var` rules by identifying the initializer’s inferred type and checking whether the declaration context permits inference.
  • For exception questions, distinguish normal completion from abrupt completion and account for automatic resource closing in try-with-resources.
Official sourceOfficial exam page ↗