1Z0-829 — Oracle Java SE 17 Developer Exam Blueprint

How to Use This Exam Blueprint

Use this checklist as a practical study map for the Oracle Java SE 17 Developer (1Z0-829) exam from Oracle. It is not a replacement for hands-on coding or official exam information. It is designed to help you decide whether you can recognize, write, debug, and reason about Java SE 17 code under exam conditions.

For each topic area, ask:

• Can I predict the output without running the code?
• Can I identify compile-time errors versus runtime exceptions?
• Can I choose the best API, syntax form, or design approach for a scenario?
• Can I explain why the other options are wrong?
• Can I handle edge cases involving scope, access, generics, streams, modules, exceptions, and concurrency?

Topic-area readiness table

Java basics and declarations

Core checks

• Identify legal and illegal identifiers, including reserved words and contextual keywords.
• Distinguish top-level, member, local, and anonymous declarations.
• Know which declarations can use access modifiers.
• Recognize valid main method signatures.
• Understand default initialization for fields and array elements.
• Know that local variables must be definitely assigned before use.
• Use var only where local variable type inference is allowed.
• Distinguish primitive types from wrapper types.
• Recognize autoboxing, unboxing, and where NullPointerException can occur.
• Understand String immutability and string pool behavior at a practical level.

Common traps

Can you do this?

var a = 10;
var b = 10L;
var c = a + b;
System.out.println(((Object) c).getClass().getSimpleName());

You should be able to identify the inferred type of c and explain numeric promotion.

Operators, expressions, and numeric behavior

Final-review expression checks

• I can determine when a narrowing cast is required.
• I can identify integer division versus floating-point division.
• I can explain NaN, infinity, and comparison behavior for floating-point values at a basic level.
• I can trace side effects in expressions with ++, --, assignment, and method calls.
• I can spot unreachable code caused by constant expressions or unconditional flow transfer.

Control flow and switch readiness

What to know

• if / else binding and nested conditionals.
• Loop types: for, enhanced for, while, do while.
• Labels with break and continue.
• Switch statements versus switch expressions.
• case labels, default, yield, and exhaustiveness expectations where applicable.
• Fall-through behavior in traditional switch statements.

Switch readiness table

Example review

int score = 2;
String result = switch (score) {
    case 1 -> "low";
    case 2, 3 -> "mid";
    default -> {
        yield "high";
    }
};

You should be able to explain why this compiles, what value is assigned, and how it differs from a traditional switch statement.

Object-oriented programming

Class and object readiness

• Trace constructor chaining with this() and super().
• Know that a constructor does not have a return type.
• Identify when the compiler inserts a default constructor.
• Understand initialization order: static fields/blocks, instance fields/blocks, constructors.
• Distinguish method overloading from overriding.
• Apply access modifiers: private, package access, protected, public.
• Recognize legal and illegal uses of static, final, and abstract.
• Understand field hiding versus method overriding.
• Predict dynamic dispatch for overridden instance methods.
• Know that static methods are hidden, not overridden.
• Understand covariant return types in overriding.

OOP decision table

Initialization-order check

class Parent {
    static { System.out.print("A"); }
    { System.out.print("B"); }
    Parent() { System.out.print("C"); }
}

class Child extends Parent {
    static { System.out.print("D"); }
    { System.out.print("E"); }
    Child() { System.out.print("F"); }
}

You should be able to predict output order when new Child() is executed after class loading considerations are applied.

Interfaces, enums, records, and sealed types

Interfaces

• Identify implicit public static final fields.
• Identify implicit public abstract methods.
• Use default methods correctly.
• Use static interface methods correctly.
• Recognize private interface methods used to share default-method logic.
• Resolve conflicts between inherited default methods.
• Know that a class implementation wins over an interface default method.

Enums

• Know enum constants are instances of the enum type.
• Recognize legal enum constructors and fields.
• Understand that enum constructors are not called directly by application code.
• Use values(), valueOf(), name(), and ordinal() cautiously.
• Avoid relying on ordinal() for stable business meaning.

Records

• Recognize record components and generated accessors.
• Understand that records are intended as transparent carriers for immutable data.
• Know how compact constructors validate or normalize input.
• Identify restrictions on record inheritance.
• Distinguish component accessors from JavaBean-style getters.

record Account(String id, int balance) {
    Account {
        if (balance < 0) throw new IllegalArgumentException();
    }
}

You should be able to explain when the compact constructor runs and how component assignment works.

Sealed classes and interfaces

• Recognize sealed, non-sealed, and final.
• Understand the role of permits.
• Know that permitted subclasses must declare an allowed continuation modifier.
• Apply sealed types to constrained inheritance scenarios.
• Distinguish sealed hierarchies from enums and records.

Exceptions and resource handling

Exception-readiness table

Can you do this?

• Given a method body, identify every checked exception that must be handled or declared.
• Given nested try / catch / finally, determine the final output and thrown exception.
• Given try-with-resources, determine resource closing order.
• Explain why catch (Exception e) before catch (IOException e) is invalid.
• Identify when a finally block can mask a prior exception or return value.

