1Z0-830 Syllabus — Learning Objectives by Topic

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

What’s covered

• Topic 1: Language Basics and Control Flow
• Topic 2: Classes, Objects, and OOP
• Topic 3: Interfaces, Enums, Records, and Sealed Types
• Topic 4: Generics
• Topic 5: Collections and Data Structures
• Topic 6: Lambdas and Functional Interfaces
• Topic 7: Streams and Optional
• Topic 8: Exceptions, Localization, and Core APIs
• Topic 9: Concurrency and Parallelism
• Topic 10: I/O, NIO.2, and Modules

Topic 1: Language Basics and Control Flow

Practice this topic →

1.1 Types, variables, and scope

• Differentiate primitives vs references and explain how assignment and passing parameters behave.
• Use variable scope rules (local, instance, static) and predict compile errors from shadowing and uninitialized locals.
• Explain type inference (var) rules and when explicit types are required.
• Given a snippet, determine whether implicit numeric promotion occurs and what the resulting type is.

1.2 Operators, strings, and common gotchas

• Apply operator precedence and associativity to evaluate expressions correctly.
• Predict behavior of ++/--, compound assignments, and short-circuit boolean operators.
• Explain String immutability and how concatenation differs from StringBuilder usage.
• Given a snippet, identify compile-time vs runtime errors caused by type mismatch or overflow.

1.3 Control flow (if/switch/loops)

• Write if/else logic and recognize unreachable code and missing return paths.
• Use switch statements/expressions (concept-level) and understand fall-through behavior when applicable.
• Predict loop execution for for/while/do-while, including break/continue and labeled control flow.
• Given a snippet, determine when a loop terminates and what values are produced.

Topic 2: Classes, Objects, and OOP

Practice this topic →

2.1 Class structure and encapsulation

• Use access modifiers (public/protected/package/private) and predict visibility across packages.
• Distinguish instance vs static members and determine correct access patterns.
• Design constructors and initialization blocks and predict initialization order.
• Given a snippet, identify compilation errors involving access, static context, and initialization.

2.2 Inheritance, polymorphism, and overriding

• Explain inheritance relationships and apply super/subclass method resolution rules.
• Differentiate overloading vs overriding and predict which method is invoked at runtime.
• Use abstract classes and methods and determine when a class must be declared abstract.
• Given a snippet, identify illegal overrides (incompatible return types, reduced visibility, thrown exceptions).

2.3 Object methods and equality

• Implement equals and hashCode consistently and explain why contracts matter for collections.
• Differentiate == vs equals for references and predict outcomes in common cases.
• Use toString effectively for debugging and predict default toString output behavior.
• Given a snippet, identify bugs caused by mutable keys or inconsistent equals/hashCode.

Topic 3: Interfaces, Enums, Records, and Sealed Types

Practice this topic →

3.1 Interfaces and default/static methods

• Define interfaces with abstract, default, and static methods and predict implementation requirements.
• Resolve method conflicts when multiple interfaces provide default methods (concept-level).
• Recognize functional interfaces and determine when lambdas are valid targets.
• Given a snippet, identify compilation errors involving interface method signatures and overrides.

3.2 Enums, nested classes, and encapsulation patterns

• Use enums with fields/methods and predict initialization and constructor behavior.
• Differentiate static nested, inner, local, and anonymous classes (concept-level) and their access rules.
• Recognize common use cases for nested classes: builders, callbacks, and encapsulating helpers.
• Given a snippet, determine which variables can be captured and which require effectively-final semantics.

3.3 Records and sealed classes (modern Java types)

• Explain what records provide (immutable data carriers, generated members) and their constraints.
• Customize record constructors and validation while preserving invariants.
• Explain sealed classes (restricted inheritance) and when they improve modeling and safety (concept-level).
• Given a snippet, identify illegal record/ sealed declarations and permitted subtype rules (concept-level).

Topic 4: Generics

Practice this topic →

4.1 Generic classes and methods

• Declare generic classes and methods and use type parameters correctly.
• Explain type erasure at a conceptual level and why some runtime checks are not possible.
• Given a snippet, predict when raw types cause warnings or unsafe operations.
• Recognize when to use generic methods vs class-level generics for API design.

4.2 Wildcards and bounds

• Differentiate upper-bounded, lower-bounded, and unbounded 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.
• Recognize wildcard capture issues and when helper methods are needed (concept-level).

4.3 Type inference and generic pitfalls

• Predict generic method type inference outcomes in common invocation patterns.
• Identify compilation failures caused by incompatible bounds or ambiguous inference.
• Explain why arrays and generics interact poorly and what safe alternatives exist (concept-level).
• Given a snippet, spot incorrect assumptions about generic types at runtime.

Topic 5: Collections and Data Structures

Practice this topic →

5.1 Core collection interfaces and implementations

• Differentiate List, Set, Queue, and Map and choose appropriate implementations (concept-level).
• Predict behavior differences of common implementations (ordering, duplicates, null handling) at a conceptual level.
• Use Map operations (put/get/compute/merge) correctly and predict results.
• Given a snippet, identify performance or correctness issues caused by choosing the wrong structure.

5.2 Sorting, comparators, and immutability

• Implement Comparable and Comparator correctly and predict sort order outcomes.
• Recognize stability and tie-breaking requirements in multi-key sorts.
• Explain mutability vs unmodifiable vs immutable collections at a conceptual level.
• Given a snippet, identify runtime failures from modifying unmodifiable collections.

5.3 Iteration, concurrent modification, and thread safety (concept-level)

• 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 when concurrent collections or synchronization is needed for shared access (concept-level).
• Given a snippet, identify whether a data structure is safe to share across threads.

