Glossary

Definitions of the Java language and API terms used across the course. It grows as new modules are added. Use the sidebar search (Ctrl/⌘ + K) to jump straight to a term; each entry links to the lessons that cover it. For the project's own vocabulary (Module, Lesson, Mini-Exam…), see Conventions.

A

assertion (test)

A check in a test that fails it when the condition is false — e.g. JUnit's assertEquals, assertThrows, assertAll, or AssertJ's fluent assertThat. Contrast an assumption, which skips a test rather than failing it.

Covered in:JUnit 5 Essentials

AssertJ

A fluent assertion library: one assertThat(subject) chained into readable, type-aware checks (.isEqualTo, .containsExactly, .hasMessageContaining) with rich failure messages. An alternative to JUnit's Assertions.

Covered in:Readable Assertions & Deterministic Tests

abstract class

A class declared abstract that cannot be instantiated and may declare abstract (body-less) methods. Unlike an interface it can hold instance fields, constructors, and state; a class extends only one. Choose it for a shared base with state; choose an interface for a capability.

Covered in:Interfaces

annotation

A @-prefixed marker (declared with @interface) attaching metadata to code. Built-ins include @Override, @FunctionalInterface, @Deprecated, @SuppressWarnings. Only RUNTIME-retained annotations are visible to reflection — how frameworks like JUnit find @Test.

Covered in:Annotations

anonymous class

A nameless local class declared and instantiated in one expression (new Runnable(){…}), typically to implement an interface or extend a class on the spot. Captures only effectively-final locals; for a functional interface a lambda is usually lighter.

Covered in:Nested & Inner Classes

array

A fixed-length, ordered container of a single type. length is a field; elements default to 0/false/null. Arrays are reference objects and are covariant. The {…} initializer works only in a declaration; use new T[]{…} elsewhere.

Covered in:Arrays

array covariance

The rule that S[] is a subtype of T[] when S is a subtype of T (e.g. String[] is an Object[]). It is unsound: storing the wrong element type compiles but throws ArrayStoreException at runtime. Generics are invariant to avoid this.

Covered in:Arrays

atomic

A java.util.concurrent.atomic class (AtomicInteger, AtomicLong, AtomicReference) offering lock-free, thread-safe updates (incrementAndGet, compareAndSet). Needed because i++ on a plain or volatile field is not atomic.

Covered in:Executors & Concurrent Utilities

AutoCloseable

The interface (close()) whose implementers can be managed by try-with-resources, which calls close() automatically. Closeable (I/O) extends it. Resources close in reverse declaration order.

Covered in:try-with-resources & Custom Exceptions

autoboxing / unboxing

Automatic conversion between a primitive and its wrapper class — e.g. int ↔ Integer. Autoboxing wraps a primitive into its object form; unboxing extracts the primitive back out.

Covered in:Operators & Expressions, Numeric Values — Wrappers, Math & BigDecimal

automatic module

A plain (non-modular) JAR placed on the module path. It gets a name (from the Automatic-Module-Name manifest header, else derived from the filename), exports all its packages, and reads all other modules — a migration bridge until the JAR is properly modularized.

Covered in:Services & Migration

AI assistant

An LLM-based tool (e.g. a coding assistant) that generates or edits code from natural-language prompts. A fast but fallible drafter — its output must be reviewed and verified, not trusted.

Covered in:Generating Code & Tests with AI

auto-waiting

Playwright's behaviour of waiting for an element to be actionable (present, visible, stable, enabled) before each action, removing most manual waits and a major source of UI flakiness.

Covered in:Playwright for Java

B

BDD (behaviour-driven development)

Expressing tests as plain-language scenarios (Given/When/Then) readable by non-developers. In Java, Cucumber runs Gherkin .feature files glued to step-definition methods. Valuable for stakeholder collaboration; overhead when developer-only.

Covered in:BDD with Cucumber

build lifecycle (Maven)

Maven's ordered list of phases (validate → compile → test → package → verify → install → deploy). Invoking a phase runs every preceding phase, so mvn package also compiles and tests.

Covered in:Maven

builder pattern

A creational idiom: a fluent Builder collects required + optional fields (with defaults) and build() produces an (ideally immutable) result. Tames telescoping constructors when there are many optional parameters.

Covered in:Object Contracts & Common Patterns

BigDecimal

An immutable, arbitrary-precision decimal number (java.math) for exact base-10 arithmetic such as money. Build it from a String (new BigDecimal("0.1")) — the double constructor captures the binary approximation. equals is scale-sensitive (1.0 ≠ 1.00); use compareTo for value equality.

Covered in:Numeric Values — Wrappers, Math & BigDecimal

BigInteger

An immutable, arbitrary-precision integer (java.math) for values beyond long's range. Every operation returns a new object.

Covered in:Numeric Values — Wrappers, Math & BigDecimal

bounded type parameter

A type parameter constrained with extends: <T extends Number> (also multiple bounds joined with &, e.g. <T extends Number & Comparable<T>>). There is no super bound on a type parameter — only on wildcards.

Covered in:Generics

boolean

The primitive type holding exactly true or false. Java has no truthiness — if requires a boolean, not an int or reference. Its wrapper is Boolean; unboxing a null Boolean in a condition throws an NPE. Boolean.parseBoolean returns true only for "true" (case-insensitive).

Covered in:Boolean & Conditions

buffered stream

A decorator (BufferedReader/BufferedWriter/BufferedInputStream/BufferedOutputStream) that reads/writes in chunks to cut system calls. BufferedReader adds readLine(). Wrap a raw stream: new BufferedReader(new FileReader(...)).

Covered in:I/O Streams & Readers

byte stream

An I/O stream of raw bytes — InputStream/OutputStream and subclasses (FileInputStream, …). Use for binary data; for text use a character stream. Bridge with InputStreamReader/OutputStreamWriter.

Covered in:I/O Streams & Readers

bytecode

The platform-independent instruction set stored in a .class file, produced by javac and executed by the JVM. The basis of Java's "write once, run anywhere".

Covered in:How a Java Program Is Structured & Run

build artifact

A file produced (and usually published) by a CI job for later use — a JAR, a test report, a coverage HTML, a UI screenshot/video. Uploaded so failures can be diagnosed from the CI run itself.

Covered in:Reports, Artifacts & Test Selection

build matrix

A CI strategy that runs the same job across combinations of parameters (JDK versions, OSes, browsers) in parallel, validating them all from one workflow definition.

Covered in:Pipelines with GitHub Actions

C

class loader

The component that loads classes lazily on first use via a delegating chain (bootstrap → platform → application/classpath). Failures surface as ClassNotFoundException, NoClassDefFoundError, or ExceptionInInitializerError.

Covered in:JVM Awareness

connection pool

A managed, bounded set of reusable database connections (e.g. HikariCP). Avoids the high per-request cost of opening a connection; with a pool, close() returns the connection rather than physically closing it.

