1Z0-829 Syllabus — Learning Objectives by Topic

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

What’s covered

• Topic 1: Java Fundamentals (Types, Operators, Control Flow)
• Topic 2: Methods, Encapsulation, and Arrays
• Topic 3: Class Design, Inheritance, and Interfaces
• Topic 4: Modern Java SE 17 Features (Records, Sealed, Pattern Matching)
• Topic 5: Generics and Type Safety
• Topic 6: Collections Framework (Lists, Sets, Maps)
• Topic 7: Lambdas, Functional Interfaces, Streams, and Optional
• Topic 8: Exceptions, Assertions, and Robustness
• Topic 9: Concurrency and Thread Safety
• Topic 10: I/O, NIO.2, Modules, and Core APIs

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).