Browse Exams — Mock Exams & Practice Tests

1Z0-829 Syllabus — Learning Objectives by Topic

Learning objectives for Java SE 17 Developer (1Z0-829), organized by topic with quick links to targeted practice.

Use this syllabus as your checklist for 1Z0‑829.

What’s covered

Topic 1: Java Fundamentals (Types, Operators, Control Flow)

Practice this topic →

1.1 Types, variables, and scope

  • Differentiate primitives vs reference types and predict assignment and parameter passing behavior.
  • Use variable scope rules (local, instance, static) and identify shadowing and lifetime issues.
  • Apply Java initialization rules and explain why local variables must be definitely assigned before use.
  • Use type inference (var) correctly and identify when an explicit type is required.
  • Given a snippet, determine when implicit numeric promotion occurs and what the resulting type is.
  • Explain autoboxing/unboxing and identify when it can cause NullPointerException or performance overhead.

1.2 Operators, conversions, and expression evaluation

  • Apply operator precedence and associativity to evaluate expressions correctly.
  • Predict the result of compound assignments (+=, -=, *=) and explain when implicit casts occur.
  • Differentiate == vs equals for references and predict outcomes with String pooling and boxed values.
  • Explain numeric conversion rules (widening vs narrowing) and identify where casts are required.
  • Predict behavior of ++/-- (pre vs post) and short-circuit boolean operators (&&, ||).
  • Use String concatenation rules and explain evaluation order with mixed primitives and objects.
  • Given a snippet, identify compile-time errors vs runtime exceptions caused by type mismatch or overflow.

1.3 Control flow: decisions and loops

  • Write correct if/else logic and identify unreachable code and missing return paths.
  • Use switch statements and switch expressions at a conceptual level, including fall-through rules when applicable.
  • Predict loop execution for for/while/do-while, including break/continue and labeled statements.
  • Given a snippet, determine when a loop terminates and what values are produced.
  • Use ternary operators correctly and identify type inference and promotion behavior within ternaries.
  • Recognize how short-circuit conditions can prevent exceptions (for example, null checks before dereference).

Topic 2: Methods, Encapsulation, and Arrays

Practice this topic →

2.1 Methods, parameters, and overloading

  • Define methods with correct signatures and return types and identify valid overloads.
  • Explain method overloading resolution (most specific match) and predict which overload is chosen.
  • Use varargs correctly and identify ambiguities when combined with overloading.
  • Differentiate pass-by-value for primitives vs references and predict effects of mutating referenced objects.
  • Given a snippet, identify compilation failures caused by ambiguous overloads or missing casts.
  • Use static methods vs instance methods correctly and recognize when a static import affects readability and ambiguity.

2.2 Encapsulation, access control, and initialization

  • Use access modifiers (public/protected/package/private) and predict visibility across packages.
  • Explain encapsulation and design getters/setters that preserve invariants.
  • Differentiate instance vs static fields and methods and predict behavior across instances.
  • Predict initialization order across static initializers, instance initializers, and constructors.
  • Explain the meaning of final for variables, fields, and references and identify what it does and does not guarantee.
  • Given a snippet, identify illegal access or initialization errors and select the correct fix.
  • Recognize common pitfalls with immutability (exposing internal mutable collections, defensive copies).

2.3 Arrays and common pitfalls

  • Declare, initialize, and access one-dimensional and multi-dimensional arrays correctly.
  • Explain array covariance and identify runtime failures that can result (ArrayStoreException).
  • Use Arrays utility methods at a conceptual level (sort, binarySearch, equals) and predict outcomes.
  • Given a snippet, identify off-by-one errors and ArrayIndexOutOfBoundsException causes.
  • Differentiate arrays from lists in terms of mutability, sizing, and API capabilities.
  • Recognize when to prefer collections over arrays for flexible APIs and generics safety.

Topic 3: Class Design, Inheritance, and Interfaces

Practice this topic →

3.1 Inheritance and constructors

  • Explain inheritance relationships and identify valid is-a vs has-a modeling choices.
  • Use super() and this() correctly and predict constructor chaining order.
  • Differentiate overriding vs hiding (static methods) and predict dispatch behavior.
  • Apply overriding rules (signature, return type covariance, access, and thrown exceptions).
  • Given a snippet, identify illegal overrides and select the correct fix.
  • Recognize how final affects inheritance (final classes, final methods) and design accordingly.

