1Z0-830 — Oracle Java SE 21 Developer Professional Exam Blueprint

How to Use This Exam Blueprint

This checklist is an independent study map for the Oracle Java SE 21 Developer Professional (1Z0-830) exam. Use it to confirm that you can apply Java SE 21 concepts under exam conditions: reading code, predicting output, identifying compiler errors, choosing APIs, and recognizing safer or more maintainable designs.

Exact official weights are not provided here, so treat the sections below as readiness areas, not weighted scoring categories.

A practical pass through this page should help you answer:

• Can I predict what Java code does without running it?
• Can I identify compile-time errors versus runtime exceptions?
• Can I choose the correct Java SE API for a scenario?
• Can I reason about generics, streams, modules, concurrency, I/O, JDBC, and localization?
• Can I spot traps involving scope, initialization, overload resolution, type inference, mutability, and resource handling?

Topic-Area Readiness Table

Java Language Foundations Checklist

Variables, Types, Operators, and Scope

Can you do this?

• Determine whether a variable declaration using var is valid.
• Distinguish local variable type inference from fields, parameters, and return types.
• Apply numeric promotion rules for byte, short, char, int, long, float, and double.
• Predict compound assignment behavior such as x += y.
• Identify narrowing casts that compile but may lose data.
• Distinguish object identity from object equality.
• Explain when String concatenation creates new objects conceptually.
• Use String, StringBuilder, and text blocks appropriately.
• Identify scope and shadowing issues in blocks, loops, lambdas, and methods.

Example readiness prompt:

var value = 10;
value += 2.5;
System.out.println(value);

You should be able to explain whether this compiles and why compound assignment is not the same as a simple assignment.

Arrays, Strings, and Core APIs

Control Flow and Pattern-Based Decisions

Core Flow Control

Be ready to trace:

• Nested if / else blocks.
• Traditional switch statements.
• Switch expressions that return a value.
• yield in switch expression blocks.
• Loops with labels.
• break and continue in nested loops.
• Enhanced for loops over arrays and collections.

Switch and Pattern Matching Readiness

Java SE 21 includes modern switch capabilities. Be prepared to reason about switch syntax and exhaustiveness where applicable.

Code-reading prompt:

static String describe(Object o) {
    return switch (o) {
        case String s when s.length() > 3 -> "long string";
        case String s -> "string";
        case null -> "null";
        default -> "other";
    };
}

You should be able to explain the role of pattern order, guards, and null.

Methods, Encapsulation, and Object State

Method and Field Checklist

• Identify valid method declarations.
• Distinguish instance methods from static methods.
• Determine whether a member is accessible from another class or package.
• Resolve overloaded method calls involving primitives, wrappers, inheritance, and varargs.
• Explain pass-by-value for object references.
• Recognize when a method mutates an object versus reassigns a local parameter.
• Understand final variables, final fields, final methods, and final classes.
• Identify legal and illegal uses of this and super.

Overload and Override Decision Table

Common traps:

• Static methods are hidden, not overridden.
• Fields are hidden, not polymorphic.
• Overloading is resolved at compile time.
• Overriding is selected at runtime based on the actual object.
• A private method is not overridden by a subclass method with the same signature.

Class Design, Initialization, and Inheritance

Initialization Order

Be ready to trace object creation in this general order:

1. Static fields and static initializers of the superclass.
2. Static fields and static initializers of the subclass.
3. Instance fields and instance initializers of the superclass.
4. Superclass constructor.
5. Instance fields and instance initializers of the subclass.
6. Subclass constructor.

Checklist:

• Identify when static initialization happens.
• Trace constructor chaining with this(...) and super(...).
• Recognize that super(...) or this(...) must be the first constructor statement when present.
• Determine which constructor is called.
• Spot calls to overridable methods from constructors.
• Identify abstract class instantiation errors.
• Apply access control across packages and subclasses.

Interfaces, Abstract Classes, and Polymorphism

Records, Enums, Sealed Classes, and Nested Types

Records

Can you do this?