Topic 6: Lambdas and Functional Interfaces

Practice this topic →

6.1 Lambda syntax and method references

• 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).
• Given a snippet, identify when a lambda captures variables and what must be effectively final.
• Recognize common compilation errors: ambiguous method references and incompatible functional targets.

6.2 Built-in functional interfaces and composition

• Choose appropriate functional interfaces (Predicate, Function, Consumer, Supplier) for a use case.
• Compose functions using default methods (andThen, compose, and/or/negate) and predict results.
• Use primitive specializations to avoid boxing overhead (concept-level).
• Given a snippet, determine which overload is chosen for functional interface parameters.

6.3 Functional programming patterns in Java

• Recognize when functional style improves clarity vs when it harms readability.
• Use immutability and pure functions to reduce side effects (concept-level).
• Given a snippet, identify side effects inside lambdas that can break correctness in parallel contexts (concept-level).
• Explain why effective error handling is needed when using functional chains.

Topic 7: Streams and Optional

Practice this topic →

7.1 Stream pipelines and laziness

• Differentiate intermediate vs terminal operations and explain stream laziness.
• Predict evaluation order for map/filter/flatMap and short-circuiting operations.
• Given a snippet, identify when a stream is consumed and why reuse causes errors.
• Recognize the impact of stateful operations (sorted/distinct) on performance (concept-level).

7.2 Collectors, reduction, and grouping

• Use reduce and collect appropriately and explain the role of identity/accumulator/combiner (concept-level).
• Use common collectors (toList, toSet, groupingBy, mapping, partitioningBy) and predict results.
• Given a snippet, identify incorrect collector usage that produces wrong types or wrong grouping.
• Recognize when parallel collection requires associative operations and safe combiners (concept-level).

7.3 Optional and null-safe design

• Use Optional correctly (map/flatMap/filter/orElseGet) and avoid common anti-patterns.
• Explain why Optional is not intended for fields/serialization in many designs (concept-level).
• Given a snippet, predict when orElse vs orElseGet evaluates eagerly vs lazily.
• Recognize how primitive streams and OptionalInt/OptionalLong/OptionalDouble reduce boxing.

Topic 8: Exceptions, Localization, and Core APIs

Practice this topic →

8.1 Exceptions and try-with-resources

• Differentiate checked vs unchecked exceptions and determine when throws declarations are required.
• Predict exception flow through try/catch/finally blocks, including suppressed exceptions.
• Use try-with-resources correctly and explain AutoCloseable behavior (concept-level).
• Given a snippet, identify unreachable catch blocks and incorrect exception handling.

8.2 Localization and formatting (concept-level)

• Use Locale and ResourceBundle at a conceptual level to support internationalization.
• Format numbers and dates using formatter APIs and recognize locale-sensitive output differences (concept-level).
• Given a scenario, choose where to store and load localized strings for a UI or report.
• Recognize common pitfalls: missing bundles, default locale surprises, and incorrect format patterns.

8.3 Core API usage patterns (immutability, equality, time)

• Explain immutability vs mutability in core types (String, wrapper types, date/time) at a conceptual level.
• Use java.time types at a conceptual level and avoid legacy date/time pitfalls.
• Given a snippet, identify incorrect assumptions about equality, hashing, or ordering.
• Recognize API misuse that causes subtle bugs (time zone assumptions, mutable shared state).

Topic 9: Concurrency and Parallelism

Practice this topic →

9.1 Threads and executors (concept-level)

• Explain why creating raw threads differs from using executors (lifecycle, pooling) at a conceptual level.
• Given a scenario, choose an executor approach for CPU-bound vs I/O-bound tasks (concept-level).
• Recognize thread lifecycle and interruption behavior (concept-level).
• Identify common concurrency hazards: shared mutable state and race conditions.

9.2 Synchronization, locks, and visibility (concept-level)

• Explain the purpose of synchronization and what it guarantees (mutual exclusion and visibility) at a conceptual level.
• Given a scenario, choose synchronization strategies to protect invariants (synchronized blocks, locks).
• Recognize deadlock risks and prevention patterns (lock ordering, timeouts) at a conceptual level.
• Identify when concurrent collections are preferable to manual synchronization (concept-level).

9.3 Futures, parallel streams, and safe parallelism (concept-level)

• Explain futures and asynchronous computation patterns at a conceptual level.
• Given a scenario, decide whether parallel streams improve performance or introduce risk.
• Recognize why side effects break parallel stream correctness and how to design pure operations (concept-level).
• Identify when to prefer explicit concurrency control vs implicit parallelism.

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

Practice this topic →

10.1 File I/O and path handling

• Use basic file I/O patterns and explain when buffering matters for performance (concept-level).
• Use Path/Files APIs at a conceptual level to read/write files and traverse directories.
• Given a snippet, identify resource leaks and fix them using try-with-resources.
• Recognize common filesystem pitfalls: relative paths, permissions, and platform differences.

10.2 NIO.2 features and common patterns (concept-level)

• Explain the difference between blocking I/O and non-blocking patterns at a conceptual level.
• Given a scenario, choose file watching, atomic moves, or directory traversal APIs where appropriate (concept-level).
• Recognize common I/O failure modes: partial writes, encoding issues, and concurrent access.
• Identify when to separate parsing/validation from I/O to simplify error handling.

10.3 Modules, packaging, and runtime basics (concept-level)

• Explain the purpose of the module system (module-info) and strong encapsulation at a conceptual level.
• Given a scenario, choose packaging strategies (JARs, modules) appropriate for deployment.
• Recognize common runtime issues: classpath conflicts, missing dependencies, and split packages (concept-level).
• Identify how to read and reason about simple stack traces to locate failures quickly.