3.2 Polymorphism, casting, and abstract classes

  • Explain dynamic dispatch and predict which implementation runs when referenced by a superclass type.
  • Use casting safely and identify ClassCastException risks in polymorphic code.
  • Differentiate compile-time type vs runtime type and apply the rules to field/method access.
  • Define abstract classes and abstract methods and identify when a class must be abstract.
  • Given a snippet, determine which members are accessible via a reference type vs the runtime type.
  • Explain the impact of protected across packages and subclasses (concept-level) and identify common surprises.
  • Recognize common object method contracts (equals/hashCode/toString) and how inheritance can break them.

3.3 Interfaces and multiple inheritance of type

  • Define interfaces with abstract, default, and static methods and identify implementation requirements.
  • Resolve default method conflicts when implementing multiple interfaces (concept-level).
  • Identify functional interfaces and determine when lambdas are valid assignment targets.
  • Given a snippet, predict which default method is chosen and when you must override.
  • Explain interface constants and why they are implicitly public static final.
  • Recognize design trade-offs between abstract classes and interfaces for API evolution.

Topic 4: Modern Java SE 17 Features (Records, Sealed, Pattern Matching)

Practice this topic →

4.1 Records as data carriers

  • Explain what records provide (generated constructor/accessors/equals/hashCode/toString) and their constraints.
  • Customize record constructors to validate invariants while preserving immutability.
  • Differentiate record components from fields and predict accessibility and initialization behavior.
  • Given a snippet, identify illegal record declarations and required fixes.
  • Use records effectively for DTO-style modeling and recognize when a class is preferable.
  • Recognize how records interact with inheritance (cannot extend classes) and interfaces (can implement).

4.2 Sealed classes and restricted hierarchies

  • Explain sealed classes/interfaces and why they improve exhaustiveness and modeling safety (concept-level).
  • Use permits lists and identify valid permitted subtypes (sealed, non-sealed, final) at a conceptual level.
  • Given a snippet, identify illegal sealed hierarchy declarations and fixes.
  • Explain why sealed hierarchies pair well with pattern matching and switch exhaustiveness (concept-level).
  • Recognize how packaging and module boundaries can constrain sealed hierarchy design (concept-level).
  • Identify scenarios where sealed is inappropriate (open plugin ecosystems) vs appropriate (closed domain models).
  • Explain how sealing affects API evolution and versioning (concept-level).

4.3 Pattern matching and switch modernizations (concept-level)

  • Use pattern matching for instanceof at a conceptual level and identify scope of pattern variables.
  • Recognize flow scoping and when pattern variables are in scope vs out of scope.
  • Explain switch expressions vs switch statements and predict when a switch yields a value (concept-level).
  • Given a snippet, identify incorrect assumptions about fall-through or yield usage (concept-level).
  • Use text blocks at a conceptual level and recognize common escaping/indentation pitfalls.
  • Identify where var improves readability and where it harms clarity due to inferred types.

Topic 5: Generics and Type Safety

Practice this topic →

5.1 Generic classes and methods

  • Declare generic classes and methods and use type parameters consistently.
  • Explain why generics provide compile-time type safety and reduce casting.
  • Use generic methods vs class-level generics appropriately for API design.
  • Given a snippet, predict compilation outcomes for generic invocations with inferred types.
  • Recognize bounded type parameters (extends) and identify which types satisfy the bounds.
  • Explain type erasure at a conceptual level and identify what is and is not available at runtime.

5.2 Wildcards, bounds, and variance

  • Differentiate unbounded, upper-bounded, and lower-bounded wildcards and their use cases.
  • Apply PECS (producer extends, consumer super) to choose correct wildcard bounds.
  • Given a snippet, determine whether assignments compile when variance is involved.
  • Explain why List<Sub> is not a subtype of List<Super> and how wildcards address the need safely.
  • Identify when reads return Object due to lower bounds and how to safely cast or redesign the API.
  • Recognize wildcard capture and when helper methods are needed (concept-level).
  • Predict which elements can be added to collections with extends vs super wildcards and why.

5.3 Raw types, arrays, and common generic pitfalls

  • Identify raw type usage and explain why it leads to unsafe operations and warnings.
  • Explain why arrays and generics interact poorly and how heap pollution can occur (concept-level).
  • Given a snippet, detect heap pollution and the risk of ClassCastException at runtime.
  • Recognize when diamond inference works and when explicit type arguments are required.
  • Explain why you cannot create generic arrays directly (new T[]) and select safe alternatives.
  • Identify when @SafeVarargs is appropriate (concept-level) and what it does not guarantee.

Topic 6: Collections Framework (Lists, Sets, Maps)

Practice this topic →