Resource handling example

try (var in = Files.newBufferedReader(path)) {
    return in.readLine();
}

You should know why this is safer than manually closing the reader and which checked exceptions may matter.

Arrays, collections, and generics

Arrays

• Create, initialize, and access one-dimensional and multidimensional arrays.
• Distinguish array length from collection size.
• Recognize array covariance and possible ArrayStoreException.
• Know default element values.
• Use enhanced for loops without assuming they can replace array elements by reassigning the loop variable.

Collections

Generics

• Understand type parameters on classes, interfaces, methods, and constructors.
• Identify valid bounded type parameters.
• Use upper-bounded wildcards: ? extends Type.
• Use lower-bounded wildcards: ? super Type.
• Recognize when a wildcard allows reading, writing, or neither safely.
• Understand type erasure at a practical exam level.
• Identify raw type risks and unchecked warnings.
• Know that generic type parameters cannot use primitive types directly.

Wildcard decision prompt

A common memory aid is producer extends, consumer super, but do not use it mechanically. Always check what the code actually reads and writes.

Lambdas, method references, and functional interfaces

Functional interface readiness

• Identify a functional interface by its single abstract method.
• Ignore Object methods when counting abstract methods.
• Recognize @FunctionalInterface as a compile-time validation aid.
• Match lambda parameter and return types to the target functional interface.
• Know that lambda variables must be final or effectively final.
• Distinguish expression lambdas from block lambdas.
• Recognize valid method references.

Common built-in functional interfaces

Method reference checks

Can you decide whether this compiles?

Predicate<String> p = String::isBlank;
Function<String, Integer> f = String::length;
Supplier<StringBuilder> s = StringBuilder::new;

You should be able to map each method reference to the functional interface method signature.

Streams, collectors, and Optional

Stream pipeline readiness

• Distinguish source, intermediate operations, and terminal operations.
• Know that many intermediate operations are lazy.
• Recognize single-use stream behavior.
• Predict short-circuiting with operations such as findFirst, findAny, anyMatch, allMatch, noneMatch, limit.
• Distinguish map from flatMap.
• Understand primitive streams: IntStream, LongStream, DoubleStream.
• Use summaryStatistics, average, sum, min, and max appropriately.
• Recognize when terminal operations return Optional.
• Identify side-effect risks in stream pipelines.

Collector readiness table

Stream traps

Optional checks

• Use isPresent, isEmpty, ifPresent, orElse, orElseGet, orElseThrow.
• Explain eager evaluation of orElse versus lazy evaluation of orElseGet.
• Avoid using Optional as a general replacement for every nullable field.
• Recognize OptionalInt, OptionalLong, and OptionalDouble.

String value = Optional.of("java")
        .filter(s -> s.length() > 10)
        .orElseGet(() -> "fallback");

You should be able to explain why "fallback" is produced and when the supplier runs.

Date, time, localization, and formatting

Java time API readiness

Can you do this?

• Choose between Period and Duration.
• Predict the result of plusDays, plusMonths, minusWeeks, and similar methods.
• Remember that date/time classes in java.time are immutable.
• Parse and format dates using a formatter.
• Understand locale-sensitive formatting at a practical level.
• Distinguish time zone from offset.
• Recognize daylight-saving-time scenarios as a reason to use appropriate zoned types.

Formatting and localization review

• Understand that formatting can vary by Locale.
• Recognize number, currency, percent, and date/time formatting patterns.
• Know that parsing can fail and may throw runtime parsing exceptions.
• Do not assume system default locale or time zone unless the code explicitly uses it.

I/O, NIO.2, and file operations

Path and Files readiness

• Create Path instances using modern APIs.
• Distinguish relative and absolute paths.
• Understand normalize, toAbsolutePath, and resolve.
• Use Files.exists, isDirectory, isRegularFile, size, copy, move, delete, and related operations conceptually.
• Know which file operations commonly require exception handling.
• Read and write text using buffered readers/writers.
• Read all lines or stream lines when appropriate.
• Traverse directories with stream-returning file methods.
• Close streams from file APIs, usually with try-with-resources.

Path example

Path base = Path.of("/app/logs");
Path file = base.resolve("today.log").normalize();

You should be able to explain the resulting path conceptually and why Path operations do not necessarily touch the file system until a Files operation is used.

I/O traps

Concurrency readiness

Core concurrency checklist

• Create tasks with Runnable and Callable.
• Understand basic Thread lifecycle concepts.
• Use executor services conceptually for task management.
• Distinguish execute from submit.
• Understand Future result retrieval and exception wrapping at a practical level.
• Identify race conditions caused by shared mutable state.
• Use synchronization to protect critical sections.
• Recognize visibility concerns and the role of volatile at a basic level.
• Understand atomic classes for simple thread-safe updates.
• Choose concurrent collections when multiple threads access shared data.
• Recognize risks of parallel streams with side effects.
• Identify deadlock clues: multiple locks acquired in inconsistent order.

