1Z0-830 — Oracle Java SE 21 Developer Professional Quick Review

Quick Review purpose

This Quick Review is for candidates preparing for Oracle Java SE 21 Developer Professional (1Z0-830). It is IT Mastery review support, not an Oracle document, and is designed to help you refresh high-yield Java SE 21 concepts before working through topic drills, mock exams, original practice questions, and detailed explanations.

Use it as a fast diagnostic checklist:

1. Review the tables and decision rules.
2. Mark topics where you hesitate.
3. Drill those topics in a question bank.
4. Read explanations carefully, especially for compile-time errors and small output differences.

The real challenge on 1Z0-830 is rarely remembering one isolated API call. It is usually reading Java code exactly: scope, overload resolution, generics, stream laziness, exception flow, object identity, module visibility, concurrency behavior, and Java SE 21 language features.

Exam-reading mindset

For code questions, classify the issue before calculating output.

High-yield Java SE 21 checklist

Java language fundamentals

Primitives, wrappers, and promotion

Common trap:

byte b = 1;
// b = b + 1;   // does not compile: int result
b += 1;         // compiles: implicit narrowing conversion

String, StringBuilder, and text blocks

Watch for:

• substring, replace, trim, strip, toLowerCase, and similar methods do not mutate the original String.
• StringBuilder.equals() is not value-based like String.equals(). Unless overridden by a subclass, it uses object identity.
• Text block questions may test spaces and newlines, not just visible words.

var rules

Examples:

var name = "java";        // String
var list = new ArrayList<String>();
// var value;             // does not compile
// var n = null;          // does not compile

var is not dynamic typing. The type is fixed at compile time.

Control flow and switch

Switch statements vs switch expressions

Example:

int score = switch (grade) {
    case "A" -> 5;
    case "B" -> 4;
    default -> 0;
};

With a block:

int score = switch (grade) {
    case "A" -> {
        System.out.println("excellent");
        yield 5;
    }
    default -> 0;
};

Switch traps

Object-oriented programming

Overloading vs overriding

High-yield rule: the reference type selects overloaded methods; the runtime object selects overridden instance methods.

class A {
    void m(Object o) { System.out.print("A-Object"); }
    void n() { System.out.print("A"); }
}
class B extends A {
    void m(String s) { System.out.print("B-String"); } // overload
    @Override void n() { System.out.print("B"); }
}

A x = new B();
x.m("hi"); // A-Object
x.n();     // B

Constructors and initialization

Review order:

1. Static fields and static initializers, superclass first.
2. Instance fields and instance initializers, superclass first.
3. Superclass constructor.
4. Subclass instance fields/initializers and constructor body.

Constructor rules:

• A constructor call to this(...) or super(...) must be the first statement when explicit.
• If no constructor is declared, a default no-argument constructor is provided.
• If any constructor is declared, no default constructor is automatically added.
• Abstract classes can have constructors.
• Interfaces do not have constructors.

Interfaces

Conflict rule: if a class inherits conflicting defaults, it must override and choose or provide behavior. A superclass instance method generally wins over an interface default.

Records, sealed classes, and pattern matching

Records

Records are compact carriers for shallowly immutable data.

record Point(int x, int y) {}

The compiler provides:

• private final fields for components
• public accessor methods named x() and y()
• canonical constructor
• equals, hashCode, and toString

Record review table:

Compact constructor trap:

record Range(int start, int end) {
    Range {
        if (start > end) throw new IllegalArgumentException();
        // assignments to components happen automatically after this block
    }
}

Sealed classes and interfaces

Sealed types restrict which classes or interfaces can directly extend or implement them.

sealed interface Shape permits Circle, Rectangle {}

final class Circle implements Shape {}
non-sealed class Rectangle implements Shape {}

Rules to remember:

• A sealed type lists permitted direct subclasses with permits, unless they are discoverable in the same compilation unit.
• Each permitted direct subclass must declare exactly one of final, sealed, or non-sealed.
• Sealed hierarchies support exhaustiveness checks in pattern switches.
• Sealing controls direct inheritance, not object creation by itself.