• Identify the canonical constructor of a record.
• Write or read a compact constructor.
• Know that record components lead to accessor methods.
• Recognize that records are intended as transparent data carriers.
• Distinguish shallow immutability from deep immutability.
• Identify invalid attempts to assign record fields outside construction.

Prompt:

record User(String name, java.util.List<String> roles) {
    User {
        if (name == null) throw new IllegalArgumentException();
    }
}

You should be able to explain what the compact constructor validates and why the list itself may still be mutable unless defensively copied.

Enums

Review:

• Enum constants and constructors.
• Enum fields and methods.
• Constant-specific class bodies.
• values() and valueOf().
• Enum use in switch.
• Why enum constructors are not public.

Sealed Types

Exceptions and Resource Handling

Exception Checklist

• Distinguish checked exceptions, unchecked exceptions, and errors.
• Identify when a method must declare or handle a checked exception.
• Order catch blocks from specific to general.
• Apply multi-catch rules.
• Understand that finally normally executes even when an exception is thrown.
• Recognize how return in finally can obscure earlier results or exceptions.
• Use try-with-resources for AutoCloseable.
• Determine resource closing order.
• Identify suppressed exceptions.

Try-with-resources prompt:

try (var a = new Resource("A");
     var b = new Resource("B")) {
    throw new RuntimeException("body");
}

You should know that resources close in reverse order and that close failures may be suppressed behind the primary exception.

Exception Decision Points

Generics and Collections

Generics Readiness

Can you do this?

• Explain type erasure at a practical level.
• Identify valid generic class, method, and constructor declarations.
• Use bounded type parameters such as <T extends Number>.
• Distinguish List<Object> from List<?>.
• Apply producer/consumer wildcard reasoning.
• Recognize unsafe raw type assignments.
• Understand why generic arrays are restricted.
• Identify when casts generate warnings versus errors.

Practical wildcard guide:

Collections Readiness

Comparator prompt:

Comparator<String> byLengthThenText =
    Comparator.comparingInt(String::length)
              .thenComparing(Comparator.naturalOrder());

You should be able to explain the sort order and identify compatible method references.

Lambdas, Functional Interfaces, and Method References

Functional Interface Checklist

• Identify whether an interface is functional.
• Match lambda parameter and return types to the target type.
• Use Predicate<T>, Function<T,R>, Consumer<T>, Supplier<T>, UnaryOperator<T>, and BinaryOperator<T>.
• Understand primitive specializations such as IntPredicate and ToIntFunction.
• Identify effectively final captured variables.
• Recognize valid method references:
  • Static method reference.
  • Bound instance method reference.
  • Unbound instance method reference.
  • Constructor reference.

Lambda Trap Table

Streams, Optionals, and Collectors

Stream Pipeline Readiness

Can you do this?

• Identify source, intermediate operations, and terminal operations.
• Explain stream laziness.
• Predict when side effects execute.
• Avoid reusing a stream after a terminal operation.
• Distinguish map, flatMap, filter, peek, sorted, distinct, limit, and skip.
• Use reduce correctly.
• Work with Optional without blindly calling get().
• Choose primitive streams where appropriate.
• Understand the risks of parallel streams with shared mutable state.

Stream prompt:

var result = java.util.List.of("ape", "bear", "cat").stream()
    .filter(s -> s.length() > 3)
    .map(String::toUpperCase)
    .findFirst();

You should identify the result type, the terminal operation, and whether all elements must be processed.

Collector Readiness

Optional Readiness

• Distinguish orElse from orElseGet.
• Use orElseThrow appropriately.
• Use map and flatMap with optional values.
• Avoid assuming an Optional contains a value.
• Recognize APIs that return optional results, such as some stream terminal operations.

Date, Time, Formatting, and Localization

Date and Time API Checklist

Can you do this?

• Add and subtract dates and times immutably.
• Distinguish date-based and time-based arithmetic.
• Format and parse using standard and custom formatters.
• Reason about zone conversions conceptually.
• Recognize invalid date/time values.

Localization Checklist