6.1 Core collection interfaces and behaviors

  • Differentiate List, Set, Queue/Deque, and Map and choose appropriate implementations (concept-level).
  • Predict ordering, duplicates, and null-handling behavior for common implementations (concept-level).
  • Use Map operations (put/get/compute/merge/replace) correctly and predict results.
  • Explain equals/hashCode requirements for keys and how they affect Map and Set correctness.
  • Given a snippet, identify performance or correctness issues caused by choosing the wrong structure.
  • Recognize when to prefer EnumSet/EnumMap for enum keys (concept-level).

6.2 Sorting, comparisons, and mutability

  • Implement Comparable and Comparator correctly and predict sort order outcomes.
  • Recognize stability and tie-breaking requirements in multi-key sorts (concept-level).
  • Explain mutability vs unmodifiable vs immutable collections at a conceptual level.
  • Given a snippet, identify runtime failures from modifying unmodifiable collections.
  • Use factory methods (List.of, Set.of, Map.of) and predict their immutability and null-handling behavior.
  • Explain how equals affects Set membership and why inconsistent comparators can break sorted sets/maps.
  • Given a scenario, choose data structures that minimize bugs from accidental mutation and aliasing.

6.3 Iteration, views, and common traps

  • Use iterators safely and predict behavior when modifying collections during iteration.
  • Explain fail-fast iteration at a conceptual level and why it is not a synchronization guarantee.
  • Recognize common view pitfalls: subList backed by the original list, and Map keySet/values views.
  • Given a snippet, identify ConcurrentModificationException causes and prevention strategies.
  • Differentiate shallow vs deep copying and choose the correct approach for mutable element types.
  • Recognize when to use streams vs loops for clarity and performance (concept-level).

Topic 7: Lambdas, Functional Interfaces, Streams, and Optional

Practice this topic →

7.1 Lambdas, method references, and scope

  • Write lambdas with correct parameter types and return behavior and determine which forms compile.
  • Use method references (static, instance, constructor) and recognize resolution rules (concept-level).
  • Identify functional interfaces and determine compatibility with lambda shapes and checked exceptions.
  • Explain variable capture and effectively-final rules for lambdas and inner classes.
  • Given a snippet, identify compilation errors involving ambiguous method references or overloads.
  • Recognize common functional interfaces (Predicate, Function, Consumer, Supplier) and their primitive specializations.

7.2 Stream pipelines and core operations

  • Differentiate intermediate vs terminal operations and explain stream laziness.
  • Predict evaluation order for map/filter/flatMap and short-circuiting operations (findFirst, anyMatch).
  • Explain stateful operations (sorted, distinct) and their impact on performance (concept-level).
  • Given a snippet, identify when a stream is consumed and why reuse causes IllegalStateException.
  • Use primitive streams (IntStream/LongStream/DoubleStream) and explain boxing vs unboxing costs (concept-level).
  • Recognize when parallel streams are unsafe due to side effects or non-associative reductions (concept-level).
  • Given a scenario, choose between loops and streams based on readability, side effects, and performance.

7.3 Collectors, grouping, reduction, and Optional

  • Use reduce and collect appropriately and explain the role of identity/accumulator/combiner (concept-level).
  • Use common collectors (toList, toSet, joining, groupingBy, mapping, partitioningBy) and predict results.
  • Explain how groupingBy keys and downstream collectors affect the output Map types and values.
  • Use Optional correctly (map/flatMap/filter/orElseGet) and avoid common anti-patterns.
  • Given a snippet, predict when orElse vs orElseGet evaluates eagerly vs lazily.
  • Recognize when OptionalInt/OptionalLong/OptionalDouble reduce boxing and simplify null handling.

Topic 8: Exceptions, Assertions, and Robustness

Practice this topic →

8.1 Exception hierarchy and method contracts

  • Differentiate checked vs unchecked exceptions and determine when throws declarations are required.
  • Predict exception flow through nested calls and understand propagation vs handling.
  • Apply overriding rules for thrown exceptions (cannot throw broader checked exceptions).
  • Given a snippet, identify unreachable catch blocks and incorrect exception ordering.
  • Recognize common runtime exceptions (NullPointerException, IllegalArgumentException) and when to throw them.
  • Explain why exception messages and types matter for debugging and API design (concept-level).

8.2 try/catch/finally and try-with-resources

  • Use try/catch/finally correctly and predict control flow with returns in try/catch/finally blocks.
  • Use multi-catch and identify when exceptions are disjoint and when ordering matters.
  • Use try-with-resources correctly and explain AutoCloseable behavior and resource closing order (concept-level).
  • Predict suppressed exceptions behavior when both the try block and close() throw.
  • Given a snippet, identify compilation errors involving effectively-final resources or exception handling.
  • Recognize why exceptions in finally can mask earlier exceptions and how to avoid it.
  • Identify best practices for exception handling in streams and lambdas (wrapping, rethrowing, or redesign).