Pattern matching

instanceof pattern:

if (obj instanceof String s) {
    System.out.println(s.length());
}

Pattern variable scope is flow-sensitive. The variable exists only where the compiler knows the pattern matched.

Common examples:

if (!(obj instanceof String s)) {
    return;
}
System.out.println(s.length()); // valid

Pattern switch:

String result = switch (obj) {
    case Integer i when i > 0 -> "positive integer";
    case Integer i -> "integer";
    case String s -> "string";
    case null -> "null";
    default -> "other";
};

Common traps:

• Put narrower or guarded cases before broader cases.
• case Object o can dominate later cases depending on selector type and exhaustiveness.
• Guarded patterns with when are not the same as unguarded total patterns.
• Record patterns deconstruct records but still follow type and scope rules.

Exceptions

Checked vs unchecked

Try-with-resources

try (var in = Files.newBufferedReader(path);
     var out = Files.newBufferedWriter(otherPath)) {
    // use resources
}

Rules:

• Resources must implement AutoCloseable or Closeable.
• Resources close in reverse order of creation.
• If both the try block and close operation throw, close exceptions may become suppressed exceptions.
• Resource variables are effectively final inside the try block.

Catch and finally traps

Generics and collections

Generic type rules

PECS memory aid:

• Producer extends: use ? extends T when the structure produces T values for you.
• Consumer super: use ? super T when the structure consumes T values from you.

Collection factories and mutability

Ordering and equality

Set/map trap: if compareTo or a comparator says two objects are equal, a TreeSet treats them as duplicates even if equals would differ.

Sequenced collections in Java SE 21

Java SE 21 adds sequenced collection abstractions for collections with a defined encounter order.

Do not assume every collection is sequenced. A hash-based collection without defined encounter order is different from an ordered collection.

Lambdas, method references, and functional interfaces

Core functional interfaces

Lambda rules:

• Captured local variables must be final or effectively final.
• The target type must be a functional interface.
• Parameter types can be explicit, inferred, or all var; do not mix styles.
• A block lambda with a non-void target must return a value on all paths.

Method reference forms:

Streams and collectors

Stream pipeline structure

A stream pipeline has:

1. Source: collection, array, file, generator, range.
2. Intermediate operations: lazy transformations.
3. Terminal operation: triggers processing and consumes the stream.

Common traps:

• A stream cannot be reused after a terminal operation.
• Intermediate operations do not run until a terminal operation.
• peek is mainly for debugging; do not rely on it without a terminal operation.
• findAny may return any matching element, especially with parallel streams.
• forEach on a parallel stream does not preserve order; forEachOrdered attempts encounter order.

map vs flatMap

Example idea:

List<List<String>> groups = List.of(List.of("a", "b"), List.of("c"));

groups.stream()
      .flatMap(List::stream)
      .toList(); // ["a", "b", "c"]

Reduce and collect

Reduction trap: for parallel streams, accumulator and combiner must be associative and compatible with the identity. Side effects in reductions are a common source of wrong answers.

Optional

Date, time, and localization

java.time

Rules:

• java.time classes are immutable.
• Months in LocalDate.of(year, month, day) are 1-based if using integers.
• Prefer Month.JANUARY style in real code when clarity matters.
• Period is date-based; Duration is time-based.
• Time zones and daylight saving transitions can produce non-obvious results.

Formatting and localization

Resource bundle review:

• Lookup uses a fallback chain based on requested locale and base bundle.
• Missing keys can throw MissingResourceException.
• Localization questions often test which bundle is selected, not translation knowledge.

I/O and NIO.2

Path and Files

Byte and character streams

Common traps:

• Byte streams are not character streams.
• Character encoding matters when converting bytes to text.
• Many I/O methods throw checked IOException.
• Streams returned by file APIs may be lazy and need explicit closing or try-with-resources.

