Java Reference

Getting Started — what Java is, the JDK vs. the JRE, installing a JDK, javac/java, the single-file source launcher, JShell, the source-to-bytecode-to-JVM model, and the six-month release cadence / LTS / preview features.

Lexical Structure & Style — source-file structure, identifiers and reserved words, literals, the three comment forms, statements and blocks, and the standard code conventions.

Primitive Types & Variables — the eight primitives and their ranges, literals, final constants, var local-variable type inference, widening/narrowing conversions, and integer overflow.

Operators & Expressions — arithmetic, relational, logical (short-circuit), bitwise and shift operators, the conditional operator, instanceof, and operator precedence.

Strings & Text — String immutability and the string pool, == vs. equals, the common methods, StringBuilder, text blocks, and string formatting.

Control Flow — if/else, the loop forms, break/continue and labels, switch statements, and arrow-form switch expressions.

Arrays — declaration and allocation, iteration, multidimensional and jagged arrays, java.util.Arrays, and varargs.

Classes & Objects — fields, methods, constructors and constructor chaining, this, object creation and garbage collection, static members, and access modifiers.

Methods & Parameters — return values, pass-by-value, overloading and overload resolution, varargs, recursion, and the utility APIs.

Inheritance & Polymorphism — extends and super, overriding vs. overloading, dynamic dispatch, abstract and final, and the java.lang.Object methods.

Interfaces — default/static/private interface methods, functional interfaces, Comparable vs. Comparator, and default-method resolution.

Records & Sealed Classes — record components and the compact constructor, generated members, and sealed/permits/non-sealed hierarchies.

Enums — enum constants, fields and methods, constant-specific bodies, and EnumSet/EnumMap.

Nested & Anonymous Classes — static nested, inner, local, and anonymous classes, and when each still fits.

Lambdas & Method References — lambda syntax and target typing, effectively-final capture, the four method-reference kinds, and lambda vs. anonymous class.

Generics — generic classes and methods, bounded type parameters, wildcards and the PECS rule, and type erasure.

Pattern Matching — pattern matching for instanceof, type patterns in switch, record deconstruction patterns, and guarded patterns.

Annotations & Reflection — the built-in annotations, declaring a custom annotation with meta-annotations, and reading members at runtime via java.lang.reflect.

Exceptions — the Throwable hierarchy, checked vs. unchecked, try/catch/finally, multi-catch, try-with-resources, custom exceptions, and exception chaining.

Optional — modelling the absence of a value, the transform and unwrap methods, the primitive variants, and the anti-patterns.

Collections Framework — the interface hierarchy and implementations, iterators, the utility class and factory methods, sequenced collections, and the equals/hashCode contract.

Streams & Collectors — the lazy pipeline, the intermediate and terminal operations, Collectors, primitive and parallel streams.

Functional Programming — the java.util.function interfaces, composition, higher-order functions and currying, and refactoring imperative loops.

Numbers & Math — wrapper classes and autoboxing pitfalls, Math, BigInteger/BigDecimal, parsing and formatting, and floating-point caveats.

Dates & Times — the java.time types, Duration/Period, formatting and parsing, time zones, and legacy interop.

I/O & Files — java.io streams and readers, Scanner, and the NIO.2 Path/Files API.

Regular Expressions — Pattern and Matcher, groups and named groups, flags, the String conveniences, and backtracking pitfalls.

Concurrency Basics — creating threads, the thread lifecycle, synchronized and volatile, the Java Memory Model, and the classic hazards.

High-Level Concurrency — executors and thread pools, Future and CompletableFuture, the concurrent collections and atomics, and the locks and synchronizers.

Virtual Threads — platform vs. virtual threads, the creation APIs, carrier threads and pinning, and a note on structured concurrency.

Packages & Modules — packages and imports, the four access levels, and the Java Platform Module System (module-info.java, requires/exports/opens).

Build & Tooling — the core JDK tools, a technology-neutral tour of Maven and Gradle, the common build plugins (testing, coverage, static analysis, SonarQube, reporting, publishing to Maven Central), and generating API docs with javadoc.

Javadoc — doc comments, block and inline tags, package and module documentation, documentation inheritance, and worked examples.

Unit Testing with JUnit 5 & Mockito — JUnit Jupiter (assertions, the lifecycle, parameterized tests) and Mockito (mock/when/verify, @Mock/@InjectMocks, spies and captors).

Cheat Sheet (PDF) — a single-page, printable summary of everything in this section, with a downloadable PDF.