• Build Locale values.
• Use localized number, currency, date, and time formatting.
• Understand resource bundle lookup and fallback conceptually.
• Use ResourceBundle to retrieve localized messages.
• Recognize missing resource behavior.
• Apply MessageFormat-style parameter substitution when relevant.

Scenario cues:

Modules, Packaging, and Deployment Concepts

Module System Checklist

Can you read and reason about module-info.java?

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

Be ready to identify:

• Module name.
• Required modules.
• Exported packages for compile-time and runtime access.
• Opened packages for reflection.
• Service usage.
• Service provider declarations with provides ... with ....
• Difference between classpath and module path.
• Automatic and unnamed module concepts.
• Split package problems.
• Encapsulation benefits of modules.

Command and Artifact Awareness

You do not need to memorize every command option, but you should recognize the purpose of common Java tools.

Conceptual command prompt:

javac --module-path mods -d out src/com.example.app/module-info.java
java --module-path mods:out -m com.example.app/com.example.Main

You should understand the distinction between compiling/running modules and compiling/running classpath-based applications.

Concurrency and Virtual Threads

Core Concurrency Checklist

• Distinguish Thread, Runnable, and Callable.
• Submit tasks with an executor.
• Retrieve results with Future or related APIs.
• Shut down executors appropriately.
• Identify race conditions.
• Use synchronized to protect critical sections.
• Understand intrinsic locks.
• Distinguish visibility from atomicity.
• Use atomic classes for simple atomic updates.
• Choose concurrent collections where appropriate.
• Recognize deadlock risk.
• Understand parallel stream tradeoffs.

Virtual Thread Readiness

Java SE 21 includes virtual threads. Be ready to reason at a practical level:

Scenario cues:

I/O, NIO.2, and File Handling

File and Stream Checklist

• Distinguish byte streams from character streams.
• Use buffering appropriately.
• Use try-with-resources for I/O objects.
• Read and write text files conceptually.
• Work with Path rather than raw string paths where appropriate.
• Resolve relative paths.
• Use Files utility methods.
• Walk or search file trees conceptually.
• Handle checked IOException.
• Understand serialization at a conceptual and code-reading level if it appears.

NIO.2 Decision Table

Common traps:

• A Path object can represent a path that does not exist.
• Relative paths depend on the working directory context.
• Character encoding matters for text.
• Many file operations throw checked exceptions.
• Resource leaks are exam-relevant; prefer try-with-resources.

JDBC and Database Access

JDBC Flow Checklist

Can you reason through this flow?

1. Obtain a connection.
2. Create a statement or prepared statement.
3. Bind parameters when needed.
4. Execute query or update.
5. Process the result set.
6. Commit or roll back if managing transactions.
7. Close resources safely.

Readiness checks:

• Distinguish Statement from PreparedStatement.
• Know why prepared statements help with parameter handling and SQL injection risk.
• Process ResultSet cursor movement correctly.
• Understand auto-commit conceptually.
• Know when to call commit or rollback.
• Close ResultSet, statement, and connection resources.
• Handle SQLException.
• Avoid building SQL with unchecked user input.

Prompt:

try (var conn = dataSource.getConnection();
     var ps = conn.prepareStatement(
         "select name from users where id = ?")) {
    ps.setInt(1, id);
    try (var rs = ps.executeQuery()) {
        while (rs.next()) {
            System.out.println(rs.getString("name"));
        }
    }
}

You should be able to explain parameter binding, cursor movement, and resource closure.

Annotations and Metadata

Review annotation basics if they appear in your study objectives:

• Built-in annotations such as @Override, @Deprecated, and @SuppressWarnings.
• Custom annotation declaration syntax.
• Valid annotation element types.
• Default element values.
• Marker annotations.
• Single-element annotations.
• Repeatable annotation concept.
• Retention and target concepts.

Common trap: @Override is checked by the compiler. If the method does not actually override a valid inherited method, compilation fails.

Scenario and Decision-Point Checks

Use this section to test whether you can choose among similar Java features.

Common Weak Areas and Exam Traps

Code-Reading Traps