Concurrency and virtual threads

Core concurrency concepts

Race condition trap:

count++; // read, add, write — not atomic

Use synchronization, locks, atomics, or concurrency-safe structures when shared mutable state is accessed by multiple threads.

Virtual threads in Java SE 21

Virtual threads are lightweight threads intended to make blocking, thread-per-task server-style code more scalable.

Review points:

• Created with APIs such as Thread.startVirtualThread(...) or virtual-thread executors.
• Useful for many blocking tasks, not for making CPU-bound algorithms automatically faster.
• Avoid assuming thread identity, scheduling order, or timing.
• Be careful with shared mutable state exactly as with platform threads.
• Blocking while holding monitors or using certain native operations can reduce scalability.

Example:

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    Future<String> f = executor.submit(() -> "done");
    System.out.println(f.get());
}

Concurrency traps

JDBC

Core JDBC flow

Typical flow:

1. Obtain Connection.
2. Create PreparedStatement or Statement.
3. Bind parameters if needed.
4. Execute.
5. Process ResultSet if returned.
6. Commit/rollback when managing transactions.
7. Close resources, usually with try-with-resources.

try (Connection con = dataSource.getConnection();
     PreparedStatement ps = con.prepareStatement(
         "select name from employee where id = ?")) {

    ps.setInt(1, id);

    try (ResultSet rs = ps.executeQuery()) {
        while (rs.next()) {
            System.out.println(rs.getString(1));
        }
    }
}

JDBC review table

Common trap: PreparedStatement prevents SQL injection only when values are bound as parameters, not when user input is concatenated into SQL text before preparing.

Modules

module-info.java

Example:

module com.example.app {
    requires com.example.service;
    exports com.example.api;
    opens com.example.model;
    uses com.example.spi.Plugin;
}

High-yield distinction:

• exports is about ordinary public type accessibility.
• opens is about deep reflection.
• A public class in a non-exported package is not necessarily accessible to other named modules.
• The class path and module path have different visibility rules.

Secure and robust coding themes

Oracle Java SE 21 Developer Professional (1Z0-830) candidates should be comfortable recognizing safer coding choices in ordinary Java code.

Common candidate mistakes

Quick practice plan

Use this Quick Review as a map for IT Mastery practice:

1. Start with topic drills. Work small sets on language basics, OOP, records/sealed types, generics, streams, exceptions, modules, I/O, concurrency, and JDBC.
2. Review every detailed explanation. For missed questions, identify whether the error was compilation, API behavior, output tracing, or concept confusion.
3. Build a personal trap list. Include examples such as Arrays.asList, orElse eagerness, switch exhaustiveness, wildcard capture, and try-with-resources close order.
4. Move to mixed sets. Once topic scores stabilize, use mixed original practice questions to simulate context switching.
5. Finish with mock exams. Practice pacing and answer discipline. Do not change answers unless you find a specific code rule you missed.

Final review checklist before mock exams

You are ready for full-length practice when you can quickly answer:

• Does this snippet compile?
• Which overload is selected?
• Which method is overridden at runtime?
• Is the collection ordered, sorted, immutable, fixed-size, or a view?
• Is a stream operation intermediate or terminal?
• Can this lambda capture the variable?
• Is the generic assignment safe, unsafe, or illegal?
• What happens if this Optional is empty?
• Which exception is caught, suppressed, or thrown?
• Does the NIO operation normalize text or access the real file system?
• Is this concurrency result deterministic?
• Is this JDBC call using the right execution method and index?
• Is this package exported, opened, both, or neither?

Next step: choose your weakest three topics from this page and work targeted question bank drills with original practice questions and detailed explanations before attempting another mixed mock exam.

Continue in IT Mastery

Use this Quick Review as a final concept map, then move into IT Mastery for focused topic drills, mixed practice sets, timed mock exams, and detailed explanations. The practice questions are original IT Mastery practice items; they are not official Oracle questions, copied live-exam content, or exam dumps.