8.3 Assertions, debugging, and defensive programming

  • Explain what assertions are and when they are enabled/disabled at runtime (concept-level).
  • Given a snippet, determine whether an assert statement runs and what happens when it fails.
  • Recognize defensive programming patterns: validate inputs, fail fast, and preserve invariants.
  • Interpret stack traces to locate the root cause and identify the failing method and line (concept-level).
  • Identify common causes of NullPointerException and strategies to reduce them (Optional, guards, contracts).
  • Choose when to return empty collections vs null and explain implications for API consumers.

Topic 9: Concurrency and Thread Safety

Practice this topic →

9.1 Threads, tasks, and executor basics

  • Differentiate creating Threads vs using executors and explain why pooling matters (concept-level).
  • Use Runnable vs Callable at a conceptual level and identify which can return a value or throw checked exceptions.
  • Explain thread lifecycle and interruption behavior (concept-level).
  • Given a scenario, choose an executor strategy for CPU-bound vs I/O-bound tasks (concept-level).
  • Recognize the risk of blocking calls and how they can exhaust thread pools (concept-level).
  • Identify when to use Future-style results and timeouts to avoid indefinite blocking (concept-level).

9.2 Synchronization, visibility, and common hazards

  • Explain the purpose of synchronization and what it guarantees (mutual exclusion and visibility) at a conceptual level.
  • Identify race conditions, lost updates, and visibility problems in shared mutable state.
  • Given a snippet, choose a correct synchronization strategy (synchronized blocks, locks) to protect invariants.
  • Explain volatile at a conceptual level and identify what it does and does not guarantee.
  • Recognize deadlock risks and prevention patterns (lock ordering, timeouts) at a conceptual level.
  • Differentiate thread safety of common collections and when external synchronization is required (concept-level).
  • Explain why immutability and confinement reduce concurrency bugs more effectively than pervasive locking (concept-level).

9.3 Concurrent collections and parallel execution (concept-level)

  • Recognize common concurrent collections (ConcurrentHashMap, CopyOnWriteArrayList) and their trade-offs (concept-level).
  • Given a scenario, choose concurrent collections vs explicit synchronization based on contention and read/write patterns.
  • Explain atomic variables at a conceptual level and when they can replace synchronized blocks for simple counters.
  • Recognize why side effects break correctness in parallel streams and how to design pure operations (concept-level).
  • Identify when parallelism harms performance due to overhead or blocking I/O (concept-level).
  • Describe basic coordination primitives (latches/barriers) at a conceptual level and their use cases.

Topic 10: I/O, NIO.2, Modules, and Core APIs

Practice this topic →

10.1 File I/O and NIO.2 fundamentals

  • Use Path and Files APIs at a conceptual level to read/write files and traverse directories.
  • Differentiate relative vs absolute paths and identify common portability issues across OSes.
  • Use buffered I/O and explain why buffering improves performance for small reads/writes (concept-level).
  • Given a snippet, identify resource leaks and fix them using try-with-resources.
  • Recognize common I/O failures: permissions, missing paths, partial writes, and encoding issues.
  • Use directory traversal at a conceptual level and identify when to handle symlinks and cycles.

10.2 Core libraries: date/time, localization, and formatting (concept-level)

  • Use java.time types at a conceptual level and avoid legacy Date/Calendar pitfalls.
  • Differentiate Instant, LocalDate/LocalDateTime, and ZonedDateTime and choose the correct type for a scenario.
  • Format and parse dates/numbers at a conceptual level and recognize locale-sensitive behavior.
  • Use Locale and ResourceBundle at a conceptual level to support internationalization.
  • Given a scenario, identify time zone assumptions that can break correctness in reporting or scheduling.
  • Recognize immutability patterns in core types (String, wrappers, java.time) and avoid accidental mutation assumptions.
  • Interpret common formatting bugs caused by pattern misuse or default locale differences (concept-level).

10.3 Modules and runtime basics (concept-level)

  • Explain the purpose of the module system (module-info) and strong encapsulation at a conceptual level.
  • Differentiate requires, exports, and opens at a conceptual level and how they impact compilation and reflection.
  • Given a scenario, choose packaging strategies (classpath vs modulepath) appropriate for deployment.
  • Recognize common runtime failures: missing classes, version conflicts, and illegal reflective access (concept-level).
  • Identify how ServiceLoader-style discovery works at a conceptual level and when it is useful for plugins.
  • Explain how to read stack traces and dependency errors to locate the module or JAR causing the failure (concept-level).