• Confusing compile-time type with runtime object type.
• Missing that a variable is shadowed in an inner scope.
• Forgetting that arrays are covariant but generics are invariant.
• Assuming collection factory results are freely mutable.
• Reusing a stream after a terminal operation.
• Calling Optional.get() without checking presence.
• Ignoring checked exceptions in lambdas.
• Misreading overloaded methods with null.
• Treating StringBuilder like immutable String.
• Forgetting constructor and initializer execution order.

API Selection Traps

Syntax Traps

• var requires an initializer and cannot infer from null alone.
• Lambda parameter types must be all explicit or all inferred in a parameter list.
• A switch expression must produce a value for each path.
• A record cannot declare instance fields outside its components except static fields.
• A subclass constructor must invoke a superclass constructor directly or indirectly.
• A multi-catch parameter cannot be assigned.
• Generic type parameters are not available for runtime type checks in the same way as concrete classes.
• Interface fields are implicitly public static final.

“Can You Do This?” Final Skills Checklist

Before you consider yourself ready for Oracle Java SE 21 Developer Professional (1Z0-830), you should be able to complete these tasks without an IDE:

Language and OOP

• Predict output for code involving constructors, inheritance, static members, and instance initialization.
• Identify invalid declarations involving classes, records, enums, interfaces, and sealed types.
• Resolve overloaded and overridden methods correctly.
• Explain access-control outcomes across packages.
• Distinguish mutability of references, objects, arrays, collections, and records.

APIs and Data Handling

• Use core string, array, math, wrapper, and collection APIs accurately.
• Select the right collection type for ordering, uniqueness, lookup, or queue behavior.
• Build type-safe generic methods and classes.
• Apply wildcard bounds to producer and consumer scenarios.
• Format dates, numbers, currencies, and messages for locale-sensitive output.

Functional and Stream Programming

• Match lambdas to functional interfaces.
• Convert simple lambdas to method references.
• Build stream pipelines for filtering, mapping, sorting, reducing, and collecting.
• Use collectors for grouping, partitioning, joining, counting, and mapping.
• Avoid unsafe side effects in streams and parallel operations.

Platform and Runtime Topics

• Interpret module declarations.
• Recognize classpath versus module path scenarios.
• Use conceptual Java tooling knowledge for compilation, packaging, dependency analysis, and runtime images.
• Identify concurrency hazards and appropriate coordination tools.
• Explain where virtual threads fit and where they do not.
• Handle I/O resources safely.
• Write or read JDBC access code safely.

Final-Week Review Checklist

Seven to Five Days Out

• Re-read your notes on topics where you still confuse compile-time and runtime behavior.
• Drill mixed code snippets without running them.
• Review method overloading, overriding, generics, lambdas, and streams together; these often combine.
• Revisit module declarations and service-related syntax.
• Practice exception flow, especially try-with-resources and suppressed exceptions.

Four to Two Days Out

• Complete timed mixed-topic practice sets.
• Review every missed question by classifying the miss: syntax, API knowledge, logic trace, or rushed reading.
• Memorize key API method names you frequently confuse.
• Practice reading stream pipelines from source to terminal operation.
• Review date/time and localization scenarios.

Day Before

• Stop trying to learn large new areas.
• Review concise notes, traps, and corrected mistakes.
• Do a short set of representative questions to stay sharp.
• Confirm you can explain why each answer is correct or incorrect.
• Rest enough to read code carefully during the exam.

Exam-Day Habits

• Read every code snippet for imports, package context, access modifiers, and variable declarations.
• Check whether the question asks for output, compile failure, runtime exception, or best design choice.
• Track object references and mutations carefully.
• Watch for unchecked assumptions about mutability, thread safety, and resource cleanup.
• Mark difficult questions and return after easier wins.
• Do not overfit to IDE behavior; answer according to Java language and API rules.

Practical Next Step

Use this checklist as a gap map: mark each area as solid, needs review, or not ready. Then focus your next practice session on the weakest two or three areas, especially mixed questions that combine language rules with collections, streams, exceptions, modules, concurrency, I/O, or JDBC.