Covered in:Transactions & Pooling

Cucumber

The dominant Java BDD framework: runs Gherkin scenarios against @Given/@When/@Then step-definition methods, on the JUnit platform.

Covered in:BDD with Cucumber

Callable

A task interface with V call() throws Exception — returns a value and may throw checked exceptions (unlike Runnable). Submitted to an executor, it yields a Future.

Covered in:Threads & Tasks

capturing group

A parenthesized part of a regex whose matched text is captured and numbered (group(1), group(2), …; group(0) is the whole match). Named groups use (?<name>…).

Covered in:Regular Expressions

character stream

An I/O stream of characters (text) — Reader/Writer and subclasses (FileReader, BufferedReader, …). Encoding-aware, unlike a byte stream. Note read() returns an int and -1 at end of stream.

Covered in:I/O Streams & Readers

checked exception

An Exception that is not a RuntimeException, subject to the handle-or-declare rule: a method must catch it or list it in throws, or it won't compile. Examples: IOException, SQLException. Contrast with unchecked exception.

Covered in:Exceptions & the Hierarchy

class file

A .class file holding the compiled bytecode for one type. Its name matches the type name (Greeting → Greeting.class).

Covered in:How a Java Program Is Structured & Run

Class object

The runtime java.lang.Class<T> describing a loaded type, obtained via T.class, obj.getClass(), or Class.forName(name). The entry point for reflection: getDeclaredFields/Methods, getConstructor, annotations, etc.

Covered in:Reflection (basics)

classpath

The list of locations (directories and JARs) where the compiler and JVM look up types.

Covered in:How a Java Program Is Structured & Run

Collections Framework

The unified java.util hierarchy of Collection (List/Set/Queue/Deque) and Map, with implementations (ArrayList, HashSet, HashMap, ArrayDeque, Tree*, Linked*) and helpers. Map is not a Collection.

Covered in:Core Collections

Collector

A recipe (java.util.stream.Collectors) for accumulating a stream into a container or summary: toList/toSet/toMap/joining, plus groupingBy/partitioningBy with downstream collectors (counting, mapping, averagingDouble). toMap needs a merge function for duplicate keys.

Covered in:Reduction & Collectors

Comparable

An interface giving a type its natural ordering via int compareTo(T o) (negative/zero/positive). Used by Collections.sort, TreeSet/TreeMap, etc. Compare numbers with Integer.compare, not subtraction (overflow). Contrast with Comparator.

Covered in:Comparison & Sorting

Comparator

An external, swappable ordering via int compare(T a, T b). Build with comparing/comparingInt, chain with thenComparing, flip with reversed, and handle nulls with nullsFirst/nullsLast. A TreeSet/TreeMap treats compare == 0 as equality.

Covered in:Comparison & Sorting

compact constructor

A record's constructor written without a parameter list (Range { … }). It runs validation/ normalization by assigning to the parameters; the compiler copies them into the final fields afterward. Writing this.field = … inside it is a compile error.

Covered in:Records

CompletableFuture

A composable Future (java.util.concurrent). Start with supplyAsync/runAsync; chain with thenApply (map), thenCompose (flatMap), thenCombine (merge two); recover with exceptionally/handle. join() throws an unchecked CompletionException.

Covered in:CompletableFuture

concurrent collection

A thread-safe java.util.concurrent collection (ConcurrentHashMap, CopyOnWriteArrayList, ConcurrentLinkedQueue, …) usable without external locking; its iterators are weakly consistent and never throw ConcurrentModificationException.

Covered in:Executors & Concurrent Utilities

constructor

A special member, named after the class with no return type, that initializes a new object. Declaring any constructor removes the compiler's default no-arg one. A this(...)/super(...) call must be its first statement.

Covered in:Classes & Objects

code review

A person reading a change line by line to judge correctness, design, and risk before it merges. The primary human guardrail around AI-generated code — you can only review what you understand.

Covered in:Critically Reviewing AI Output

continuous integration (CI)

The practice of automatically building and testing every change, early and often, so integration problems surface in minutes rather than at release. Implemented with tools like GitHub Actions.

Covered in:Pipelines with GitHub Actions

contract testing

Verifying that two services agree on their interface by testing each side independently against a shared, machine-checkable contract — catching interface mismatches without full end-to-end runs.

Covered in:Contract Testing

D

defensive copy

Copying a mutable input on the way into a type (constructor) and a mutable field on the way out (accessor), so internal state can't be mutated through a shared reference. Essential to genuine immutability; List.copyOf does both.

Covered in:Immutability & Defensive Copying

dependency scope (Maven)

Controls which classpath a dependency is on and whether it's packaged: compile (default, all), test (test classpath only — JUnit/Mockito), provided (compile only), runtime (run but not compile — JDBC drivers).

Covered in:Maven

deterministic test

A test that yields the same result on every run and machine. Achieved by removing hidden inputs — inject a fixed Clock, seed randomness, pin locale/time zone — instead of reading wall-clock time or Math.random() directly.

Covered in:Readable Assertions & Deterministic Tests

dynamic test

A test generated at runtime via @TestFactory returning DynamicTests. Use when cases can't be expressed by a declarative parameterized source.

Covered in:Parameterized & Structured Tests

dangling else

The ambiguity where an else could attach to either of two nested ifs. Java's rule: an else binds to the nearest unmatched if, regardless of indentation. Add braces to redirect it.

Covered in:Conditionals — if / else

DateTimeFormatter

The immutable, thread-safe formatter/parser for java.time types. Use ofPattern(...) for custom patterns; letters are case-sensitive (MM month vs mm minute, HH 24-hour vs hh 12-hour). A mismatch throws DateTimeParseException.

Covered in:Dates & Times — the java.time API

default method

An interface method with a body, declared default. Implementing classes inherit it unless they override it; conflicting defaults from two interfaces must be overridden (resolve via Iface.super.m()). A default cannot be static, final, or abstract.

Covered in:Interfaces

definite assignment

The rule that a local variable must be provably assigned a value before it is read; otherwise the code does not compile.

Covered in:Types, Variables & var

Deque

A double-ended queue (java.util) supporting insert/remove at both ends; usable as a stack (push/pop/peek) or FIFO queue. ArrayDeque is the common implementation; it is a SequencedCollection.

Covered in:Core Collections

Duration

A time-based amount of time (java.time) measured in seconds and nanoseconds (also exposes hours/minutes). Use it with time-bearing types (LocalTime, Instant, LocalDateTime); contrast with Period.

Covered in:Dates & Times — the java.time API

Docker

A platform that packages an app and its dependencies as a reproducible image and runs it as a container, so it behaves the same on a laptop and a CI runner. The basis for Testcontainers.

Covered in:Docker & Testcontainers

Docker image