Concurrency decision table

Race-condition cue

class Counter {
    private int count;
    void increment() { count++; }
    int get() { return count; }
}

You should be able to explain why count++ is not atomic and how simultaneous calls can lose updates.

JDBC readiness

JDBC checklist

• Understand the roles of Connection, Statement, PreparedStatement, and ResultSet.
• Use try-with-resources for JDBC resources.
• Distinguish queries from updates.
• Iterate through ResultSet using cursor movement.
• Retrieve column values by name or index.
• Understand transaction concepts: auto-commit, commit, rollback.
• Prefer PreparedStatement for parameterized SQL.
• Recognize SQL injection risk from string concatenation.
• Know that many JDBC operations throw checked SQLException.

Safer parameterized pattern

String sql = "select name from users where id = ?";
try (PreparedStatement ps = connection.prepareStatement(sql)) {
    ps.setInt(1, userId);
    try (ResultSet rs = ps.executeQuery()) {
        while (rs.next()) {
            System.out.println(rs.getString("name"));
        }
    }
}

You should be able to explain resource scope, parameter binding, and why this is safer than concatenating user input into SQL.

Modules and packaging

Module readiness

• Read a module-info.java file.
• Understand requires for module dependencies.
• Understand exports for making packages accessible to other modules.
• Distinguish exporting a package from merely having it inside a module.
• Recognize qualified exports at a conceptual level.
• Understand requires transitive as exposing a dependency to downstream modules.
• Understand service provider and service consumer declarations conceptually.
• Distinguish classpath-based access from module-path-based access.
• Diagnose errors caused by missing readability or non-exported packages.

Module descriptor example

module com.example.app {
    requires java.sql;
    exports com.example.api;
}

Readiness questions:

• What module dependency is declared?
• Which package is exported?
• Are non-exported packages accessible to other modules?
• Would code in another module automatically access internal packages?

Security, encapsulation, and maintainability

Practical secure-coding checks

Defensive copy prompt

If a class stores a mutable collection supplied by a caller, can you explain why this is risky?

class Team {
    private final List<String> names;

    Team(List<String> names) {
        this.names = new ArrayList<>(names);
    }

    List<String> names() {
        return List.copyOf(names);
    }
}

You should be able to explain how this protects internal state.

Scenario and decision-point checks

Use these prompts to test whether you can apply Java knowledge, not just recall syntax.

Common weak areas and exam traps

“Can you do this?” master checklist

Before final review, you should be able to complete these tasks without looking up syntax.

Language and syntax

• Predict output for code using operators, casts, wrappers, and strings.
• Identify whether code compiles when var is used.
• Trace loop execution with labels, break, and continue.
• Convert between traditional switch syntax and switch expression syntax.
• Explain numeric promotion in mixed-type arithmetic.

Object-oriented Java

• Trace constructor and initialization order.
• Determine which overloaded method is selected.
• Determine which overridden method executes at runtime.
• Explain why fields do not behave polymorphically like overridden methods.
• Validate interface, enum, record, and sealed-type declarations.

APIs and data handling

• Choose the right collection for ordering, uniqueness, keys, or sorting.
• Write or read generic method signatures with bounded type parameters.
• Match lambdas and method references to functional interfaces.
• Predict stream pipeline results, including short-circuiting.
• Use collectors for grouping, partitioning, joining, and map creation.
• Choose appropriate date/time types and formatters.

I/O, database, modules, and concurrency

• Read and write file examples using Path and Files.
• Identify required exception handling for I/O and JDBC operations.
• Read JDBC code using PreparedStatement and ResultSet.
• Explain transaction commit and rollback at a practical level.
• Read a module descriptor and determine accessibility.
• Identify race conditions and safer concurrency alternatives.

Final-week review checklist

Seven to five days out

• Revisit every missed practice question and classify the miss: syntax, API, concept, careless reading, or time pressure.
• Build a one-page list of personal traps, especially around generics, streams, exceptions, and OOP.
• Recode small examples for topics you keep missing.
• Review Java SE 17 language features that differ from older Java versions.
• Practice predicting output without an IDE.

Four to two days out

• Do mixed-topic timed practice.
• For each wrong answer, write the exact rule that would have prevented the mistake.
• Review method signatures for common functional interfaces and stream operations.
• Drill compile-time error recognition.
• Review try-with-resources, module descriptors, JDBC patterns, and concurrency examples.

Final day

• Stop trying to learn large new topics.
• Review your personal trap sheet.
• Re-read concise examples for switch expressions, records, sealed classes, streams, generics, and exceptions.
• Practice slowing down on questions that ask “which statements are true” or “what is the result.”
• Confirm you can explain why each incorrect option is incorrect.

Practical next step

Use this Exam Blueprint to choose your next practice set. Start with your weakest readiness area, answer mixed code-based questions, then review every miss until you can state the Java rule, predict the behavior, and recognize the trap in a new example.