An immutable, layered package of an application plus everything it needs (OS, runtime, config). A running instance of an image is a container; images are pulled from a registry (e.g. Docker Hub).

Covered in:Docker & Testcontainers

E

equals/hashCode contract

The rules linking the two methods: if a.equals(b) then a.hashCode() == b.hashCode() (the reverse isn't required). equals must be reflexive, symmetric, transitive, and consistent. Break it and hash-based collections lose elements; use the same fields in both.

Covered in:Object Contracts & Common Patterns

enhanced for (for-each)

The for (T x : iterable) loop that visits each element of an array or Iterable without an index. The loop variable is a copy of each element reference, so assigning to it does not modify the source. Mutating the underlying collection during the loop throws ConcurrentModificationException.

Covered in:Loops & Branching

enum

A type with a fixed set of named constant instances (each a singleton). Constants are listed first; name() gives the identifier and ordinal() the 0-based position. valueOf is case-sensitive (throws IllegalArgumentException on a miss). Enums can have fields, a private constructor, methods, per-constant bodies, and implement interfaces — but cannot extend a class.

Covered in:Enums

ExecutorService

A managed pool that runs submitted tasks (Executors.newFixedThreadPool, …). submit returns a Future; execute returns void; invokeAll runs many. You must shutdown() it or the JVM may not exit; submitting after shutdown throws RejectedExecutionException.

Covered in:Executors & Concurrent Utilities

exports (module directive)

A module-info directive making a package accessible (compile-time + runtime) to other modules: exports com.acme.api;. A qualified form exports P to M1, M2; limits it to named modules. Non-exported packages are strongly encapsulated. Distinct from opens (reflection).

Covered in:Modules Basics

explicit wait

A Selenium WebDriverWait that polls until a specific condition on a specific element holds (or times out). Far more reliable than a fixed Thread.sleep; the preferred Selenium wait strategy.

Covered in:Selenium WebDriver Basics

F

factory method

A static method that creates instances with a meaningful name, the option to cache or return a subtype, and decoupling from the concrete class (Optional.of, List.of). Can't be subclassed if the constructor is private.

Covered in:Object Contracts & Common Patterns

FIRST principles

Qualities of good unit tests: Fast, Isolated/Independent, Repeatable, Self-validating, Timely. Flakiness is a violation of Isolated/Repeatable.

Covered in:Readable Assertions & Deterministic Tests

fixture

The known, controlled state a test runs against (objects, data, a seeded database). Built reusably with test data builders and object mothers, and reset or recreated between tests for isolation.

Covered in:Data-Driven Tests & Fixtures

flaky test

A test that passes and fails without code changes. Causes: time, unseeded randomness, async waited on with sleep, shared/ordering state, real network. Fix the root cause; don't mask it with blanket retries.

Covered in:Parallelism, Flakiness & Reporting, Stable UI Tests

fall-through

In a traditional switch statement, execution continuing from a matched case into the following cases because there is no break. The arrow form (case L ->) and switch expressions never fall through.

Covered in:The switch — Statements & Expressions

Files

The java.nio.file utility of static methods that actually touch the filesystem: readString/ writeString, readAllLines, copy/move/delete/deleteIfExists, createDirectories, exists/size, and the walk/list/lines streams (which must be closed). Most throw IOException.

Covered in:NIO.2 — Path & Files

finally

A block after try/catch that always runs — on normal completion, exception, or return — except when System.exit() is called. A return/throw inside finally overrides and silently swallows what try/catch produced, so avoid it.

Covered in:try / catch / finally

fully qualified name (FQN / FQCN)

A type's complete name including its package — e.g. java.util.List (FQCN = fully qualified class name). You can always use the fully qualified name instead of an import.

Covered in:How a Java Program Is Structured & Run

functional interface

An interface with exactly one abstract method (the SAM), so it can be implemented by a lambda or method reference. default/static/private and Object methods don't count. @FunctionalInterface enforces the rule.

Covered in:Lambdas & Functional Interfaces

Future

A handle to a result that may not be ready yet. get() blocks until done and wraps a task exception in ExecutionException (getCause() for the original); get(timeout, unit) may throw TimeoutException. See CompletableFuture for a composable version.

Covered in:Threads & Tasks

G

garbage collection (GC)

Automatic reclamation of objects no longer reachable from a GC root (live stacks, statics). There is no manual free; setting a reference to null helps only if it was the last one. Most JVMs use generational collection ("most objects die young").

Covered in:JVM Awareness

Gherkin

The plain-language, Given/When/Then format for Cucumber .feature files. A Scenario Outline with an Examples table is its data-driven form.

Covered in:BDD with Cucumber

Gradle

A build tool using a programmable Groovy/Kotlin DSL and a task graph (vs Maven's XML + fixed lifecycle). Same group:artifact:version coordinates; configurations (implementation/api/ testImplementation) map roughly onto Maven scopes. Run via the wrapper (./gradlew).

Covered in:Gradle (basics)

generics

Parameterizing types and methods over a type (List<T>, <T> T first(...)) for compile-time type safety without casts. Use bounds and wildcards to flex; remember type erasure removes the type argument at runtime.

Covered in:Generics

GitHub Actions

GitHub's CI/CD system: declarative YAML workflows in .github/workflows/ triggered by events (push, pull_request, schedule) that run jobs of steps on fresh runners.

Covered in:Pipelines with GitHub Actions

guardrail

A control that keeps AI-assisted changes safe: human review, independent test oracles, edge-case coverage, determinism, CI gates, small diffs. The course's own disciplines aimed at machine output.

Covered in:Guardrails — When Not to Trust AI

H

H2

A pure-Java relational database that runs in-process (often in-memory). Needs no install or Docker, so it's ideal for fast, self-contained DB tests — but it's a different engine from production, so vendor-specific SQL/behaviour can diverge.

Covered in:Test Databases

heap

The shared memory region where all objects and arrays live, managed by the garbage collector. Exhausting it throws OutOfMemoryError: Java heap space. Contrast the per-thread stack.

Covered in:JVM Awareness

hiding

When a subclass declares a static method or a field with the same name as one in its superclass. Unlike overriding, hiding is resolved statically by the reference's compile-time type, not the object's runtime type. Fields and static methods hide; instance methods override.

Covered in:Inheritance & Polymorphism

hallucination

An LLM confidently producing something that doesn't exist — most dangerously a hallucinated API (an invented method, class, or parameter). Caught by compiling and checking the documentation.

Covered in:Critically Reviewing AI Output

headless browser

A browser run without a visible window — faster and required on most CI agents. Run headed locally to debug, headless in CI, knowing a few bugs reproduce in only one mode.

Covered in:Stable UI Tests

HttpClient

The reusable, thread-safe sender in the JDK's java.net.http API (since Java 11). Build one and share it; it manages a connection pool and supports synchronous send and asynchronous sendAsync.

Covered in:HTTP with java.net.http

HttpRequest

An immutable, builder-constructed HTTP request in java.net.http — URI, method, headers, and an optional body supplied by a BodyPublisher.

Covered in:HTTP with java.net.http

HttpResponse

The result of an HttpClient send in java.net.http: statusCode(), headers(), and a body() decoded by a BodyHandler (e.g. ofString()). The client does not throw on 4xx/5xx.

Covered in:HTTP with java.net.http

I

idempotent test

A (database) test that produces the same result however often it runs, by starting from a known clean state — fresh schema, transaction rollback, or explicit cleanup — and never depending on data left by other tests.

Covered in:Database Testing & Assertions

isolation level

How much concurrent transactions see of each other's changes: READ_UNCOMMITTED, READ_COMMITTED (common default), REPEATABLE_READ, SERIALIZABLE. Higher levels prevent more anomalies (dirty, non-repeatable, phantom reads) at the cost of concurrency.

Covered in:Transactions & Pooling

IEEE 754

The floating-point standard that Java's float and double follow. It defines signed zero, Infinity, and NaN, and explains rounding surprises like 0.1 + 0.2 != 0.3.

Covered in:Types, Variables & var

immutability / immutable

An object whose state cannot change after construction. String, the wrapper classes, and the java.time types are immutable — methods that appear to modify them return a new object.

Covered in:Text — Strings & Text Blocks, Immutability & Defensive Copying

import

A declaration that lets you refer to a type by its simple name. Never strictly required — you can always use a type's fully qualified name instead.

Covered in:How a Java Program Is Structured & Run

inheritance

A subclass acquiring the accessible members of a superclass via extends. Java allows single class inheritance (one direct superclass) but multiple interface inheritance of type.

Covered in:Inheritance & Polymorphism

initialization order

The fixed order in which a class and object initialize: static fields and static blocks once at class load (source order), then for each object the instance fields and instance blocks (source order), then the constructor body.

Covered in:Classes & Objects

inner class

A non-static nested class. Each instance is bound to an enclosing instance (outer.new Inner()) and can access its members, including private ones. It cannot declare non-constant static members. Contrast with a static nested class.

Covered in:Nested & Inner Classes

Instant

A single point on the UTC timeline (java.time), counted from the 1970 epoch. Time-zone independent; combine with a ZoneId to get a ZonedDateTime. Created via Instant.now() / Instant.ofEpoch….

Covered in:Dates & Times — the java.time API

Integer cache

The JVM caches boxed Integer values from -128 to 127, so == on two boxed values in that range is true (same cached object). Outside the range they are distinct objects, so == is false — use .equals() to compare values.

Covered in:Operators & Expressions, Numeric Values — Wrappers, Math & BigDecimal

integer overflow

int/long arithmetic that exceeds the type's range wraps around silently (no error) — e.g. Integer.MAX_VALUE + 1 becomes Integer.MIN_VALUE. The Math.*Exact methods (addExact, …) throw ArithmeticException instead.

Covered in:Numeric Values — Wrappers, Math & BigDecimal

intermediate operation

A lazy stream operation that returns another Stream (filter, map, sorted, distinct, limit, flatMap, peek). Nothing runs until a terminal operation triggers the pipeline.

Covered in:Streams Basics

interface

A reference type defining a contract. Methods are implicitly public abstract (unless default, static, or private); fields are implicitly public static final constants. A class may implements many. No constructors or instance fields. See abstract class for the comparison.

Covered in:Interfaces

I/O stream

The java.io abstraction for sequential data — a byte stream (InputStream/OutputStream) or character stream (Reader/Writer). Distinct from java.util.stream.Stream. read() returns an int, -1 at end of stream.

Covered in:I/O Streams & Readers

J

JDBC

The JDK's low-level database API (java.sql): a Connection creates a Statement/ PreparedStatement, which yields a ResultSet. The foundation under higher-level tools (JPA, Spring Data). Always close resources (try-with-resources).

Covered in:JDBC Core

JUnit

The standard Java testing framework. JUnit 5 (Jupiter) provides @Test, lifecycle annotations (@BeforeEach/@BeforeAll/…), Assertions (incl. assertThrows), assumptions, parameterized and nested tests, and the platform other tools (Cucumber) run on.

Covered in:JUnit 5 Essentials

java (launcher)

The command that starts the JVM to run a program (java Greeting), or runs a single source file directly (java Greeting.java). You pass the class name, not the .class file.

Covered in:How a Java Program Is Structured & Run

javac

The Java compiler: turns .java source into .class bytecode.

Covered in:How a Java Program Is Structured & Run

JDK (Java Development Kit)

The full toolkit for developing Java — compiler (javac), launcher (java), and other tools — which bundles a runtime (JRE).

Covered in:How a Java Program Is Structured & Run

JEP (JDK Enhancement Proposal)

The document/process describing a change to the JDK. Features are often referenced by their JEP number — e.g. JEP 330 (single-file source launch), JEP 378 (text blocks).

Covered in:How a Java Program Is Structured & Run

JIT (just-in-time) compiler

The JVM component that compiles frequently executed ("hot") bytecode to native machine code at runtime, after initial interpretation — combining portability with near-native speed.

Covered in:How a Java Program Is Structured & Run

JRE (Java Runtime Environment)

What's needed to run Java programs: the JVM plus the core libraries. No compiler.

Covered in:How a Java Program Is Structured & Run

JVM (Java Virtual Machine)

The runtime engine that loads and executes bytecode, isolating your program from the underlying OS and hardware.

Covered in:How a Java Program Is Structured & Run

Jackson

The de-facto-standard Java JSON library. Its ObjectMapper deserializes (readValue) and serializes (writeValueAsString) POJOs/records by field name; it fails on unknown properties by default.

Covered in:JSON Binding — Jackson & Gson

JSON

JavaScript Object Notation — the lingua franca of web APIs. Java has no built-in binder, so projects use Jackson or Gson to map JSON text to objects and back.

Covered in:JSON Binding — Jackson & Gson

JSON-path

An expression language for selecting values inside a JSON document (e.g. items[0].name). Used by RestAssured to assert on response bodies without manual parsing.

Covered in:REST Testing with RestAssured

JSON tree

A dynamic, in-memory representation of JSON (Jackson's JsonNode) navigated by key/index instead of bound to a typed class. Preferred when the shape is dynamic or only a few fields are needed.

Covered in:JSON Binding — Jackson & Gson

L

labeled statement

A statement prefixed with name: so that break name; or continue name; can target it — typically an outer loop in nested loops. break exits the labeled loop; continue skips to its next iteration.

Covered in:Loops & Branching

lambda

A concise anonymous function (x -> x * 2) implementing a functional interface. Captures only effectively-final locals; its this is the enclosing instance (no own this).

Covered in:Lambdas & Functional Interfaces

List

An ordered, indexed Collection allowing duplicates (ArrayList, LinkedList). Implements SequencedCollection in Java 21. List.of(...) builds an immutable, null-rejecting list.

Covered in:Core Collections

literal

A fixed value written directly in source code — e.g. 42, 3.14, 'A', "hi", true.

Covered in:Types, Variables & var

LocalDate / LocalTime / LocalDateTime

The zone-free java.time value types: a date, a time-of-day, and the two combined. Immutable, built via static factories (now/of/parse), with no public constructors. Months are 1-based; plus/minus/with return a new value.

Covered in:Dates & Times — the java.time API

Locale

An identifier for a language (lowercase) + region (UPPERCASE), e.g. en_US, optionally script/variant. Build with Locale.Builder or Locale.forLanguageTag("pt-BR") (preferred over the legacy constructor). Drives ResourceBundle selection and locale-aware formatting.

Covered in:Locale & Resource Bundles

LLM (large language model)

A neural model trained to predict text, underlying AI coding assistants. Optimized to produce plausible output — which is not the same as correct — so its code must be verified.

Covered in:Generating Code & Tests with AI

load testing

Performance testing at expected/peak traffic to verify the system meets its targets. Contrast stress testing, which pushes past the limit to find the breaking point.

Covered in:Performance Testing

locator

A description of how to find a UI element — Selenium's By (By.id, By.cssSelector) or Playwright's Locator. Prefer stable hooks (data-testid) over brittle layout-based XPath/CSS.

Covered in:Selenium WebDriver Basics

M

Maven

A convention-driven build tool. A pom.xml declares coordinates, dependencies (with scopes), and plugins; the build lifecycle runs cumulative phases. This course's labs build with mvn -f labs/pom.xml test.

Covered in:Maven

mock

A test double with verifiable expectations about its interactions (was a method called, with what, how often). Created with Mockito's @Mock/mock(); assert with verify. Contrast a stub, which just returns canned values.

Covered in:Test Doubles & Mockito

Mockito

The standard Java mocking library: @Mock + MockitoExtension create doubles, when(...).thenReturn(...) stubs, verify(...) checks interactions, ArgumentCaptor inspects passed arguments. Unstubbed methods return type defaults.

Covered in:Test Doubles & Mockito

main method

A program's entry point. To be launchable it must be public static void main(String[] args) (String... also works); a non-static main or a non-array parameter will not launch.

Covered in:How a Java Program Is Structured & Run

Map

A key→value association (java.util), not a Collection. HashMap (unordered), LinkedHashMap (insertion order), TreeMap (sorted). Handy methods: getOrDefault, putIfAbsent, computeIfAbsent, merge. Map.of(...) is immutable and null-rejecting.

Covered in:Core Collections

MessageFormat

Builds parameterized messages with zero-indexed positional placeholders ({0}, {1}), optionally typed ({0,number,currency}, {1,date,short}). A literal single quote must be doubled ('').

Covered in:Formatting & Parsing

meta-annotation

An annotation that annotates another annotation's declaration — chiefly @Retention (how long it's kept) and @Target (where it may be placed), plus @Inherited, @Documented, @Repeatable.

Covered in:Annotations

method reference

A shorthand for a lambda that just calls one method, in four kinds: Type::staticMethod, Type::instanceMethod (on an arbitrary receiver), obj::instanceMethod (a specific receiver), and Type::new (constructor).

Covered in:Lambdas & Functional Interfaces

module

A named, self-describing set of packages (JPMS, Java 9+). It declares what it reads (requires) and exposes (exports), giving strong encapsulation the compiler and runtime enforce. java.base is required implicitly.

Covered in:Modules Basics

module-info

The module-info.java declaration at a module's root listing its directives: requires, exports, opens, uses, provides. Compiles to module-info.class.

Covered in:Modules Basics

module service (uses / provides)

JPMS's service-provider wiring: a consumer module declares uses ServiceType; and looks implementations up via ServiceLoader; a provider declares provides ServiceType with Impl;.

Covered in:Services & Migration

multi-catch

A single catch handling several exception types separated by | (catch (IOException | SQLException e)). The types may not be subclass-related, and the exception variable is implicitly final.

Covered in:try / catch / finally

N

narrowing conversion

A conversion to a type that may lose information (e.g. long → int, double → int). Requires an explicit cast.

Covered in:Types, Variables & var

nested class

A class declared inside another. A static nested class has no enclosing instance (new Outer.Nested()) and sees only static outer members; a non-static one is an inner class. Also covers local and anonymous classes.

Covered in:Nested & Inner Classes

NullPointerException (NPE)

The unchecked runtime exception thrown when you use a null reference as if it pointed to an object (calling a method or accessing a field on it).

Covered in:Operators & Expressions

NumberFormat

A java.text formatter/parser for numbers, currency, and percentages tied to a Locale (getInstance/getCurrencyInstance/getPercentInstance). parse returns a Number, throws the checked ParseException, and stops at the first unparseable character.

Covered in:Formatting & Parsing

numeric promotion

Before arithmetic, the smaller integer types (byte, short, char) are promoted to int (or wider). This is why byte + byte produces an int.

Covered in:Types, Variables & var, Operators & Expressions

O

object mother

A fixture idiom exposing named, ready-made canonical instances (Users.admin(), Users.minor()) for the recurring cases a suite needs. Use a test data builder for specific variations; mothers are often implemented with one.

Covered in:Data-Driven Tests & Fixtures

Object methods

The methods every class inherits from java.lang.Object — chiefly equals(Object), hashCode(), and toString(). Override equals and hashCode together and consistently, or hash-based collections break. equals must take an Object parameter to actually override.

Covered in:Inheritance & Polymorphism

octal / hex / binary literal

Integer literals in another base: a leading 0 is octal (013 == 11), 0x is hex, 0b is binary. Underscores may separate digits (1_000).

Covered in:Types, Variables & var

opens (module directive)

A module-info directive granting runtime deep reflective access to a package (including private members) for frameworks using setAccessible — without exporting it for compile-time use. An open module { } opens every package. Independent of exports.

Covered in:Services & Migration

Optional

A container that holds a value or nothing, replacing null for "maybe a result". Build with of/ofNullable/empty; transform with map/filter; extract with orElse (eager), orElseGet (lazy), or orElseThrow. get() on an empty Optional throws NoSuchElementException.

Covered in:Optional & Primitive Streams

overloading

Declaring multiple methods (or constructors) with the same name but different parameter lists. The compiler picks the most specific applicable one: exact match → widening → boxing → varargs. Return type alone never distinguishes overloads.

Covered in:Classes & Objects

overriding

A subclass replacing an inherited instance method with the same signature. Dispatch is dynamic (by the object's runtime type). An override can't narrow visibility or broaden checked exceptions; the return type may be covariant. Contrast with hiding.

Covered in:Inheritance & Polymorphism

OWASP Top 10

An awareness list of the most critical web application security risks (broken access control, injection, cryptographic failures, …), used to prioritize defenses and security tests.

Covered in:Security Testing

P

parameterized test

A JUnit 5 test (@ParameterizedTest) whose body runs once per input from a source (@ValueSource/@CsvSource/@MethodSource/@EnumSource/…), each case reported separately. Must declare a source and must not also be @Test.

Covered in:Parameterized & Structured Tests

POM (Project Object Model)

Maven's pom.xml build descriptor: artifact coordinates (groupId/artifactId/version), dependencies and their scopes, properties, and plugins.

Covered in:Maven

PreparedStatement

A parameterized JDBC statement with ? placeholders bound via setX (1-based). Sends values separately from the SQL text, so it prevents SQL injection and is the default for any query with input. Binds values, not identifiers.

Covered in:JDBC Core

package

A namespace that groups related types, declared with package and mirrored by the directory layout.

Covered in:How a Java Program Is Structured & Run

Path

An immutable java.nio.file abstraction for a file/directory location (it need not exist). Built with Path.of(...). Operations (resolve, relativize, normalize, getParent/getFileName) are pure path math — they never touch the filesystem. resolve against an absolute path returns it.

Covered in:NIO.2 — Path & Files

pattern matching

Testing a value against a pattern that, on success, binds variables. instanceof patterns (o instanceof String s) test-and-bind; switch patterns match by type; record patterns deconstruct components. Bindings follow flow scoping; guards use when.

Covered in:Pattern Matching

Period

A date-based amount of time (java.time) measured in years, months, and days. Use it with LocalDate; calendar-aware (so Period.between reports months and days, not a flat day count). Contrast with Duration.

Covered in:Dates & Times — the java.time API

polymorphism

The ability to treat objects of different subtypes through a common supertype, with the overridden instance method chosen at runtime by the object's actual type (dynamic dispatch). Fields and static methods are not polymorphic.

Covered in:Inheritance & Polymorphism

primitive stream

IntStream, LongStream, and DoubleStream — streams of primitives that avoid boxing and add numeric ops (sum, average, range/rangeClosed, summaryStatistics). Convert with mapToInt/mapToObj/boxed. range is end-exclusive; rangeClosed is inclusive.

Covered in:Optional & Primitive Streams

primitive type

One of the eight built-in value types: byte, short, int, long, float, double, char, boolean. Primitives are not objects.

Covered in:Types, Variables & var

page object model (POM)

A UI-test design pattern that wraps each screen in a class hiding its locators behind intention-revealing methods. Tests read in domain terms; a markup change touches one class, not many.

Covered in:Page Object Model & Design

Pact

The leading consumer-driven contract-testing tool. A consumer test produces a contract (Pact file) declaring the fields it uses; the provider replays and verifies it, catching breaking changes.

Covered in:Contract Testing

percentile latency

A latency distribution point — p95/p99 is the value at or below which that share of requests fall. Reported instead of the average because a few slow requests dominate the tail users actually feel.

Covered in:Performance Testing

Playwright

A modern browser-automation library (Chromium/Firefox/WebKit from one API) with built-in auto-waiting, lazy locators, and tracing. The main alternative to Selenium WebDriver.

Covered in:Playwright for Java

prompt engineering

Crafting an AI prompt to specify intent, signature, constraints, and edge cases (with examples) so the model produces correct, testable output — and to enumerate cases for a human-owned oracle.

Covered in:Prompt Patterns & Test Oracles

R

ResultSet

A JDBC cursor over query rows. Advance with next() (false when exhausted); read columns by 1-based index or name (getLong, getString). Close it (try-with-resources), before its Statement.

Covered in:JDBC Core

record

A transparent, immutable data carrier. From its component list the compiler generates a canonical constructor, private final fields, accessors named x(), and value-based equals/hashCode/ toString. It is implicitly final, cannot extends a class, and has no extra instance fields — but may implement interfaces. See compact constructor.

Covered in:Records

record pattern

A pattern that matches a record and deconstructs it, binding each component (case Point(var x, var y)). Record patterns nest, so nested records destructure in one label.

Covered in:Pattern Matching

reduce

A terminal stream operation that folds elements into one value. reduce(identity, op) returns the element type (identity must be a neutral element); reduce(op) returns an Optional (empty stream → empty).

Covered in:Reduction & Collectors

reflection

Inspecting and invoking code at runtime via Class, Method, Field, Constructor. Powers frameworks (JUnit, Mockito, Jackson) but defeats compile-time checks, is slower, and needs opens for deep access on modules. getDeclaredX = members of this class; getX = public, inherited included.

Covered in:Reflection (basics)

regex (regular expression)

A pattern language for matching text, via Pattern/Matcher and String.matches/split/ replaceAll. find matches a substring; matches the whole input. Backslashes are doubled in Java literals; quantifiers are greedy unless suffixed with ? (lazy).

Covered in:Regular Expressions

requires (module directive)

A module-info directive declaring that this module reads another and may use its exported types: requires com.acme.util;. Readability is not transitive unless requires transitive is used.

Covered in:Modules Basics

requires transitive

A requires transitive X; directive granting implied readability: any module that requires you also reads X. Use it when X's types appear in your own public API.

Covered in:Services & Migration

ResourceBundle

A locale-keyed map of translations, loaded by getBundle(base, locale) as .properties (property bundle) or a ListResourceBundle subclass (class bundle). Selection is most-specific-first with fallback to the default locale then the base; key lookup walks up the parent chain. A missing key throws MissingResourceException.

Covered in:Locale & Resource Bundles

retention

How long an annotation is kept, set by @Retention: SOURCE (compiler only, e.g. @Override), CLASS (in the .class but not loaded — the default), or RUNTIME (readable via reflection).

Covered in:Annotations

Runnable

A task interface with void run() — no return value and no checked exceptions (unlike Callable). Run it via new Thread(r).start(), an executor's execute, or a lambda.

Covered in:Threads & Tasks

REST

An architectural style for web APIs: resources addressed by URL, manipulated with HTTP verbs (GET/POST/PUT/DELETE) and status codes, typically exchanging JSON.

Covered in:HTTP with java.net.http

RestAssured

A Java library for testing REST APIs with a fluent given/when/then DSL — request building, JSON parsing, and status/body/header assertions (via Hamcrest and JSON-path) in one place.

Covered in:REST Testing with RestAssured

S

semantic versioning (SemVer)

MAJOR.MINOR.PATCH: MAJOR = breaking changes, MINOR = backward-compatible features, PATCH = backward-compatible fixes. Compare each component numerically (1.2.10 > 1.2.9), not as strings.

Covered in:Dependencies & Logging

SLF4J

A logging facade: code compiles against its API and a backend (Logback, Log4j2) is chosen at runtime. Provides levels (ERROR→TRACE) and parameterized messages (log.debug("id {}", id)) that skip string-building when the level is disabled.

Covered in:Dependencies & Logging

SQL injection

A vulnerability where attacker input is interpreted as SQL because it was concatenated into a query. Prevented by PreparedStatement parameter binding, which treats input as a literal value, never as SQL.

Covered in:JDBC Core

stack

The per-thread memory holding method call frames: local variables, primitives, and references (to heap objects). Pops when a method returns; unbounded recursion throws StackOverflowError. Contrast the shared heap.

Covered in:JVM Awareness

strategy pattern

Parameterizing behaviour by passing in an implementation of an interface. In modern Java this is usually a lambda/method reference on a functional interface (Comparator, Runnable, java.util.function).

Covered in:Object Contracts & Common Patterns

stub

A test double that returns canned answers to control the inputs a system under test reads (e.g. when(rates.rateFor("EUR")).thenReturn(0.9)). Unlike a mock, it doesn't assert on interactions.

Covered in:Test Doubles & Mockito

sealed class

A class or interface declared sealed with a permits clause naming the only allowed subtypes. Each permitted subtype must be final, sealed, or non-sealed. A known, complete subtype set lets a switch be exhaustive without a default.

Covered in:Sealed Types

SequencedCollection / SequencedSet / SequencedMap

Java 21 interfaces (JEP 431) for collections with a defined encounter order and both ends reachable: getFirst/getLast, addFirst/addLast, and a live reversed() view. Implemented by List, Deque, LinkedHashSet/SortedSet, and LinkedHashMap/SortedMap — not by HashSet/ HashMap.

Covered in:Sequenced Collections

serialization

Converting an object graph to/from bytes via ObjectOutputStream/ObjectInputStream. A class opts in by implementing the marker interface Serializable; deserialization bypasses constructors. Every non-transient, non-static field must be serializable. Java's built-in serialization is brittle and unsafe for untrusted input.

Covered in:Serialization

serialVersionUID

A static final long version stamp for a Serializable class. On read, a mismatch with the stored value throws InvalidClassException. Declare it explicitly (1L) — the auto-generated value changes on almost any edit.

Covered in:Serialization

Set

A Collection with no duplicate elements. HashSet (unordered), LinkedHashSet (insertion order), TreeSet (sorted — uses compareTo/compare == 0 for equality). Set.of(...) is immutable, rejects nulls, and rejects duplicate arguments.

Covered in:Core Collections

SDET (Software Development Engineer in Test)

A developer who specializes in test automation and quality engineering. This guide's SDET note callouts connect a Java concept to that work and to AI-assisted development.

short-circuit evaluation

&& and || skip evaluating their right operand when the left already determines the result.

Covered in:Operators & Expressions, Boolean & Conditions

single-file source-code program (JEP 330)

Since Java 11, java Greeting.java compiles and runs a single source file in memory, with no separate javac step.

Covered in:How a Java Program Is Structured & Run

static member

A field or method declared static, belonging to the class rather than any instance. Shared by all objects; accessed via the class name. A static method has no this and can't directly use instance members.

Covered in:Classes & Objects

stream

A lazy pipeline over a data source (java.util.stream): a source → intermediate ops → one terminal op. Nothing runs until the terminal op; a stream is single-use (a second terminal op throws IllegalStateException).

Covered in:Streams Basics

String

An immutable sequence of characters — a class (java.lang.String), not a primitive. Literals are held in the string pool; compare contents with .equals(), not ==.

Covered in:Text — Strings & Text Blocks

string concatenation

Joining strings with +. A constant expression ("h" + "i") is folded and pooled at compile time; concatenation involving a variable builds a new String at runtime. Repeated + in a loop is O(n²) — use a StringBuilder.

Covered in:Text — Strings & Text Blocks

string pool (interning)

A JVM cache of unique String literals, so equal literals share one object (and compare ==). String.intern() returns the pooled copy of a string.

Covered in:Text — Strings & Text Blocks

StringBuilder

A mutable sequence of characters for building strings efficiently. Methods mutate in place and return this (so calls chain). It does not override equals (identity only) — compare contents via String ("a".contentEquals(sb)).

Covered in:Text — Strings & Text Blocks

super (keyword)

A reference used to call a superclass constructor (super(args) — first statement of a constructor) or to invoke a superclass version of a member (super.method()). Iface.super.m() selects a specific interface default.

Covered in:Inheritance & Polymorphism

suppressed exception

When a try-with-resources body throws and a resource's close() also throws, the body exception propagates and the close() exception is attached as suppressed — retrieved via Throwable.getSuppressed(). (A throwing finally, by contrast, replaces the original.)

Covered in:try-with-resources & Custom Exceptions

switch expression

A switch that produces a value, using arrow arms (case L -> …). It never falls through, uses yield to return from a block arm, and must be exhaustive (cover every value or have a default) or it does not compile.

Covered in:The switch — Statements & Expressions

synchronization

Coordinating threads so shared state stays consistent. synchronized gives mutual exclusion and visibility; volatile gives visibility only (not atomicity). Prefer atomics and concurrent collections over hand-rolled locks.

Covered in:Executors & Concurrent Utilities

SAST / DAST

Two complementary security-testing approaches: SAST (static) analyzes source/bytecode at build time; DAST (dynamic) attacks the running app from outside (e.g. OWASP ZAP).

Covered in:Security Testing

Selenium

The long-standing standard for Java browser automation, driving a real browser through the W3C WebDriver protocol. Uses locators and explicit/implicit waits; Selenium Manager fetches driver binaries.

Covered in:Selenium WebDriver Basics

serialization (JSON)

Converting an object to JSON text (and deserialization the reverse), done by a binder like Jackson or Gson. Distinct from Java's built-in object serialization (Serializable, Module 08).

Covered in:JSON Binding — Jackson & Gson

service virtualization

Standing in for a real dependency with a programmable stub so the calling code can be tested in isolation — deterministically, offline, and with on-demand error/latency injection (e.g. WireMock).

Covered in:Mocking Services with WireMock

T

test data builder

A fixture idiom: a fluent builder with valid defaults for every field, so each test overrides only what it cares about (aUser().withAge(17).build()). A new required field is one change, not a hundred call-site edits.

Covered in:Data-Driven Tests & Fixtures

test double

A stand-in for a real collaborator in a test. Five kinds: dummy (unused filler), stub (canned answers), spy (real object that records calls), fake (working simplified implementation), mock (verifiable interactions).

Covered in:Test Doubles & Mockito

test lifecycle

The order JUnit runs callbacks around tests: @BeforeAll (once, static) → for each test @BeforeEach → @Test → @AfterEach → @AfterAll (once, static). A new test instance per method keeps tests isolated.

Covered in:JUnit 5 Essentials

test pyramid

A strategy for suite shape: many fast unit tests at the base, fewer integration tests, fewest slow E2E tests at the top. Inverting it (the "ice-cream cone") yields a slow, flaky, untrusted suite.

Covered in:Test Pyramid & Strategy

test report

Output summarizing test results: Maven Surefire XML (target/surefire-reports/, the CI default), the universal JUnit XML format, or rich HTML like Allure (steps, attachments, history). @DisplayName makes failures readable.

Covered in:Parallelism, Flakiness & Reporting

Testcontainers

A library that starts real dependencies (databases, brokers, browsers) in disposable Docker containers for tests — highest fidelity to production, but needs Docker and is slower, so such tests are kept out of the fast unit gate.

Covered in:Test Databases, Docker & Testcontainers

transaction

A unit of database work that is atomic (all-or-nothing). In JDBC, setAutoCommit(false) begins one; commit() persists all statements, rollback() discards them. Provides ACID guarantees.

Covered in:Transactions & Pooling

transitive dependency

A dependency pulled in indirectly by another dependency. Version conflicts are resolved by the build tool — Maven picks the nearest (shallowest) definition, Gradle the highest; pin explicitly when it matters.

Covered in:Dependencies & Logging

terminal operation

The single eager operation that ends a stream pipeline and produces a result or side-effect (collect, reduce, count, forEach, findFirst, anyMatch, toList, min/max). It triggers execution; short-circuiting terminals can stop early.

Covered in:Streams Basics

ternary operator

The conditional operator cond ? a : b — Java's only three-operand operator and the only one that yields a value as an expression. It has very low precedence, so parenthesize it inside larger expressions; the two result branches are unified to a common type (numeric promotion can apply).

Covered in:Boolean & Conditions

text block

A multi-line string literal delimited by """ (Java 15+, JEP 378). The opening """ must be followed by a newline; incidental leading whitespace is stripped relative to the closing delimiter; a line-ending \ continues the line (no newline) and \s preserves a trailing space.

Covered in:Text — Strings & Text Blocks

this (keyword)

A reference to the current object. Disambiguates a field from a same-named parameter (this.x = x), and this(...) chains to another constructor (must be the first statement). Not available in a static context.

Covered in:Classes & Objects

thread

An independent path of execution. A platform thread wraps an OS thread; a virtual thread is a lightweight JVM-scheduled one. start() spawns a new thread (run() does not); states run NEW → RUNNABLE → BLOCKED/WAITING/TIMED_WAITING → TERMINATED.

Covered in:Threads & Tasks

Throwable

The root type of everything that can be thrown or caught. Splits into Error (unchecked, serious JVM problems) and Exception; RuntimeException is the unchecked branch of Exception. Carries a message, a cause (chaining), a stack trace, and suppressed exceptions.

Covered in:Exceptions & the Hierarchy

transient

A field modifier marking state that is excluded from serialization. On deserialization a transient field gets its type's default (null/0/false) — no constructor runs. Use it for secrets, caches, or non-serializable references.

Covered in:Serialization

try-with-resources

A try (Resource r = …) form that automatically calls close() on each AutoCloseable resource — in reverse declaration order, before any catch/finally. Resource variables are implicitly final; a failing close() yields a suppressed exception.

Covered in:try-with-resources & Custom Exceptions

type erasure

The compile-time-only nature of generics: type arguments are removed (erased) at runtime, so all List<X> share one Class. Consequences: no new T[], no obj instanceof List<String>, and no two overloads differing only by generic type.

Covered in:Generics

type inference

Letting the compiler determine a type instead of writing it out explicitly — see var.

Covered in:Types, Variables & var

test oracle

The mechanism that decides whether an output is correct for a given input — a known value, round-trip, reference implementation, invariant/property, or metamorphic relation. The human core of testing AI-generated code; derive it independently of the code under test.

Covered in:Prompt Patterns & Test Oracles

test tag

A label on a test (JUnit 5's @Tag) used to select subsets in CI — e.g. run fast tests on every push and exclude slow/integration ones, filtered via Surefire groups or Maven profiles.

Covered in:Reports, Artifacts & Test Selection

throughput

The rate of work a system sustains under load, typically requests per second — a primary performance metric alongside latency and error rate.

Covered in:Performance Testing

U

unchecked exception

A RuntimeException (or Error) subclass, exempt from handle-or-declare — no throws or catch required. Signals programming bugs: NullPointerException, IllegalArgumentException, ArithmeticException, ClassCastException, etc. Contrast with checked exception.

Covered in:Exceptions & the Hierarchy

UTF-16

The 16-bit character encoding Java uses in memory: a char is a single UTF-16 code unit, and a String is a sequence of them.

Covered in:Types, Variables & var

V

var

A local-variable declaration whose type the compiler infers from the initializer (Java 10+). It needs an initializer and can't be null, a lambda, or an array-initializer shorthand ({ 1, 2, 3 }).

Covered in:Types, Variables & var

virtual thread

A lightweight, JVM-scheduled thread (Java 21, JEP 444) mounted onto a small pool of carrier platform threads; a blocking virtual thread unmounts its carrier, so millions can run cheaply. Best for I/O-bound work; create one per task via newVirtualThreadPerTaskExecutor() — don't pool them. Always daemon.

Covered in:Virtual Threads

verification

Establishing that code actually behaves as required — by review, tests, and deterministic runs. The course's thesis for AI: verification, not trust, is what makes generated code safe to ship.

Covered in:Guardrails — When Not to Trust AI

W

widening conversion

A conversion to a larger type that loses no information (e.g. int → long, int → double). Happens implicitly — no cast needed.

Covered in:Types, Variables & var

wildcard

A ? standing for an unknown type argument, used on variable/parameter types (not declarations). ? extends T is an upper-bounded producer (read, can't add); ? super T is a lower-bounded consumer (add T, read as Object); ? alone is unbounded. Mnemonic: PECS.

Covered in:Generics

wrapper class

The immutable java.lang class that boxes a primitive as an object: Byte, Short, Integer, Long, Float, Double, Character, Boolean. Needed for collections, generics, and null. Prefer valueOf over the deprecated constructors; autoboxing converts to/from them automatically. See the Integer cache.

Covered in:Numeric Values — Wrappers, Math & BigDecimal

WebDriver

The Selenium interface (and W3C protocol) for driving a browser — ChromeDriver, FirefoxDriver, etc. implement it. Always quit() it in teardown to end the session and free the browser process.

Covered in:Selenium WebDriver Basics

WireMock

A programmable mock HTTP server: stub responses, match/verify requests, and inject faults (errors, delays). Lets you test the code that calls a dependency without a live downstream service.

Covered in:Mocking Services with WireMock

Y

yield

The keyword that produces a value from a block arm of a switch expression (yield x;). It is not return (which would exit the whole method) and is unrelated to break.

Covered in:The switch — Statements & Expressions