Java glossary

Every term the course uses, in plain words. Search for a word you met somewhere, or browse by letter. Each entry links to the lesson that teaches it properly.

A14

Abstract classalso abstract, abstract method, concrete class: A class marked abstract that you cannot create objects from, made to be a shared base for subclasses. It can hold fields and finished methods, plus abstract methods with no body that every concrete (non-abstract) subclass must write.; Learn it in 23. Abstract classes and 25. Interface vs abstract classSee also Interface, Inheritance, Polymorphism
Access modifieralso public, private, protected, package-private, visibility: A keyword that says which code may use a class, field, method or constructor. public means any code, protected the same package and subclasses, no modifier at all the same package only, and private the class itself only.; Learn it in 14. Access modifiers and encapsulation and 44. Packages and importsSee also Encapsulation, Package, Getter and setter
AI assistantalso AI coding assistant, LLM, large language model, prompt: A tool built on a large language model that writes, explains and reviews code from a plain-language request, called a prompt. It predicts likely text, so it can be wrong while sounding sure: read, run and test whatever it gives you before you rely on it.; Learn it in 68. Working with AI coding assistantsSee also Hallucination, Code review, Unit test
Annotationalso @Deprecated, @SuppressWarnings, @FunctionalInterface: A note starting with @ that the compiler, a tool or a framework reads, such as @Override, @Test or @RestController. @Deprecated marks code you should stop using, and @SuppressWarnings("unchecked") silences one kind of warning. An annotation does nothing by itself until some program looks for it.; Learn it in 17. Method overriding and super, 57. Annotations, docs, stack traces, and the IDE and 22. Testing your code with JUnitSee also @Override, @Test, Javadoc
APIalso application programming interface, web API, endpoint: The set of operations a piece of software offers to other code. A library's API is its public classes and methods, and a web API is a set of URLs, called endpoints, that answer HTTP requests, usually with JSON.; Learn it in 71. Talking to the web: HttpClient and JSON and 72. Your first web API with Spring BootSee also REST, HTTP, JSON
Application (JavaFX)also Application class, start(), launch(), init(), stop(): The class every JavaFX program extends. launch(args) starts the toolkit, which calls init(), then start(Stage), where you build and show the window, and finally stop() when the program ends.; Learn it in 77. Creating and running a JavaFX applicationSee also Stage, JavaFX, JavaFX Application Thread
Arrange-act-assertalso AAA, arrange, act, assert, given, when, then: The usual shape of a test: arrange the objects and inputs it needs, act by calling the one method under test, then assert that the result is what you expected. Keeping the three parts apart makes a failing test quick to read.; Learn it in 22. Testing your code with JUnitSee also Unit test, Assertion
Arrayalso index, array literal, zero-based indexing: A fixed number of values of one type under one name, each reached by its index, counting from 0: in an array of length 5, a[0] is the first element and a[4] the last. new int[5] makes five zeros, {3, 1, 4} lists the values directly, and the size never changes.; Learn it in 6. Arrays, one dimensionSee also length, ArrayIndexOutOfBoundsException, ArrayList
ArrayIndexOutOfBoundsExceptionalso out of bounds, IndexOutOfBoundsException: The exception thrown when code uses an array index below 0 or not less than the length, such as a[5] on an array of length 5. Its message names both numbers: Index 5 out of bounds for length 5.; Learn it in 6. Arrays, one dimension and 9. Reading errors and debuggingSee also Array, Runtime error, Stack trace
ArrayList: A list stored in an array that grows by itself as you add to it. Reading or replacing by index with get(i) and set(i, x) is fast, while removing from the front shifts every later element along.; Learn it in 7. ArrayList: a list that can grow and 43. Inside ArrayList and HashMap: build your ownSee also List, Array, Dynamic array
Arrays.sortalso Collections.sort, List.sort, TimSort, dual-pivot quicksort: The library's sorting methods, which real code uses instead of a hand-written sort. Arrays.sort on numbers uses a dual-pivot quicksort, while sorting objects with Arrays.sort or List.sort uses TimSort, a stable sort built on merge sort that is fast on data that is already partly sorted.; Learn it in 37. Comparable, Comparator and sorting and 42. Searching and sorting algorithmsSee also Stable sort, Comparator, Merge sort
Assertionalso assertEquals, assertThrows, assertTrue, Assertions: A check inside a test that fails the test when the result is wrong. assertEquals(expected, actual) compares two values, expected first; assertTrue(condition) checks a condition; and assertThrows(IllegalArgumentException.class, () -> account.withdraw(-5)) passes only if that exception is thrown.; Learn it in 22. Testing your code with JUnitSee also JUnit, @Test, Unit test
AtomicIntegeralso atomic variable, incrementAndGet, AtomicLong: An int holder whose updates are atomic, so many threads can change it without a lock: hits.incrementAndGet() never loses an update the way count++ can. AtomicLong and AtomicBoolean do the same for other types.; Learn it in 63. Safe sharing: atomics, locks and concurrent collectionsSee also Race condition, Thread safety, synchronized
Autoboxingalso boxing, unboxing: Java wrapping a primitive value in its wrapper object by itself, such as an int becoming an Integer when you add it to a List<Integer>. Unboxing is the way back, and unboxing null throws a NullPointerException.; Learn it in 32. Wrapper classes and autoboxingSee also Wrapper class, Primitive type, Integer cache

B12

Base case: The input a recursive method answers directly, without calling itself, such as if (n == 0) return 1; in a factorial. Every recursive call must move closer to a base case, or the calls never stop and end in a StackOverflowError.; Learn it in 40. Recursion: methods that call themselvesSee also Recursion, StackOverflowError
Big-Oalso Big O notation, time complexity, space complexity: A way to say how an algorithm's work grows as its input grows, ignoring constant factors: O(n) means twice the input takes about twice the steps. Space complexity uses the same notation for the extra memory an algorithm needs.; Learn it in 41. How fast is it? Big-O in plain words and 42. Searching and sorting algorithmsSee also O(1), O(n), O(log n)
BigDecimalalso scale, setScale, money: An exact decimal number, used for money. Create it from a String, as in new BigDecimal("19.99"), and round with setScale(2, RoundingMode.HALF_UP), where the scale is the number of digits after the decimal point. Compare amounts with compareTo, because equals also compares the scale and calls 2.0 and 2.00 different.; Learn it in 51. Money and exact numbers: BigDecimal and BigIntegerSee also Floating point, RoundingMode, BigInteger
BigInteger: A whole number with no size limit, for values past a long's 9.2 quintillion, such as the factorial of 30. Like BigDecimal it is immutable, so a.multiply(b) returns a new number.; Learn it in 51. Money and exact numbers: BigDecimal and BigIntegerSee also BigDecimal, Integer overflow, int
Binary searchalso linear search, Arrays.binarySearch: Finding a value in sorted data by checking the middle and throwing away the half that cannot hold it, again and again, so a million items need at most 20 looks. Linear search, checking items one by one from the start, also works on unsorted data but takes O(n) steps.; Learn it in 42. Searching and sorting algorithms and 41. How fast is it? Big-O in plain wordsSee also O(log n), Arrays.sort, Recursion
booleanalso true, false, condition: The primitive type with only two values, true and false. Every condition in an if or a loop is a boolean expression, such as age >= 18.; Learn it in 2. Variables, types, and input/output and 4. Making decisions: if, else and switchSee also if statement, Logical operator
Branchalso git branch, git switch: A movable name for a line of commits, so you can work on a feature without touching main. git switch -c login creates a branch called login and moves to it, and new commits then go only to that branch.; Learn it in 64. Git and GitHub: saving your workSee also Merge, Commit, Pull request
break and continuealso break, continue: Two ways to jump inside a loop. break leaves the loop at once, and continue skips the rest of the current round and starts the next one. break also ends a case in a colon-style switch.; Learn it in 5. Loops: for, while, do-while and 4. Making decisions: if, else and switchSee also for loop, while loop, switch statement
BufferedReaderalso FileReader, readLine, end of file, EOF: A reader that pulls text in large chunks and hands it out a line at a time with readLine(), often wrapped around a FileReader. readLine() returns null at the end of the file, so while ((line = in.readLine()) != null) reads every line.; Learn it in 46. Reading filesQuick guide: How to Read a File in Java, with ExamplesSee also Try-with-resources, IOException, Files
Build lifecyclealso Maven lifecycle, phase, mvn package: Maven's fixed order of build steps, called phases; the main ones are validate, compile, test, package, verify, install and deploy. Running a phase runs every phase before it, so mvn package compiles and tests the code before it makes the JAR.; Learn it in 65. Maven and Gradle: building real projectsSee also Maven, JAR file
Builder patternalso builder: Making an object with many optional settings step by step through a helper object, then calling build(): new Pizza.Builder().size(12).cheese(true).build(). It replaces constructors with long lists of easily confused arguments.; Learn it in 31. Designing classes well and 71. Talking to the web: HttpClient and JSONSee also Factory method, Immutable
Bytecodealso .class file: The instructions javac writes into a .class file. They are not for any one kind of computer: the JVM reads them and runs them on whatever machine it is on.; Learn it in 1. Your first Java programQuick guide: JDK vs JRE vs JVM: What Each One DoesSee also JVM, Compiler, JIT compiler

C35

Call stackalso stack frame, the stack, stack memory: The JVM's record of the methods running right now, with one stack frame per call holding that call's parameters and local variables. A call pushes a new frame on top and return pops it off, and a stack trace is a printout of the call stack.; Learn it in 40. Recursion: methods that call themselves and 48. Exception handlingSee also Recursion, Stack trace, Heap
Capturing groupalso group, named group, $1: A part of a regex inside parentheses whose matched text is saved: in (\d{4})-(\d{2}), group(1) is the year and group(2) the month. (?<year>\d{4}) gives a group a name, and $1 in replaceAll puts group 1's text back into the result.; Learn it in 52. Regular expressions: patterns in textSee also Pattern and Matcher, Regular expression
Castingalso cast, type casting, type conversion, widening, narrowing: Converting a value to another type. Java widens a value to a bigger type by itself, as in double d = 5;, but going to a smaller type needs a cast you write, and (int) 9.99 cuts off the fraction to give 9.; Learn it in 3. Operators, expressions, and castingSee also Integer division, Upcasting and downcasting, Primitive type
charalso character: The primitive type for a single character, written in single quotes: 'A'. A char is stored as a number, so 'A' + 1 is the int 66, and a String is a sequence of them.; Learn it in 2. Variables, types, and input/output and 21. String practice problemsSee also String, Primitive type
Character classalso [a-z], \d, \w, \s: A part of a regex that matches one character from a set: [aeiou] matches any vowel and [^0-9] anything but a digit. The shortcuts \d, \w and \s stand for a digit, a word character and whitespace.; Learn it in 52. Regular expressions: patterns in textSee also Regular expression, Quantifier
Checked exceptionalso checked: An exception the compiler makes you deal with: you must catch it or declare it with throws, or the code does not compile. IOException and SQLException are checked, because files and databases can fail however careful your code is.; Learn it in 48. Exception handling and 46. Reading filesSee also Unchecked exception, throws, IOException
ChronoUnitalso ChronoUnit.DAYS: An enum of time units such as DAYS, WEEKS and MONTHS. ChronoUnit.DAYS.between(start, end) gives the total number of days between two dates, which is usually what “how many days until” means.; Learn it in 50. Dates and times with java.timeSee also Period, LocalDate, Enum
Classalso blueprint, class definition: A blueprint that describes a kind of object: the fields each object holds and the methods it can run. class Dog { String name; void bark() { ... } } describes dogs, and new Dog() builds one.; Learn it in 10. Why objects? Class vs object and 11. Creating classes and objectsSee also Object, Field, Method
ClassCastException: The exception thrown when a cast names a class the object does not belong to, such as casting a Cat to Dog. Check first with instanceof, or use a pattern such as if (a instanceof Dog d), before you downcast.; Learn it in 18. Polymorphism and 33. Generics: one class for many typesSee also Upcasting and downcasting, instanceof, Pattern matching
Classpathalso class path, -cp, ClassNotFoundException: The list of folders and JAR files where the JVM looks for compiled classes, set with -cp or the CLASSPATH environment variable. A class missing from it causes a ClassNotFoundException or a NoClassDefFoundError, a common sight when a JDBC driver JAR was left out.; Learn it in 44. Packages and imports and 69. SQL, MySQL, and connecting with JDBCSee also Package, JAR file, Module path
Code reviewalso review, reviewer: Another person reading your changes before they are merged, looking for bugs, unclear names and missing tests. Code an AI assistant wrote needs the same review as code from a stranger.; Learn it in 68. Working with AI coding assistants and 64. Git and GitHub: saving your workSee also Pull request, AI assistant, Refactoring
Collections Frameworkalso Java collections, Collection, java.util: The interfaces and classes in java.util for holding groups of objects: List, Set, Queue and Map, and the classes such as ArrayList, HashSet, ArrayDeque and HashMap that implement them. Each interface is a promise about how its elements behave, so you pick the one whose promise you need.; Learn it in 34. The Collections FrameworkSee also List, Set, Map
Collectorsalso collect, Collector, joining, toMap: The class of ready-made recipes you hand to collect to gather a stream's elements: Collectors.toSet(), joining(", ") for one String, toMap(...) for a Map and groupingBy(...) for groups. toMap throws an IllegalStateException when two elements produce the same key, unless you give it a merge function.; Learn it in 53. Streams: processing collections step by step and 54. Collectors and stream recipesSee also groupingBy, Terminal operation, Stream
Commentalso //, /* */, single-line comment, multi-line comment: Text in a source file that the compiler ignores, written for the people who read the code. // starts a comment that runs to the end of the line, and /* starts one that runs to the next */, even across many lines.; Learn it in 1. Your first Java programSee also Javadoc, Compiler
Commitalso git commit, commit message: A saved snapshot of the staged changes, with an author, a unique ID and a message saying why: git commit -m "Add login form". Commits form the project's history, and you can return to any of them.; Learn it in 64. Git and GitHub: saving your workSee also Staging area, Branch, Repository
Compact constructoralso canonical constructor: A record constructor written without a parameter list, used to check or tidy values before they are stored: record Age(int years) { Age { if (years < 0) throw new IllegalArgumentException(); } }. It is a short way to write the canonical constructor, the one that takes every component in order.; Learn it in 29. Records: data classes in one lineSee also Record, IllegalArgumentException
Compact source filealso void main(), instance main method, IO.println, IO.readln: A Java 25 program with no class declaration: the file holds methods such as void main() directly, and IO.println prints while IO.readln reads a line. You run it with java Hello.java, and Java wraps the file in a class for you.; Learn it in 1. Your first Java program, 56. Modern Java syntax: var, text blocks and more and 45. Scanner and console applicationsSee also main method, JShell
Comparablealso compareTo, natural order: An interface that gives a class its natural order through one method, compareTo, which returns a negative number, zero or a positive number when this object comes before, ties with or comes after the other. String, Integer and LocalDate implement it, which is how Collections.sort knows their order.; Learn it in 33. Generics: one class for many types and 37. Comparable, Comparator and sortingSee also Comparator, TreeSet, Arrays.sort
Comparatoralso Comparator.comparing, thenComparing, reversed: An object that holds one rule for ordering, kept separate from the class it sorts. list.sort(Comparator.comparing(Student::grade).thenComparing(Student::name)) sorts by grade and breaks ties by name, and reversed() flips an order.; Learn it in 37. Comparable, Comparator and sorting and 53. Streams: processing collections step by stepSee also Comparable, Strategy pattern, Lambda expression
Compile erroralso compile-time error, syntax error, cannot find symbol: A mistake the compiler finds before the program runs, such as a missing semicolon, a misspelled name or text put into an int. javac makes no bytecode until every one is fixed, so start with the first message: later ones are often side effects of it.; Learn it in 9. Reading errors and debuggingSee also Compiler, Runtime error, Logic error
Compileralso javac: The program that reads your .java source file, checks it, and turns it into bytecode. Java's compiler is javac. Mistakes it finds, such as a missing semicolon, are compile errors, and nothing runs until they are fixed.; Learn it in 1. Your first Java programSee also Bytecode, JVM, Compile error
CompletableFuturealso supplyAsync, thenApply, thenAccept: A Future you can chain more steps onto, so work continues when the result arrives instead of a thread sitting and waiting: CompletableFuture.supplyAsync(() -> fetchPrice()).thenApply(p -> p * 2). Calling join() at the end waits for the final value.; Learn it in 61. Thread pools, executors and futuresSee also Future, ExecutorService, Lambda expression
Compositionalso has-a, composition over inheritance, delegation: Building a class from other objects that it keeps in fields: a Car has an Engine, instead of inheriting from one. It is usually preferred to inheritance, because the parts can be swapped and the class shows only the methods it chooses.; Learn it in 31. Designing classes wellSee also Inheritance, Dependency injection, Strategy pattern
Compound assignmentalso +=, -=, *=, /=: A shortcut that updates a variable with an operator: total += price means total = total + price. It also casts the result back to the variable's type without a word, so after int n = 10;, n *= 2.5 quietly leaves 25.; Learn it in 3. Operators, expressions, and casting and 5. Loops: for, while, do-whileSee also Increment and decrement, Casting, Operator precedence
Concurrencyalso multithreading, parallelism: Several tasks making progress during the same stretch of time, such as a program downloading files while its window stays responsive. Java does it with threads, and when tasks run at the same instant on different processor cores, that is called parallelism.; Learn it in 59. Introduction to threadsSee also Thread, Race condition, Virtual thread
ConcurrentHashMap: A thread-safe HashMap that many threads can read and update at once without corrupting it. Use its one-step methods, such as counts.merge(word, 1, Integer::sum), because a separate get followed by a put can still race.; Learn it in 63. Safe sharing: atomics, locks and concurrent collectionsSee also HashMap, Thread safety, Race condition
ConcurrentModificationExceptionalso fail-fast: The exception a collection's iterator throws when the collection changed size while it was being walked, most often by calling list.remove(x) inside a for-each loop. Remove through the iterator or with removeIf instead; despite the name, it usually happens with a single thread.; Learn it in 7. ArrayList: a list that can grow and 34. The Collections FrameworkSee also Iterator, for-each loop
Connectionalso DriverManager, getConnection, connection URL, JDBC URL: An open session with a database, made with DriverManager.getConnection(url, user, password), where the URL names the database, such as jdbc:mysql://localhost:3306/school. Close it when you are done, ideally with try-with-resources, because a database allows only so many open connections.; Learn it in 69. SQL, MySQL, and connecting with JDBC and 70. Creating and executing queriesSee also JDBC, PreparedStatement, Try-with-resources
Constructoralso default constructor, this(), constructor chaining: Code with the class's name and no return type that runs when new builds an object, so the object starts in a valid state. A class that declares no constructor gets an empty default one, and a constructor can hand its work to another with this(...), or to the parent class's with super(...).; Learn it in 13. Constructors and 16. InheritanceSee also Object, this, super
Containeralso Docker container, docker run: A running instance of an image, kept apart from other programs with its own files and network but sharing the machine's operating system kernel, which makes it much lighter than a virtual machine. docker run -p 8080:8080 myapp starts one and makes its port 8080 reachable.; Learn it in 74. Shipping it: Docker and GitHub ActionsSee also Docker image, Docker, Docker Compose
Continuous integrationalso CI, CI/CD, continuous delivery: Building and testing every change automatically as soon as it is pushed, so a broken build is caught within minutes instead of days. Continuous delivery goes a step further and also prepares every change that passes for release.; Learn it in 74. Shipping it: Docker and GitHub ActionsSee also GitHub Actions, Unit test, Pull request
Controlalso Button, Label, TextField, PasswordField, TextArea, Alert: A JavaFX node the user works with, such as a Button, Label, TextField, PasswordField or TextArea. What a user types is a String until you parse it, and an Alert is the ready-made dialog for telling them what went wrong.; Learn it in 78. Nodes, controls, and layout panes and 79. Form creation using JavaFXSee also Node (JavaFX), Layout pane, Event handler
CountDownLatchalso latch, countDown, await: A one-time gate that opens when its counter reaches zero: worker threads call countDown() as they finish, and await() blocks until the count hits zero. It lets the main thread wait until all five of its downloads are complete.; Learn it in 63. Safe sharing: atomics, locks and concurrent collectionsSee also Thread lifecycle, ExecutorService
CRUDalso create, read, update, delete, INSERT, SELECT, UPDATE, DELETE: Create, read, update and delete: the four things most programs do with stored data. In SQL they are INSERT, SELECT, UPDATE and DELETE, and in a REST API they are usually POST, GET, PUT and DELETE.; Learn it in 70. Creating and executing queries, 81. Database support of a JavaFX application and 73. Saving data with Spring Data JPASee also SQL, REST, JpaRepository
Custom exceptionalso user-defined exception: An exception class you write for your own program by extending Exception (checked) or RuntimeException (unchecked), such as class InsufficientFundsException extends RuntimeException. Its name tells the reader exactly what went wrong.; Learn it in 48. Exception handlingSee also throw, Checked exception, Unchecked exception

D15

Databasealso DBMS, RDBMS, MySQL, table, primary key: A program that stores data safely and answers questions about it. A relational database, such as MySQL, keeps data in tables, where each column has a name and a type and each row is one record, and a primary key column gives every row a unique identity.; Learn it in 69. SQL, MySQL, and connecting with JDBCSee also SQL, JDBC, CRUD
DateTimeFormatteralso ofPattern, date format, ISO 8601: Turns dates and times into text, and text back into dates, using a pattern: DateTimeFormatter.ofPattern("dd/MM/yyyy") formats 14 March 2025 as 14/03/2025. Letter case matters, since MM is the month and mm the minute, and without a formatter toString gives the ISO 8601 form, 2025-03-14.; Learn it in 50. Dates and times with java.timeSee also LocalDate, Period
Deadlock: Two or more threads stuck forever, each holding a lock that another one needs. If thread A holds lock 1 and waits for lock 2 while thread B holds lock 2 and waits for lock 1, neither can move; taking locks in the same order everywhere prevents it.; Learn it in 63. Safe sharing: atomics, locks and concurrent collectionsSee also synchronized, ReentrantLock, Thread lifecycle
Debuggingalso debugger, breakpoint, step over, rubber duck debugging, print debugging: Finding and fixing the cause of a bug by ruling out, check by check, where it cannot be. Printed values help, and a debugger lets you pause at a breakpoint and step over or into one line at a time while you watch every variable. Explaining the code out loud, line by line, is called rubber duck debugging.; Learn it in 9. Reading errors and debugging and 57. Annotations, docs, stack traces, and the IDESee also Stack trace, Logic error, IDE
Dependencyalso library, third-party library, Maven Central: A library your project uses that someone else wrote, such as JUnit or Jackson, listed in pom.xml or build.gradle by its group, name and version. The build tool downloads it, along with the libraries it needs in turn, from a repository such as Maven Central.; Learn it in 65. Maven and Gradle: building real projectsSee also Maven, Gradle, pom.xml
Dependency injectionalso DI, constructor injection, bean, inversion of control: Handing an object the things it needs, usually through its constructor, instead of letting it create them itself. A class that takes a Store interface can be given a real database store or a fake one in a test, and Spring Boot does this wiring for you, creating and passing in objects it calls beans.; Learn it in 31. Designing classes well and 72. Your first web API with Spring BootSee also Composition, Interface, Spring Boot
Dequealso ArrayDeque, double-ended queue: A double-ended queue, pronounced “deck”: you can add and remove at both the front and the back. ArrayDeque is the standard class, used both as a stack and as a queue.; Learn it in 34. The Collections Framework and 38. Stacks, queues and dequesSee also Stack, Queue
Dockeralso containerization: A tool that packages an app with everything it needs to run, such as the Java runtime, into an image, then runs that image as an isolated container. The same image runs the same way on your laptop, a teammate's and a server.; Learn it in 74. Shipping it: Docker and GitHub ActionsSee also Docker image, Container, Dockerfile
Docker Composealso compose.yaml, docker-compose.yml, docker compose up: A tool for running several containers together, such as your API and a MySQL database, described in one compose.yaml file. docker compose up starts them all on a shared network, where each finds the others by service name.; Learn it in 74. Shipping it: Docker and GitHub ActionsSee also Container, Docker
Docker imagealso image, container image: A read-only package holding an app and everything it needs, built in layers from a Dockerfile. You can run many containers from one image, and share images through a registry such as Docker Hub.; Learn it in 74. Shipping it: Docker and GitHub ActionsSee also Container, Dockerfile, Docker
Dockerfilealso FROM, multi-stage build: A text file of instructions for building an image: FROM picks a starting image such as a Java runtime, COPY adds your JAR and ENTRYPOINT says how to start it. A multi-stage build compiles the app in one stage with a full JDK, then copies only the result into a small runtime image.; Learn it in 74. Shipping it: Docker and GitHub ActionsSee also Docker image, Docker, JAR file
doublealso decimal number: The primitive type for numbers with a fractional part, such as 3.75. It stores the nearest binary fraction, so 0.1 + 0.2 prints 0.30000000000000004, and money belongs in a BigDecimal instead.; Learn it in 2. Variables, types, and input/output and 51. Money and exact numbers: BigDecimal and BigIntegerSee also Floating point, BigDecimal, Primitive type
Durationalso Duration.between: An exact amount of time in seconds and nanoseconds, such as Duration.ofMinutes(90), which prints as PT1H30M. Use it for clock times and timings, and Period for calendar dates.; Learn it in 50. Dates and times with java.timeSee also Period, LocalDate, ChronoUnit
Dynamic arrayalso growable array, capacity, resize, amortized cost: A list stored in an array with spare room, as ArrayList is: its capacity is the array's length, which is usually more than the list's size. When the array is full, a bigger one (half as big again in ArrayList) is made and everything is copied across. The copies are rare enough that adding to the end costs O(1) on average, which is called amortized O(1).; Learn it in 43. Inside ArrayList and HashMap: build your own and 7. ArrayList: a list that can growSee also ArrayList, Array, Load factor
Dynamic dispatchalso late binding, runtime type, declared type: Choosing which version of an overridden method to run from the object's real class while the program runs. In Animal a = new Dog();, the declared type Animal decides which methods you may call, and the runtime type Dog decides which version of a.speak() runs.; Learn it in 17. Method overriding and super and 18. PolymorphismSee also Polymorphism, Overriding, Upcasting and downcasting

E12

Edge casealso corner case, boundary value: An input at the limits of what code must handle: an empty list, zero, a negative number, the first or last element, or a value right at a boundary, such as exactly 18 for an adult. Bugs gather at the edges, so good tests check them on purpose.; Learn it in 22. Testing your code with JUnitSee also Unit test, Parameterized test
Encapsulationalso data hiding, information hiding, invariant: Keeping an object's fields private and letting other code change them only through methods, so the object can refuse bad values. A BankAccount with a private balance can make sure a withdrawal never takes it below zero, a rule that always holds and is called an invariant.; Learn it in 14. Access modifiers and encapsulation and 19. OOP practice: Student, Bank, EmployeeSee also Access modifier, Getter and setter, Immutable
@Entityalso entity, @Id, @GeneratedValue: The JPA annotation that maps a class to a database table, one object per row. The field that holds the primary key is marked @Id, often with @GeneratedValue so the database picks each new number.; Learn it in 73. Saving data with Spring Data JPASee also JPA, JpaRepository, Database
Enumalso enumeration, enum type: A type with a fixed set of named values: enum Size { SMALL, MEDIUM, LARGE }. A variable of that type can hold only those values, and an enum can have fields, constructors and methods like a class.; Learn it in 28. Enums, lambdas, and functional interfacesSee also Switch expression, final, Class
equalsalso ==, == vs equals, equality, identity: The method that asks whether two objects hold the same value: a.equals(b). For objects, == asks a different question, whether both variables point at the same object, so compare strings, records and wrapper values with equals.; Learn it in 15. The this keyword and object references, 36. equals, hashCode and toString and 20. Strings, StringBuilder, StringBufferSee also hashCode, Reference, String
Escape sequencealso \n, \t, backslash: A backslash and a letter that stand for a character you cannot type straight into a string: \n is a new line, \t a tab, \" a double quote and \\ one backslash. So "a\tb" prints a, then a tab, then b.; Learn it in 2. Variables, types, and input/outputSee also String, Text block, char
Event dispatch chainalso event bubbling, bubbling phase, capturing phase, event filter, consume: The route an event travels through the scene graph: down from the stage to the target node, running event filters, then back up, running event handlers. Calling consume() on the event ends its trip at that point.; Learn it in 80. Event handling and GUI programsSee also Event handler, Scene graph
Event handleralso EventHandler, setOnAction, ActionEvent, handle: Code that JavaFX runs when an event happens, such as a button press: button.setOnAction(e -> save());. The handler receives an event object, an ActionEvent for a button, that says what happened and where.; Learn it in 79. Form creation using JavaFX and 80. Event handling and GUI programsSee also Event-driven programming, Lambda expression, Event dispatch chain
Event-driven programmingalso event-driven, event loop: A style where the program sets everything up and then waits, and the toolkit calls your code when something happens, such as a click or a key press. Instead of one script running top to bottom, you write a handler for each event.; Learn it in 76. JavaFX overview, features, and architecture and 80. Event handling and GUI programsSee also Event handler, JavaFX Application Thread, JavaFX
Exceptionalso exception handling, Throwable, Error: An object Java throws to say “I cannot do what you asked”, which travels up the call stack until a catch handles it. Everything that can be thrown descends from Throwable: Exception for problems a program can handle, and Error, such as StackOverflowError, for serious trouble inside the JVM.; Learn it in 9. Reading errors and debugging and 48. Exception handlingSee also try-catch, Checked exception, Stack trace
Executable JARalso runnable JAR, java -jar, manifest, Main-Class, fat JAR: A JAR whose manifest file, META-INF/MANIFEST.MF, names the class with main in a Main-Class line, so java -jar app.jar runs it. A fat JAR, the kind Spring Boot builds, also packs every dependency inside.; Learn it in 67. Packaging and shipping a Java appSee also JAR file, jpackage, main method
ExecutorServicealso thread pool, Executors, submit, shutdown: A service that runs tasks on threads it manages: you submit a task and get a Future back. Executors.newFixedThreadPool(4) keeps a pool of four threads and reuses them for every task, and you call shutdown(), or use try-with-resources, when no more tasks will come.; Learn it in 61. Thread pools, executors and futures and 62. Virtual threadsSee also Future, Virtual thread, Runnable

F14

Factory methodalso static factory method, factory: A static method that creates and returns an object for you instead of a constructor call: List.of(1, 2), LocalDate.of(2025, 3, 14) and Integer.valueOf(5) are factory methods. It can have a descriptive name, reuse existing objects or return a subclass.; Learn it in 31. Designing classes well and 29. Records: data classes in one lineSee also Builder pattern, Constructor, Strategy pattern
Fieldalso instance variable, attribute, member variable, default value: A variable declared in a class but outside its methods, so every object carries its own copy, such as each Student's own name. A field you have not set holds a default value: 0 for numbers, false for boolean and null for objects.; Learn it in 11. Creating classes and objects and 13. ConstructorsSee also Class, Encapsulation, static
Filesalso Files.readString, Files.readAllLines, Files.writeString, java.nio.file, CSV, UTF-8: A class of static methods in java.nio.file that do a whole file job in one call: Files.readString(path) reads a file into a String, Files.readAllLines(path) into a List<String>, and Files.writeString(path, text) writes one. They read and write UTF-8 text by default, and they are the usual way to load a CSV file, a plain-text table with one record per line and commas between the fields.; Learn it in 49. Path and Files: modern file handlingQuick guides: How to Read a File in Java, with Examples, How to Write to a File in JavaSee also Path, IOException, BufferedReader
FileWriteralso BufferedWriter, PrintWriter, append mode, flush, buffer: A writer that puts text into a file, replacing what was there unless you open it in append mode with new FileWriter("log.txt", true). Writers hold text in a buffer, a block of memory, so it reaches the file only on flush() or close(), which is why you open them with try-with-resources.; Learn it in 47. Writing filesQuick guide: How to Write to a File in JavaSee also Try-with-resources, BufferedReader, Files
filteralso Stream.filter, Predicate: The stream operation that keeps only the elements a test accepts: scores.stream().filter(s -> s >= 50) keeps the passing scores. The test is a Predicate, a function that returns a boolean.; Learn it in 53. Streams: processing collections step by stepSee also map (streams), Stream, Lambda expression
finalalso constant, static final, final class, final method: A keyword meaning the thing cannot change: a final variable is assigned once, a final method cannot be overridden and a final class, such as String, cannot be extended. A constant is a static final field named in capitals, such as MAX_SIZE, and a final reference can still point at an object whose fields change.; Learn it in 26. The static and final keywordsSee also static, Immutable, Enum
finallyalso finally block: A block after try (and any catch) that runs whether or not an exception happened, even when the try block returns early. It is for cleanup such as closing a file, though try-with-resources usually does that job better.; Learn it in 48. Exception handlingSee also try-catch, Try-with-resources
flatMapalso flatten: A stream operation that turns each element into a stream of its own and joins them all into one flat stream. A list of orders, each with a list of items, becomes one stream of every item with orders.stream().flatMap(o -> o.items().stream()).; Learn it in 54. Collectors and stream recipesSee also map (streams), Stream
Floating pointalso floating-point number, float, rounding error, 0.1 + 0.2: How double and float store numbers: as the nearest binary fraction, which is exact for halves and quarters but not for tenths. That is why 0.1 + 0.2 prints 0.30000000000000004, and why money is kept in BigDecimal.; Learn it in 51. Money and exact numbers: BigDecimal and BigInteger and 2. Variables, types, and input/outputSee also double, BigDecimal
for loopalso for, loop counter, loop: A loop with its counter built into the first line: for (int i = 0; i < 5; i++) sets i to 0, runs the body while i < 5, and adds one after each round. Use it when you know how many rounds you need.; Learn it in 5. Loops: for, while, do-while and 6. Arrays, one dimensionSee also while loop, for-each loop, break and continue
for-each loopalso enhanced for loop, for each: A loop that visits every element of an array or collection in turn: for (String name : names). It gives you no index, and changing a collection's size inside one usually ends in a ConcurrentModificationException.; Learn it in 6. Arrays, one dimension and 7. ArrayList: a list that can growQuick guide: The for-each Loop in Java (Enhanced for Loop)See also for loop, Iterator, ConcurrentModificationException
Functional interfacealso @FunctionalInterface, single abstract method: An interface with exactly one abstract method, such as Comparator, Runnable or Predicate. Because there is only one method to fill in, a lambda or a method reference can stand in for an object that implements it.; Learn it in 28. Enums, lambdas, and functional interfaces and 53. Streams: processing collections step by stepSee also Lambda expression, Method reference, Interface
Futurealso Callable, Future.get: A handle to the result of a task still running on another thread, whose get() waits for the result and returns it. A task that returns a value is a Callable: its call() method, unlike Runnable's run(), gives back a result and may throw a checked exception.; Learn it in 61. Thread pools, executors and futuresSee also ExecutorService, CompletableFuture, Runnable
FXMLalso .fxml, Scene Builder, FXMLLoader: An XML format for describing a JavaFX screen's layout in a file instead of building it in Java code. Scene Builder, a free drag-and-drop designer, writes FXML for you, and FXMLLoader turns the file back into nodes.; Learn it in 76. JavaFX overview, features, and architecture and 79. Form creation using JavaFXSee also Scene graph, JavaFX

G10

Garbage collectionalso garbage collector, GC: The JVM's automatic cleanup of objects that no variable can reach any more, which frees their memory for new objects. You never delete an object yourself in Java.; Learn it in 1. Your first Java program and 39. Linked lists: nodes and referencesSee also Heap, Reference, JVM
Genericsalso generic class, generic method, type parameter, <T>, bounded type, diamond operator: Writing a class or method once with a type parameter such as <T>, then using it with any type: a Box<String> holds only strings, and the compiler checks every value you put in. A bound such as <T extends Number> limits which types fit, and the diamond <> in new ArrayList<>() lets the compiler fill in the type.; Learn it in 33. Generics: one class for many types and 34. The Collections FrameworkSee also Wildcard, Type erasure, ArrayList
@GetMappingalso @PostMapping, @PutMapping, @DeleteMapping, @PathVariable, @RequestBody: Ties HTTP GET requests for a path to a controller method: @GetMapping("/tasks/{id}") runs it for GET /tasks/42, and a parameter marked @PathVariable receives the 42. @PostMapping, @PutMapping and @DeleteMapping do the same for the other methods, and @RequestBody turns a request's JSON into a Java object.; Learn it in 72. Your first web API with Spring BootSee also @RestController, HTTP, REST
Getter and setteralso getter, setter, accessor, mutator: Methods that read and change a private field: a getter such as getName() returns its value, and a setter such as setName(String name) changes it and can reject a bad value. Records name their getters after the field, as in point.x(), with no get.; Learn it in 14. Access modifiers and encapsulation and 29. Records: data classes in one lineSee also Encapsulation, Field, Record
Gitalso version control, source control: A version control system: it records snapshots of a project's files as commits, so you can see every change, go back to any earlier state and work on several versions at once. Git runs on your own computer, and GitHub is a website that hosts Git repositories.; Learn it in 64. Git and GitHub: saving your workSee also Repository, Commit, GitHub
GitHub: A website that hosts Git repositories online, so a team can share code, review changes in pull requests and run automated checks with GitHub Actions. Git is the tool, and GitHub is one place to keep a shared copy of what it tracks.; Learn it in 64. Git and GitHub: saving your work and 74. Shipping it: Docker and GitHub ActionsSee also Git, Pull request, GitHub Actions
GitHub Actionsalso workflow, .github/workflows: GitHub's built-in automation: YAML workflow files in .github/workflows describe jobs, such as building and testing the project, that run on GitHub's machines after every push or pull request. A red cross on a pull request means a job failed.; Learn it in 74. Shipping it: Docker and GitHub ActionsSee also Continuous integration, GitHub, Pull request
.gitignore: A file listing the files and folders Git should not track, one pattern per line, such as target/, *.class and .env. Build output, editor settings and secrets such as passwords belong in it.; Learn it in 64. Git and GitHub: saving your workSee also Git, Repository
Gradlealso build.gradle, build.gradle.kts, gradlew: A build tool that does the same jobs as Maven, configured with a script in Kotlin (build.gradle.kts) or Groovy (build.gradle) instead of XML. ./gradlew build compiles, tests and packages the project with the Gradle version the project asks for.; Learn it in 65. Maven and Gradle: building real projectsSee also Maven, Dependency
groupingByalso Collectors.groupingBy, partitioningBy, counting: A collector that sorts a stream's elements into a Map of lists by a key: groupingBy(Student::grade) gives each grade with its students. A second collector summarizes each group, as in groupingBy(Student::grade, counting()), and partitioningBy is the two-group version, with the keys false and true.; Learn it in 54. Collectors and stream recipesSee also Collectors, Map, Stream

H8

Hallucination: An answer from an AI model that sounds right but is made up, such as a method that does not exist or a library version that was never released. The compiler, the official documentation and your own tests are how you catch it.; Learn it in 68. Working with AI coding assistantsSee also AI assistant, Javadoc, Unit test
Hash collisionalso collision, bucket, chaining: Two different keys landing in the same bucket, the slot in a hash table's array that a key's hash code picks. A HashMap keeps both entries in that bucket, chained together, and tells them apart with equals; many collisions make lookups slow.; Learn it in 35. HashMap and HashSet: finding things fast and 43. Inside ArrayList and HashMap: build your ownSee also hashCode, HashMap, Load factor
hashCode: A method every object has that returns an int summary of the object. Hash-based collections such as HashMap use it to decide where an object goes, so two objects that are equals must return the same hash code.; Learn it in 36. equals, hashCode and toString and 35. HashMap and HashSet: finding things fastSee also HashMap, equals, Hash collision
HashMapalso map, dictionary, dict, hash table: A collection of key and value pairs that finds a value from its key in about the same time however big it grows. It uses each key's hashCode to pick a bucket, and its keys come out in no promised order.; Learn it in 35. HashMap and HashSet: finding things fast and 43. Inside ArrayList and HashMap: build your ownSee also hashCode, TreeMap, Hash collision
HashSetalso hash set: A set that adds, finds and removes values in about the same time however big it grows, using each value's hashCode and equals. It keeps no order, and inside it is a HashMap whose keys are the set's values.; Learn it in 35. HashMap and HashSet: finding things fastSee also Set, HashMap, hashCode
Heapalso heap memory: The area of the JVM's memory where objects live. Every new makes an object on the heap, and a variable holds a reference that points to it. This heap has nothing to do with the binary heap inside a PriorityQueue.; Learn it in 1. Your first Java program and 15. The this keyword and object referencesSee also Call stack, Reference, Garbage collection
HTTPalso HTTPS, HTTP method, GET, POST, request, response: The protocol programs use to talk to web servers. A client sends a request with a method (GET to read, POST to create, PUT to replace, DELETE to remove), a URL, headers and sometimes a body, and the server answers with a status code, headers and a body; HTTPS is the same protocol, encrypted.; Learn it in 71. Talking to the web: HttpClient and JSON and 72. Your first web API with Spring BootSee also Status code, HttpClient, REST
HttpClientalso java.net.http, HttpRequest, HttpResponse: The JDK's built-in class for calling web servers, in java.net.http since Java 11. You build an HttpRequest, send it with client.send(request, HttpResponse.BodyHandlers.ofString()), and read the status code and body from the HttpResponse you get back.; Learn it in 71. Talking to the web: HttpClient and JSONSee also HTTP, JSON, API

I18

IDEalso integrated development environment, IntelliJ IDEA, VS Code, Eclipse: An integrated development environment: an editor built for writing code, such as IntelliJ IDEA, VS Code or Eclipse. It marks errors as you type, completes names, renames safely, runs your program and has a debugger built in.; Learn it in 57. Annotations, docs, stack traces, and the IDESee also Debugging, Javadoc, Refactoring
if statementalso if, else, else if, if-else: Runs a block only when its condition is true, with an optional else for when it is not. In a chain of if, else if and else, only the first branch whose condition is true runs.; Learn it in 4. Making decisions: if, else and switchSee also boolean, switch statement, Ternary operator
IllegalArgumentException: The standard unchecked exception for “I cannot accept this value”, thrown by a method that checks its arguments: throw new IllegalArgumentException("age must not be negative");. Throwing it at the start of a method stops bad data before it does any harm.; Learn it in 22. Testing your code with JUnit, 48. Exception handling and 80. Event handling and GUI programsSee also throw, Unchecked exception, NumberFormatException
Immutablealso immutability, immutable object: Unable to change after it is made. String, LocalDate and BigDecimal objects are immutable, so a method such as plusDays returns a new object, and immutable objects are safe to share between methods and threads.; Learn it in 20. Strings, StringBuilder, StringBuffer, 29. Records: data classes in one line and 31. Designing classes wellSee also String, Record, final
importalso import statement, static import, java.lang: A line at the top of a file that lets you use a class from another package by its short name: import java.util.ArrayList;. Classes in java.lang, such as String and Math, need no import, and import static brings in static members, such as JUnit's assertEquals.; Learn it in 44. Packages and imports and 7. ArrayList: a list that can growQuick guide: Java import Statement, Explained with ExamplesSee also Package, Classpath
Increment and decrementalso ++, --, i++, prefix, postfix: x++ adds one to x and x-- takes one away. Inside a bigger expression, the postfix form x++ gives the old value and the prefix form ++x the new one, so int a = 5; int b = a++; leaves b at 5 and a at 6.; Learn it in 3. Operators, expressions, and casting and 5. Loops: for, while, do-whileSee also Compound assignment, for loop
Inheritancealso extends, subclass, superclass, parent class, child class, is-a: Building a new class on top of an existing one with extends: in class Dog extends Animal, the subclass Dog gets the fields and methods of its superclass Animal and adds its own. A class extends exactly one other class, Object if it names none, and inheritance fits only when “a Dog is an Animal” is true.; Learn it in 16. Inheritance, 17. Method overriding and super and 25. Interface vs abstract classSee also Overriding, Composition, Abstract class
Insertion sort: Sorting the way you sort playing cards in your hand: take the next element and slide it left into place among those already sorted. It is O(n²) in general but close to O(n) on data that is nearly sorted, and it is stable.; Learn it in 42. Searching and sorting algorithmsSee also Selection sort, Merge sort, Stable sort
instanceofalso instanceof pattern, type check: An operator that asks whether an object belongs to a class or interface: shape instanceof Circle is true for any circle and false for null. Written with a name, as in if (shape instanceof Circle c), it also hands you the object as a Circle called c.; Learn it in 18. Polymorphism and 30. Sealed types and pattern matchingSee also Upcasting and downcasting, Pattern matching, ClassCastException
intalso integer, whole number: The primitive type for whole numbers from -2,147,483,648 to 2,147,483,647. Going past either end wraps around without any error, so bigger values need a long, which reaches about 9.2 quintillion.; Learn it in 2. Variables, types, and input/output and 3. Operators, expressions, and castingSee also Primitive type, Integer overflow, Integer division
Integer cache: Java keeps ready-made Integer objects for the values -128 to 127 and reuses them when it boxes those numbers. So == on two boxed Integers is true for 127 but false for 128, which is why wrapper values are compared with equals.; Learn it in 32. Wrapper classes and autoboxingSee also Autoboxing, Wrapper class, equals
Integer divisionalso int division, truncation: Dividing one whole number by another in Java gives a whole number, with the fraction thrown away: 7 / 2 is 3. Make either side a double, as in 7 / 2.0 or (double) a / b, to get 3.5.; Learn it in 3. Operators, expressions, and castingSee also Remainder operator, Casting, int
Integer overflowalso overflow, wraparound: What happens when a whole-number result is too big for its type: it wraps around to the other end without any error. Integer.MAX_VALUE + 1 is -2147483648; use long, Math.addExact (which throws instead) or BigInteger when numbers can grow that large.; Learn it in 3. Operators, expressions, and casting, 37. Comparable, Comparator and sorting and 51. Money and exact numbers: BigDecimal and BigIntegerSee also int, BigInteger
Interfacealso implements, contract, default method: A named set of methods that a class promises to provide, with no instance fields. A class implements as many interfaces as it likes but extends only one class, and an interface can also supply finished default methods.; Learn it in 24. Interfaces, 25. Interface vs abstract class and 31. Designing classes wellSee also Abstract class, Polymorphism, Functional interface
Intermediate operationalso lazy evaluation, laziness, sorted, distinct: A stream step that returns another stream, such as filter, map, sorted, distinct and limit. Intermediate operations are lazy: they only describe the work, and nothing happens until a terminal operation pulls elements through one at a time.; Learn it in 53. Streams: processing collections step by step and 54. Collectors and stream recipesSee also Terminal operation, Stream, filter
IntStreamalso LongStream, DoubleStream, primitive stream, IntStream.range: A stream of plain int values with number methods built in: IntStream.rangeClosed(1, 5).sum() is 15, and sum(), average() and max() need no boxing. LongStream and DoubleStream do the same for long and double.; Learn it in 53. Streams: processing collections step by stepSee also Stream, Autoboxing, map (streams)
IOExceptionalso FileNotFoundException, NoSuchFileException: The checked exception for input or output that failed, such as a file that is missing, locked or unreadable. Its subclasses name the exact problem, for example FileNotFoundException and NoSuchFileException.; Learn it in 46. Reading files, 48. Exception handling and 49. Path and Files: modern file handlingSee also Checked exception, BufferedReader, Files
Iteratoralso hasNext, Iterable: An object that walks a collection one element at a time with hasNext() and next(). The for-each loop uses one behind the scenes, and the iterator's own remove() is the safe way to delete elements while you walk.; Learn it in 34. The Collections FrameworkSee also for-each loop, ConcurrentModificationException

J17

JAR filealso JAR, .jar, Java archive: A Java archive: one zip file holding compiled .class files and resources, so a program or library travels as a single file. The JDK's jar tool makes them, and the libraries your project depends on arrive as JARs.; Learn it in 67. Packaging and shipping a Java app and 65. Maven and Gradle: building real projectsSee also Executable JAR, Classpath, Dependency
Javadocalso doc comment, /**, API documentation: Documentation comments that start with /**, written just above a class or method to describe it. The javadoc tool turns them into the web pages you read for the standard library, and your IDE shows them when you hover over a name.; Learn it in 57. Annotations, docs, stack traces, and the IDESee also IDE, Annotation
JavaFXalso OpenJFX, GUI, graphical user interface: Java's modern toolkit for programs with a graphical user interface (GUI): windows, buttons, forms and charts. Since Java 11 it is no longer part of the JDK download, so you get the JavaFX SDK separately and add its modules when you compile and run.; Learn it in 76. JavaFX overview, features, and architecture and 77. Creating and running a JavaFX applicationQuick guide: Fix: JavaFX Runtime Components Are MissingSee also Stage, Scene graph, Swing
JavaFX Application Threadalso FX thread, UI thread, Platform.runLater, Task: The single thread that runs every JavaFX event handler and is the only one allowed to change what is on screen. Slow work such as a database query belongs in a Task on a background thread, and Platform.runLater(...) hands an update back to this thread.; Learn it in 76. JavaFX overview, features, and architecture and 81. Database support of a JavaFX applicationSee also Event handler, Thread, Event-driven programming
JDBCalso Java Database Connectivity, java.sql, SQLException: Java Database Connectivity, the standard API in java.sql for talking to a relational database through interfaces such as Connection, PreparedStatement and ResultSet. A driver for the particular database does the real work, and every failure arrives as a checked SQLException.; Learn it in 69. SQL, MySQL, and connecting with JDBC, 70. Creating and executing queries and 81. Database support of a JavaFX applicationSee also JDBC driver, Connection, PreparedStatement
JDBC driveralso driver, Connector/J: The library, a JAR file, that makes JDBC work for one database, such as MySQL Connector/J. It must be on the classpath when the program runs, or connecting fails with No suitable driver found.; Learn it in 69. SQL, MySQL, and connecting with JDBCSee also JDBC, Classpath, Connection
JDKalso Java Development Kit: The Java Development Kit, the one thing you install to write Java. It holds the JVM and the standard library, plus tools such as the compiler javac, the java launcher that runs programs, and jshell.; Learn it in 1. Your first Java programQuick guide: JDK vs JRE vs JVM: What Each One DoesSee also JRE, JVM, Compiler
JIT compileralso just-in-time compiler, JIT: A part of the JVM that spots the bytecode a program runs most often and translates it into the processor's own machine code while the program runs. It is why a Java program usually gets faster after it has been running for a moment.; Learn it in 1. Your first Java programSee also JVM, Bytecode
jlink: A JDK tool that builds a cut-down Java runtime holding only the modules your app uses. The result can run your app on a machine with no JDK installed, and it is often much smaller than a full JDK.; Learn it in 67. Packaging and shipping a Java appSee also Module, jpackage
JPAalso Jakarta Persistence, Hibernate, ORM, H2: Jakarta Persistence, the standard API for saving objects as database rows and loading them back, with the SQL written for you; in Spring Boot, the Hibernate library does this work. During development it often runs against H2, a small database that lives in the app's memory.; Learn it in 73. Saving data with Spring Data JPASee also @Entity, JpaRepository, JDBC
jpackage: A JDK tool that turns a Java app and its runtime into a normal installer: an .msi or .exe on Windows, a .dmg or .pkg on macOS, and a .deb or .rpm on Linux. People install it like any other program, without installing Java first.; Learn it in 67. Packaging and shipping a Java appSee also jlink, Executable JAR
JpaRepositoryalso repository, Spring Data repository, CrudRepository: A Spring Data interface you extend, as in interface TaskRepository extends JpaRepository<Task, Long>, and Spring writes the class behind it for you. You get save, findById, findAll and deleteById for free, and a method named like findByDone(boolean done) becomes a query.; Learn it in 73. Saving data with Spring Data JPASee also JPA, @Entity, CRUD
JREalso Java Runtime Environment: The Java Runtime Environment: the JVM plus the standard library, enough to run a compiled program but with no compiler. The JDK contains everything the JRE has, so to learn Java you install the JDK.; Learn it in 1. Your first Java programQuick guide: JDK vs JRE vs JVM: What Each One DoesSee also JDK, JVM
JShellalso REPL: A tool in the JDK that runs Java one line at a time and shows each result straight away, with no class and no main method. Type jshell in a terminal to start it and /exit to leave; it is handy for trying out a method before you use it in a program.; Learn it in 1. Your first Java program and 2. Variables, types, and input/outputSee also JDK, Compact source file
JSONalso JavaScript Object Notation, Jackson, ObjectMapper, DTO: A text format for data built from objects in braces, arrays in brackets, strings, numbers, true, false and null: {"name": "Ada", "age": 36}. The Jackson library's ObjectMapper turns JSON into Java objects and back, often into records whose only job is to carry data, called DTOs (data transfer objects).; Learn it in 71. Talking to the web: HttpClient and JSON and 72. Your first web API with Spring BootSee also Record, HttpClient, REST
JUnitalso JUnit 5, JUnit 6, JUnit Jupiter, @BeforeEach: The most widely used testing framework for Java: you mark test methods with @Test, and JUnit runs each one on a fresh object of the test class and reports which passed and which failed. A method marked @BeforeEach runs before every test to rebuild the starting point, and JUnit 5 and JUnit 6 share these annotations.; Learn it in 22. Testing your code with JUnitSee also Unit test, @Test, Assertion
JVMalso Java Virtual Machine: The program that runs Java bytecode. Every operating system has its own JVM, which is why the same .class file runs on Windows, macOS and Linux.; Learn it in 1. Your first Java programQuick guide: JDK vs JRE vs JVM: What Each One DoesSee also Bytecode, Compiler, JDK

L15

Lambda expressionalso lambda, arrow function, anonymous function, ->, effectively final: A short way to write a piece of behavior as a value: x -> x * 2 takes x and returns double it. A lambda can go wherever a functional interface is expected, as in list.removeIf(s -> s.isEmpty()), and it may only use local variables that are never reassigned, which Java calls effectively final.; Learn it in 28. Enums, lambdas, and functional interfaces, 53. Streams: processing collections step by step and 80. Event handling and GUI programsQuick guide: Anonymous Inner Class in Java, with ExamplesSee also Functional interface, Method reference, Stream
Layout panealso Pane, VBox, HBox, StackPane, GridPane, BorderPane: A JavaFX node that positions its children for you and rearranges them when the window changes size. VBox stacks them top to bottom, HBox left to right, StackPane on top of each other, and GridPane in rows and columns, which suits forms.; Learn it in 78. Nodes, controls, and layout panes and 79. Form creation using JavaFXSee also Node (JavaFX), Control, Scene graph
lengthalso length(), size(): How many elements something holds, asked three different ways: an array has the field a.length, a String has the method s.length(), and a collection has the method list.size().; Learn it in 6. Arrays, one dimension, 20. Strings, StringBuilder, StringBuffer and 7. ArrayList: a list that can growSee also Array, String, ArrayList
Linked listalso LinkedList, node, head, singly linked list, doubly linked list: A list built from nodes, where each node holds a value and a reference to the next node, and in a doubly linked list to the previous one too. Adding or removing at the front is fast, but reaching index i means walking i nodes from the head. Java's LinkedList is doubly linked, yet ArrayList is faster for most jobs, even where LinkedList looks cheaper on paper.; Learn it in 39. Linked lists: nodes and references and 41. How fast is it? Big-O in plain wordsSee also List, ArrayList, Deque
LinkedHashMapalso LinkedHashSet, insertion order: A HashMap that also remembers the order in which keys were first put in, and hands them back in that order. LinkedHashSet does the same for a set.; Learn it in 35. HashMap and HashSet: finding things fastSee also HashMap, TreeMap, Set
Listalso List interface: The collection interface for elements kept in order and reached by index, with duplicates allowed. ArrayList and LinkedList implement it, so you can declare List<String> names = new ArrayList<>(); and swap the class later.; Learn it in 7. ArrayList: a list that can grow and 34. The Collections FrameworkSee also ArrayList, Linked list, Collections Framework
Literalalso integer literal, string literal: A value written straight into the code, such as 42, 3.5, 'x', "hello", true or null. A whole-number literal is an int unless it ends in L, as in 5000000000L, which makes it a long.; Learn it in 2. Variables, types, and input/outputSee also Primitive type, String, Escape sequence
Load factor: How full a hash table may get before it grows, as entries divided by buckets. A HashMap starts with 16 buckets and a load factor of 0.75, so the 13th entry makes it double to 32 buckets and move every entry to its new bucket.; Learn it in 35. HashMap and HashSet: finding things fast and 43. Inside ArrayList and HashMap: build your ownSee also Hash collision, HashMap, Dynamic array
LocalDatealso java.time, LocalTime, LocalDateTime, DayOfWeek: A date with no time of day and no time zone, such as LocalDate.of(2025, 3, 14), which prints as 2025-03-14. It never changes: plusDays(30) returns a new date. LocalTime holds a time of day, LocalDateTime holds both, and getDayOfWeek() gives a DayOfWeek such as FRIDAY.; Learn it in 50. Dates and times with java.timeSee also Period, DateTimeFormatter, Immutable
Log levelalso levels, ERROR, WARN, INFO, DEBUG, TRACE: How serious a log message is. SLF4J's levels, from most to least serious, are ERROR, WARN, INFO, DEBUG and TRACE, and setting a logger to INFO hides the DEBUG and TRACE lines without touching the code.; Learn it in 66. Logging instead of printlnSee also Logging, SLF4J
Logback: A logging library that does the writing behind SLF4J: it decides where log lines go, such as the console or a file, how each line looks and which levels to keep, usually from a logback.xml file. Spring Boot uses it by default.; Learn it in 66. Logging instead of printlnSee also SLF4J, Logging, Log level
Loggingalso logger, log, java.util.logging, System.Logger: Recording what a running program does through a logger instead of println, usually with a level, a time and the class name on every line. The JDK has java.util.logging and System.Logger built in, and most projects use SLF4J with Logback.; Learn it in 66. Logging instead of printlnSee also Log level, SLF4J, Logback
Logic erroralso bug, logic bug: A mistake that lets the program compile and run but gives the wrong answer, such as < where you meant <=. Java cannot spot it for you: you find it by knowing what the right result should be, and tests catch it early.; Learn it in 9. Reading errors and debugging and 22. Testing your code with JUnitSee also Debugging, Unit test, Compile error
Logical operatoralso &&, ||, !, and, or, not, short-circuit: && (and), || (or) and ! (not) combine boolean values into one. && and || short-circuit: they skip the right-hand side when the left side already decides the answer, so s != null && s.isEmpty() never calls a method on null.; Learn it in 3. Operators, expressions, and casting and 4. Making decisions: if, else and switchSee also boolean, Operator precedence, if statement
LTSalso long-term support: Long-term support: a Java release that gets fixes and security updates for years. Java 8, 11, 17, 21 and 25 are LTS releases, and this course uses Java 25.; Learn it in 1. Your first Java programSee also JDK

M11

main methodalso main, public static void main, entry point: The method where a program starts: public static void main(String[] args). The java command looks for it in the class you run and calls it first, and since Java 25 a plain void main() works too.; Learn it in 1. Your first Java program and 26. The static and final keywordsSee also Method, static, Compact source file
Mapalso Map interface, key-value pairs, Map.Entry, entrySet: The interface for looking up a value by its key, where each key appears at most once: put("kiwi", 3) stores a pair and get("kiwi") finds 3. entrySet() hands back each pair as a Map.Entry with getKey() and getValue().; Learn it in 34. The Collections Framework and 35. HashMap and HashSet: finding things fastSee also HashMap, TreeMap, LinkedHashMap
map (streams)also Stream.map, mapToInt: The stream operation that turns each element into a new value: names.stream().map(String::length) turns names into their lengths. It has nothing to do with the Map collection, and mapToInt does the same job but gives an IntStream.; Learn it in 53. Streams: processing collections step by stepSee also filter, flatMap, IntStream
Mavenalso mvn, mvnw, Maven Wrapper: A build tool that compiles a project, downloads its libraries, runs its tests and packages it, all from the description in pom.xml. It expects code in src/main/java and tests in src/test/java, and the wrapper script ./mvnw runs the right Maven version without installing it first.; Learn it in 65. Maven and Gradle: building real projectsSee also pom.xml, Gradle, Dependency
Memoizationalso caching, memo: Storing each answer a method works out, often in a HashMap, so the same question is never computed twice. It turns a recursive Fibonacci that would make billions of calls for fib(50) into one that makes about a hundred.; Learn it in 40. Recursion: methods that call themselvesSee also Recursion, HashMap
Mergealso git merge, merge conflict, conflict: Bringing one branch's commits into another: git merge login, run while on main, adds the login work to main. When both branches changed the same lines, Git stops with a merge conflict and marks the spot between <<<<<<< and >>>>>>>, and you edit the file to the right result before committing.; Learn it in 64. Git and GitHub: saving your workSee also Branch, Pull request, Commit
Merge sortalso divide and conquer: Sorting by splitting the data in half, sorting each half the same way, and merging the two sorted halves into one. This split, solve and combine approach is called divide and conquer; merge sort always takes O(n log n) steps, is stable, and needs extra memory for merging.; Learn it in 42. Searching and sorting algorithmsSee also O(n log n), Stable sort, Recursion
Methodalso function, instance method: A named block of code that belongs to a class, with a return type, a name, parameters and a body: int area() { return width * height; }. Java has no free-standing functions; every method lives in a class.; Learn it in 12. Methods: parameters and return valuesSee also Parameter, Return value, Overloading
Method referencealso ::: A lambda that only calls an existing method, written with ::. String::length means s -> s.length(), and System.out::println means x -> System.out.println(x).; Learn it in 28. Enums, lambdas, and functional interfaces and 53. Streams: processing collections step by stepSee also Lambda expression, Functional interface
Modulealso module-info.java, JPMS, Java Platform Module System: A named group of packages with a module-info.java file that lists the modules it needs (requires) and the packages it lets others use (exports). The JDK itself has been split into modules, such as java.base and java.sql, since Java 9.; Learn it in 67. Packaging and shipping a Java app and 77. Creating and running a JavaFX applicationSee also Module path, jlink, Package
Module pathalso --module-path, --add-modules: Where the JVM looks for modules, the module system's version of the classpath, set with --module-path. --add-modules names the modules to load, which is how a JavaFX program is compiled and run from the command line.; Learn it in 77. Creating and running a JavaFX application and 67. Packaging and shipping a Java appSee also Module, Classpath, JavaFX

N5

Nested classalso inner class, static nested class, anonymous class: A class declared inside another class. A static nested class is an ordinary class kept inside for tidiness, an inner class (no static) belongs to an object of the outer class, and an anonymous class is declared and created in one expression, as in new Comparator<String>() { ... }.; Learn it in 27. Inner classes and OOP consolidation and 80. Event handling and GUI programsQuick guide: Anonymous Inner Class in Java, with ExamplesSee also Lambda expression, static, Interface
Node (JavaFX)also Node, Parent, Group, Region: The base class of everything that can appear in a JavaFX scene, from a Button to a VBox. A node that holds other nodes is a Parent, such as a Group or a layout pane, and a scene's root node must be a Parent.; Learn it in 78. Nodes, controls, and layout panes and 76. JavaFX overview, features, and architectureSee also Scene graph, Layout pane, Control
nullalso null reference: The value of a reference variable that points at no object. Calling a method or reading a field through null throws a NullPointerException, and primitives such as int can never be null.; Learn it in 2. Variables, types, and input/output, 15. The this keyword and object references and 55. Optional: a value that might be missingSee also NullPointerException, Reference, Optional
NullPointerExceptionalso NPE, helpful NullPointerException: The exception thrown when code uses a null reference as if it pointed at an object, for example calling name.length() while name is null. Its message names what was null, as in Cannot invoke "String.length()" because "this.name" is null.; Learn it in 15. The this keyword and object references, 9. Reading errors and debugging and 55. Optional: a value that might be missingSee also null, Optional, Stack trace
NumberFormatException: The exception thrown when text cannot be read as a number, for example by Integer.parseInt("12a"). Its message quotes the bad text, For input string: "12a", and it is unchecked, a kind of IllegalArgumentException.; Learn it in 9. Reading errors and debugging, 32. Wrapper classes and autoboxing and 80. Event handling and GUI programsSee also parseInt, IllegalArgumentException, try-catch

O12

O(1)also constant time: Constant time: the work stays the same however big the input gets. Reading a[i] from an array is O(1), and so is get on a HashMap on average.; Learn it in 41. How fast is it? Big-O in plain wordsSee also Big-O, HashMap, O(n)
O(log n)also logarithmic time: Logarithmic time: each step throws away a fixed share of what is left, usually half. Binary search over a million sorted items needs at most 20 looks, and finding a key in a TreeMap is O(log n) too.; Learn it in 41. How fast is it? Big-O in plain words and 42. Searching and sorting algorithmsSee also Big-O, Binary search, TreeMap
O(n log n)also linearithmic time: The growth rate of the best general sorting algorithms, such as merge sort and the sorts behind Arrays.sort and List.sort. Sorting a million items takes about 20 million steps, where an O(n²) sort would need around a trillion.; Learn it in 41. How fast is it? Big-O in plain words and 42. Searching and sorting algorithmsSee also Merge sort, Big-O, O(n^2)
O(n)also linear time: Linear time: the work grows in step with the input, so twice the items take about twice as long. Looking at every element once, as linear search and ArrayList.contains do, is O(n).; Learn it in 41. How fast is it? Big-O in plain wordsSee also Big-O, Binary search, O(1)
O(n^2)also O(n²), quadratic time, O(n squared): Quadratic time: twice the input means about four times the work. Two nested loops over the same data, such as comparing every pair of items, are O(n²), and a million items would mean about a trillion steps.; Learn it in 41. How fast is it? Big-O in plain words and 42. Searching and sorting algorithmsSee also Big-O, Selection sort, Two-dimensional array
Objectalso instance, new, instantiate: One thing built from a class with new, such as new Dog("Rex"), with its own copy of every field. Each new makes a separate object on the heap and hands back a reference to it, and the object is called an instance of its class.; Learn it in 10. Why objects? Class vs object and 11. Creating classes and objectsSee also Class, Reference, Constructor
Object-oriented programmingalso OOP, abstraction, four pillars: Building a program from objects that keep data and the methods that work on it together. Its four big ideas are encapsulation, inheritance, polymorphism and abstraction, which means showing what something does while hiding how it does it.; Learn it in 10. Why objects? Class vs object and 27. Inner classes and OOP consolidationSee also Class, Object, Encapsulation
Operator precedencealso precedence, order of operations: The rules for which operator goes first when an expression has several. *, / and % come before + and -, so 2 + 3 * 4 is 14, and parentheses change the order: (2 + 3) * 4 is 20.; Learn it in 3. Operators, expressions, and castingSee also Logical operator, Integer division, Remainder operator
Optionalalso Optional.of, Optional.ofNullable, Optional.empty, orElse, orElseThrow: A box that holds one value or nothing, used as a return type to say “there may be no result” instead of returning null. Get the value out with orElse(fallback), orElseThrow() or ifPresent(...), and use map to change it only if it is there.; Learn it in 55. Optional: a value that might be missing and 53. Streams: processing collections step by stepSee also null, NullPointerException, Stream
Overloadingalso method overloading, constructor overloading, method signature: Writing several methods or constructors with the same name but different parameter lists, such as add(int a, int b) and add(double a, double b). The compiler picks the version whose parameters match the arguments, and a different return type alone is not enough.; Learn it in 12. Methods: parameters and return values and 13. ConstructorsQuick guide: Method Overloading vs Overriding in JavaSee also Method, Overriding, Constructor
@Overridealso Override annotation: An annotation on a method saying it is meant to override one from a parent class or interface. If there is no such method, for example because of a typo in the name, the compiler reports an error instead of quietly adding a new method.; Learn it in 17. Method overriding and super and 57. Annotations, docs, stack traces, and the IDESee also Overriding, Annotation
Overridingalso method overriding, override: A subclass replacing an inherited method with its own version that has the same name and parameters. When the method is called, the object's real class decides which version runs.; Learn it in 17. Method overriding and super and 18. PolymorphismQuick guide: Method Overloading vs Overriding in JavaSee also @Override, Overloading, Dynamic dispatch

P17

Packagealso package declaration, fully qualified name, standard library: A named group of related classes, declared on a file's first line with package com.shop.billing; and kept in matching folders. A class's full name includes its package, as in java.util.ArrayList, and the JDK's standard library is organized the same way, into packages such as java.util and java.time.; Learn it in 44. Packages and importsQuick guide: Java import Statement, Explained with ExamplesSee also import, Classpath, Access modifier
Parameteralso argument: A variable in a method's declaration that receives a value when the method is called. In void greet(String name), name is the parameter, and in the call greet("Ada"), "Ada" is the argument that fills it.; Learn it in 12. Methods: parameters and return valuesSee also Method, Pass by value, Return value
Parameterized testalso @ParameterizedTest, @ValueSource, @CsvSource: One JUnit test method that runs once for each row of inputs you list: with @ParameterizedTest and @CsvSource({"1, 1", "2, 4", "3, 9"}), a test of squaring runs three times. It replaces copies of a test that differ only in their values.; Learn it in 22. Testing your code with JUnitSee also @Test, Edge case
parseIntalso Integer.parseInt, Double.parseDouble, valueOf, string to int: Turns text into a number: Integer.parseInt("42") gives the int 42, and Double.parseDouble does the same for decimals. Text that is not a number, such as "4x" or an empty string, throws a NumberFormatException.; Learn it in 9. Reading errors and debugging, 32. Wrapper classes and autoboxing and 45. Scanner and console applicationsSee also NumberFormatException, Wrapper class, Scanner
Pass by valuealso pass by reference, call by value: Java always copies an argument's value into the parameter. A method that gets an int gets a copy of the number, so the caller's variable cannot change; one that gets an object gets a copy of the reference, so it can change the object but cannot make the caller's variable point somewhere else.; Learn it in 12. Methods: parameters and return valuesSee also Parameter, Reference
Pathalso Path.of, Paths.get, relative path, absolute path, working directory: An object naming a file or folder location, made with Path.of("data", "scores.txt"). Making one never touches the disk, so it can name a file that does not exist yet, and a relative path is looked up from the working directory, the folder the program was started in.; Learn it in 49. Path and Files: modern file handling and 47. Writing filesQuick guide: How to Read a File in Java, with ExamplesSee also Files, IOException
Pattern and Matcheralso Pattern, Matcher, Pattern.compile, find: The two java.util.regex classes for working with a regex. Pattern.compile("\\d+") turns the regex into a reusable Pattern, and pattern.matcher(text) gives a Matcher for one text: find() moves to the next match, group() returns the text that matched, and matches() asks whether the whole text fits.; Learn it in 52. Regular expressions: patterns in textSee also Regular expression, Capturing group
Pattern matchingalso type pattern, record pattern, guard, when, switch pattern: Testing a value's shape and naming its parts in one step. if (obj instanceof String s) checks the type and gives you s, and a record pattern such as Point(int x, int y) takes a record apart into its components. In a switch, a guard adds a condition: case Circle c when c.radius() > 10 ->.; Learn it in 30. Sealed types and pattern matching and 56. Modern Java syntax: var, text blocks and moreSee also instanceof, Record, Switch expression
Periodalso Period.between: An amount of time in years, months and days, such as Period.ofMonths(3). Period.between(start, end) splits the gap between two dates into those parts, so its getDays() is only the days left over after the whole months, not the total.; Learn it in 50. Dates and times with java.timeSee also Duration, ChronoUnit, LocalDate
Polymorphismalso many forms: One piece of code working with many kinds of object through a type they share. A loop over a List<Shape> can call area() on circles and squares alike, and each object runs its own version.; Learn it in 18. Polymorphism and 24. InterfacesSee also Dynamic dispatch, Interface, Upcasting and downcasting
pom.xmlalso POM, groupId, artifactId: The file that describes a Maven project: its coordinates (groupId, artifactId and version), the Java version and the dependencies it needs. Maven reads it to know what to download and how to build.; Learn it in 65. Maven and Gradle: building real projectsSee also Maven, Dependency
PreparedStatementalso Statement, placeholder, executeQuery, executeUpdate: A JDBC statement whose SQL has ? placeholders that you fill with typed values: ps.setString(1, name) fills the first. executeQuery() runs a SELECT and returns a ResultSet, and executeUpdate() runs other SQL and returns how many rows changed. The values travel as data, never as SQL, which blocks SQL injection.; Learn it in 70. Creating and executing queries and 81. Database support of a JavaFX applicationSee also SQL injection, ResultSet, Connection
Primitive typealso primitive: One of Java's eight built-in kinds of simple value: byte, short, int, long, float, double, char and boolean. A primitive variable holds the value itself, not a reference to an object.; Learn it in 2. Variables, types, and input/outputSee also Wrapper class, Autoboxing, int
printlnalso System.out.println, print, printf, System.out: Prints a value and then moves to a new line: System.out.println("Hi"). print stays on the same line, and printf fills a template with values, so System.out.printf("%.2f%n", 3.14159) prints 3.14.; Learn it in 1. Your first Java program, 2. Variables, types, and input/output and 51. Money and exact numbers: BigDecimal and BigIntegerSee also String, main method
PriorityQueuealso priority queue, binary heap, min-heap: A queue that always hands out its smallest element first, by natural order or by a Comparator you give it. Inside it keeps a binary heap, so printing it shows the elements in heap order, not sorted order.; Learn it in 38. Stacks, queues and dequesSee also Queue, Comparator, Comparable
Pull requestalso PR, merge request: A request on GitHub to merge one branch into another, where teammates read the changes, comment and see automated test results before anyone merges. It is where code review usually happens.; Learn it in 64. Git and GitHub: saving your work and 74. Shipping it: Docker and GitHub ActionsSee also Branch, Merge, Code review
Pushalso git push, git pull, remote, origin: Sending your local commits to a remote repository, such as one on GitHub: git push origin main. The opposite direction, git pull, brings the remote's new commits into your branch, and origin is the usual name of the remote you cloned from.; Learn it in 64. Git and GitHub: saving your workSee also Repository, GitHub, Commit

Q3

Quantifieralso *, +, {n,m}, greedy, reluctant: A regex symbol that says how many times the part before it may repeat: * zero or more, + one or more, ? zero or one, and {2,4} two to four times. Quantifiers are greedy and match as much as they can, unless a ? follows them, as in .*?.; Learn it in 52. Regular expressions: patterns in textSee also Regular expression, Character class
Quantum Toolkitalso Prism, Glass, JavaFX architecture: The layer of JavaFX that ties the scene graph to the engines below it: Prism, which draws every frame, using the graphics card when it can, and Glass, which creates the native windows and passes mouse and keyboard input up as events. Your own code talks only to the JavaFX API above them.; Learn it in 76. JavaFX overview, features, and architectureSee also Scene graph, JavaFX, Event-driven programming
Queuealso FIFO, first in, first out, offer, poll: A collection that hands out elements first in, first out, like a line at a shop: offer adds at the back and poll takes from the front. ArrayDeque is the usual class for a plain queue.; Learn it in 34. The Collections Framework and 38. Stacks, queues and dequesSee also Stack, Deque, PriorityQueue

R17

Race conditionalso data race, shared state, atomic: A bug where the result depends on the exact timing of threads that share data. Two threads running count++ can both read 5 and both write 6, losing an update, because count++ is three steps (read, add, write) instead of one atomic step that no thread can interrupt.; Learn it in 60. Thread creation and synchronizationSee also synchronized, AtomicInteger, Thread safety
Recordalso record class, record component, data class: A class for carrying a fixed group of values, declared in one line: record Point(int x, int y) {}. Java writes the constructor, the accessors x() and y(), and equals, hashCode and toString from those components, and the fields are final.; Learn it in 29. Records: data classes in one line and 30. Sealed types and pattern matchingSee also Compact constructor, Immutable, Pattern matching
Recursionalso recursive method, recursive case: A method solving a problem by calling itself on a smaller version of the same problem. factorial(n) returns n * factorial(n - 1), and a base case such as n == 0 stops the calls.; Learn it in 40. Recursion: methods that call themselvesSee also Base case, Call stack, StackOverflowError
reducealso Stream.reduce, fold: The stream operation that combines all elements into one value from a starting value and a rule: nums.stream().reduce(0, Integer::sum) adds them up. Ready-made operations such as count(), max(...) and an IntStream's sum() cover the common cases.; Learn it in 53. Streams: processing collections step by stepSee also Terminal operation, Stream, IntStream
ReentrantLockalso Lock, lock(), unlock(), tryLock: A lock object that does the job of synchronized with more control, such as tryLock() to give up instead of waiting forever. Always call unlock() in a finally block, so the lock is released even when an exception is thrown.; Learn it in 63. Safe sharing: atomics, locks and concurrent collectionsSee also synchronized, Deadlock, finally
Refactoringalso refactor: Changing the structure of code, such as renaming, splitting a long method or removing repeated code, without changing what it does. Tests make refactoring safe, because they show at once if the behavior changed.; Learn it in 22. Testing your code with JUnitSee also Test-driven development, Unit test, IDE
Referencealso object reference, pointer, address, aliasing: What a variable of a class type actually holds: the address of an object, not the object itself. Dog b = a; copies the reference, so both names reach the same dog, and a change made through one shows through the other.; Learn it in 11. Creating classes and objects and 15. The this keyword and object referencesSee also Object, Heap, null
Regular expressionalso regex, regexp: A pattern that describes the shape of text, such as \d{3}-\d{4} for a number like 555-1234. matches, split, replaceAll and the Pattern and Matcher classes all take one, and in Java source every backslash is written twice: "\\d+".; Learn it in 52. Regular expressions: patterns in textSee also Pattern and Matcher, Character class, Quantifier
Remainder operatoralso %, modulo, mod, modulus: % gives what is left over after whole-number division: 17 % 5 is 2. It tells you whether a number is even (n % 2 == 0), and its result takes the sign of the left-hand number, so -7 % 3 is -1.; Learn it in 3. Operators, expressions, and casting and 5. Loops: for, while, do-whileSee also Integer division, Operator precedence
Repositoryalso repo, git init, git clone: A project folder that Git tracks, with the full history of every commit stored in a hidden .git folder inside it. git init makes a new one, and git clone copies an existing one, history and all.; Learn it in 64. Git and GitHub: saving your workSee also Git, Commit, Push
RESTalso RESTful, REST API: A style of web API where URLs name things, such as /tasks/42, and HTTP methods say what to do with them: GET /tasks lists the tasks and DELETE /tasks/42 removes one. Answers usually come back as JSON with a fitting status code.; Learn it in 72. Your first web API with Spring Boot and 75. Capstone: build and ship a small web APISee also HTTP, @RestController, API
@RestControlleralso controller: The Spring annotation for a class whose methods answer web requests, with each return value written into the response body, usually as JSON. The methods inside are tied to URLs with annotations such as @GetMapping.; Learn it in 72. Your first web API with Spring BootSee also @GetMapping, Spring Boot, REST
ResultSetalso cursor, next(), getString, getInt: The rows a SELECT returns, read one row at a time through a cursor that starts before the first row. while (rs.next()) steps onto each row in turn, and rs.getString("name") or rs.getInt("age") reads a column of the current row.; Learn it in 69. SQL, MySQL, and connecting with JDBC and 70. Creating and executing queriesSee also PreparedStatement, SQL, JDBC
Return valuealso return, return type, void: The value a method hands back to its caller with return; its type is written before the method's name. A method declared void returns nothing, and return; on its own just ends it early.; Learn it in 12. Methods: parameters and return valuesSee also Method, Parameter
RoundingModealso HALF_UP, HALF_EVEN, banker's rounding: An enum that tells BigDecimal how to round. HALF_UP rounds 2.5 to 3, the way most people learn at school, while HALF_EVEN, called banker's rounding, sends a 5 to the nearest even digit, so 2.5 becomes 2 and 3.5 becomes 4.; Learn it in 51. Money and exact numbers: BigDecimal and BigIntegerSee also BigDecimal
Runnable: A functional interface with one method, void run(), that describes a job for a thread to do. You can pass a lambda: new Thread(() -> System.out.println("working")).start();.; Learn it in 59. Introduction to threads and 61. Thread pools, executors and futuresSee also Thread, Future, Functional interface
Runtime erroralso crash, ArithmeticException: A failure while the program runs, after it compiled fine, such as 7 / 0, which throws ArithmeticException: / by zero, or an array index past the end. Java reports it by throwing an exception, and if nothing catches it the program stops with a stack trace.; Learn it in 9. Reading errors and debugging and 48. Exception handlingSee also Exception, Stack trace, Compile error

S31

Scanneralso System.in, nextInt, nextLine, standard input: A class that reads input piece by piece: new Scanner(System.in) reads what the user types, nextInt() the next whole number and nextLine() the rest of the line. After nextInt(), the line break from the Enter key is still waiting, so a nextLine() straight after it returns an empty string.; Learn it in 4. Making decisions: if, else and switch and 45. Scanner and console applicationsSee also parseInt, BufferedReader, while loop
Scene: The content shown inside a stage, built around one root node: new Scene(root, 400, 300) makes a scene 400 pixels wide and 300 high. A stage shows one scene at a time, so swapping the scene swaps the whole window's content.; Learn it in 76. JavaFX overview, features, and architecture and 77. Creating and running a JavaFX applicationSee also Stage, Scene graph, Node (JavaFX)
Scene graphalso root node, branch node, leaf node, node tree: The tree of nodes that describes everything in a JavaFX window. The root node at the top holds branch nodes, such as layout panes, which hold leaf nodes, such as buttons and text; when the tree changes, JavaFX redraws the window.; Learn it in 76. JavaFX overview, features, and architecture and 78. Nodes, controls, and layout panesSee also Node (JavaFX), Scene, Layout pane
Sealed classalso sealed, sealed interface, permits, non-sealed: A class or interface that names every class allowed to extend it: sealed interface Shape permits Circle, Square {}. Each permitted class must be final, sealed or non-sealed, and a switch over the type that covers them all needs no default.; Learn it in 30. Sealed types and pattern matchingSee also Pattern matching, Switch expression, Record
Selection sort: Sorting by finding the smallest remaining element and swapping it into the next position, over and over. It always takes O(n²) comparisons and is not stable, so it is for learning how sorting works rather than for real code.; Learn it in 42. Searching and sorting algorithmsSee also Insertion sort, Merge sort, O(n^2)
Setalso Set interface: The collection interface that refuses duplicates: adding a value that is already there changes nothing, and add returns false. HashSet is the fast everyday choice, LinkedHashSet keeps insertion order and TreeSet keeps the values sorted.; Learn it in 34. The Collections Framework and 35. HashMap and HashSet: finding things fastSee also HashSet, TreeSet, equals
SLF4Jalso Simple Logging Facade for Java, LoggerFactory, parameterized message, {}: The Simple Logging Facade for Java: the logging API your code calls, as in log.info("User {} logged in", name), where each {} is filled from the next argument. A separate library, usually Logback, does the actual writing, so you can swap it without changing your code.; Learn it in 66. Logging instead of println and 72. Your first web API with Spring BootSee also Logback, Logging, Log level
SOLIDalso single responsibility principle, open/closed principle, Liskov substitution, interface segregation, dependency inversion: Five design guidelines named by their first letters: single responsibility (each class has one job, so one reason to change), open/closed (add behavior with new code instead of editing old code), Liskov substitution (a subclass keeps every promise of its parent), interface segregation (small, focused interfaces) and dependency inversion (depend on interfaces, not concrete classes).; Learn it in 31. Designing classes wellSee also Composition, Dependency injection, Interface
Spring Bootalso Spring, Spring Initializr, application.properties: A framework for building Java web services on top of Spring: it starts a web server and sets up JSON handling and database access from sensible defaults. You create a project at start.spring.io, the Spring Initializr, and change settings such as server.port=8081 in application.properties.; Learn it in 72. Your first web API with Spring Boot, 73. Saving data with Spring Data JPA and 75. Capstone: build and ship a small web APIQuick guide: How to Build a Web Application with Spring BootSee also @RestController, Dependency injection, JPA
SQLalso Structured Query Language, query: Structured Query Language, the language for working with relational databases. You describe the result you want, such as SELECT name FROM students WHERE grade > 80, and the database works out how to find it.; Learn it in 69. SQL, MySQL, and connecting with JDBC and 70. Creating and executing queriesSee also Database, CRUD, SQL injection
SQL injection: An attack where text a user types is glued into SQL and runs as part of it: a name such as x' OR '1'='1 can turn a query about one user into a query about every user. Filling ? placeholders in a PreparedStatement, instead of joining strings with +, stops it.; Learn it in 70. Creating and executing queriesSee also PreparedStatement, SQL
Stable sortalso stability, stable: A sort that keeps elements with equal keys in the order they already had. Sort students by name, then stably by grade, and each grade's students stay in name order; List.sort and merge sort are stable, selection sort is not.; Learn it in 37. Comparable, Comparator and sorting and 42. Searching and sorting algorithmsSee also Merge sort, Arrays.sort, Comparator
Stackalso LIFO, last in, first out, push, pop, peek: A collection where the newest element comes out first, like a pile of plates: push adds to the top, pop takes the top off and peek looks at it. Use an ArrayDeque as a stack; the older Stack class still works, but its own documentation recommends a Deque instead.; Learn it in 38. Stacks, queues and dequesSee also Deque, Queue, Call stack
Stack tracealso traceback, exception trace: The report Java prints when an exception is not caught: the exception's name and message on the first line, then one at line per method that was running, newest first. Read down to the first at line in your own code to find where it broke.; Learn it in 9. Reading errors and debugging, 48. Exception handling and 57. Annotations, docs, stack traces, and the IDESee also Exception, Call stack, Debugging
StackOverflowError: The error thrown when the call stack runs out of room, almost always because a recursive method never reaches its base case. It is an Error, not an Exception, and its stack trace shows the same method over and over.; Learn it in 40. Recursion: methods that call themselvesSee also Recursion, Base case, Call stack
Stagealso window, primary stage, StageStyle: A JavaFX window. The platform hands your start method the primary stage, and you give it a scene with setScene, a title with setTitle, and then call show().; Learn it in 76. JavaFX overview, features, and architecture and 77. Creating and running a JavaFX applicationSee also Scene, Application (JavaFX)
Staging areaalso index, git add, staging: Where you gather the changes that should go into the next commit. git add Main.java stages that file's current changes, so one commit can hold just the related edits, and git status shows what is staged.; Learn it in 64. Git and GitHub: saving your workSee also Commit, Git
staticalso static field, static method, class variable, utility class: Marks a field or method that belongs to the class itself instead of to each object. A static counter is one number shared by all the objects, a static method such as Math.max(3, 7) is called on the class name, and a class with only static methods, such as Math, is called a utility class.; Learn it in 26. The static and final keywords and 69. SQL, MySQL, and connecting with JDBCSee also final, main method, Field
Static typingalso statically typed, dynamic typing, type checking: Every variable has a type that is fixed in the source code, and the compiler checks every use of it before the program runs. Putting text into an int variable is a compile error in Java, while a dynamically typed language such as Python finds that mistake only when the line runs.; Learn it in 2. Variables, types, and input/outputSee also Variable, Compile error, var
Status codealso HTTP status, 200, 404, 500: The three-digit number at the start of an HTTP response that says how the request went. Codes in the 200s mean success (200 OK, 201 Created), the 400s mean the request was wrong (400 Bad Request, 404 Not Found), and the 500s mean the server failed.; Learn it in 71. Talking to the web: HttpClient and JSON and 72. Your first web API with Spring BootSee also HTTP, REST
Strategy patternalso strategy: Putting each way of doing one job in its own object behind a shared interface, so code can switch between them without a chain of ifs. A Comparator handed to sort is a strategy for ordering, and a lambda is often the whole strategy.; Learn it in 31. Designing classes wellSee also Comparator, Interface, Factory method
Streamalso Stream API, java.util.stream, pipeline: A sequence of values flowing through a pipeline of steps, usually made from a collection with list.stream(). You describe the result, as in names.stream().filter(n -> n.length() > 3).map(String::toUpperCase).toList(), and nothing runs until a terminal operation asks for it. It is unrelated to the byte streams in java.io.; Learn it in 53. Streams: processing collections step by step and 54. Collectors and stream recipesSee also Intermediate operation, Terminal operation, Lambda expression
Stringalso text, string concatenation: The class for text, written in double quotes: "hello". + joins strings, and methods such as toUpperCase() and substring(1, 3) return a new String, because a String never changes. Compare two strings with equals, never ==.; Learn it in 2. Variables, types, and input/output, 20. Strings, StringBuilder, StringBuffer and 21. String practice problemsSee also StringBuilder, Immutable, equals
String poolalso string interning, intern: A store where Java keeps one shared copy of each string literal, so two "hi" literals in your code are the same object. Strings built while the program runs, such as with new String(...) or + on variables, are usually separate objects, which is why == on strings gives surprising answers.; Learn it in 20. Strings, StringBuilder, StringBufferSee also String, equals, Immutable
StringBuilderalso StringBuffer: A changeable sequence of characters for building text piece by piece: sb.append("x") adds to the same object instead of making a new String each time. Use it in loops and call toString() at the end; StringBuffer is an older, thread-safe twin that is a little slower.; Learn it in 20. Strings, StringBuilder, StringBuffer and 70. Creating and executing queriesSee also String, Immutable
Structured concurrencyalso StructuredTaskScope: Treating a group of related tasks that run on different threads as one unit, so they start together, finish together and are cancelled together if one fails. Java's StructuredTaskScope for this is still a preview API in Java 25, so it needs the --enable-preview flag.; Learn it in 62. Virtual threadsSee also Virtual thread, ExecutorService
superalso super(), super.method(): The keyword for reaching the parent class from a subclass. super.describe() runs the parent's version of a method you overrode, and super(...) in a constructor runs the parent's constructor.; Learn it in 16. Inheritance and 17. Method overriding and superQuick guide: this vs super in Java, with ExamplesSee also Overriding, Constructor, Inheritance
Swingalso AWT, Abstract Window Toolkit, javax.swing: Java's older desktop toolkit, in javax.swing since Java 1.2 in 1998, which paints its own buttons and menus in Java. It came after AWT, the first toolkit, which asks the operating system to draw each control; both still ship with the JDK, and JavaFX is the newer choice.; Learn it in 76. JavaFX overview, features, and architectureSee also JavaFX
Switch expressionalso arrow case, yield, exhaustive switch, exhaustiveness: A switch that produces a value: String size = switch (n) { case 1 -> "small"; default -> "large"; };. It must be exhaustive, covering every possible value, so over an enum or a sealed type you can list every case without a default, and a missing case is a compile error. A case with a block hands back its value with yield.; Learn it in 4. Making decisions: if, else and switch, 56. Modern Java syntax: var, text blocks and more and 30. Sealed types and pattern matchingSee also switch statement, Sealed class, Pattern matching
switch statementalso switch, case, default, fall-through: Picks one of several branches by comparing a value with each case, with default for anything else. In the colon form, case 1:, execution falls through into the cases below until a break, a classic bug; the arrow form, case 1 ->, runs only its own case.; Learn it in 4. Making decisions: if, else and switchSee also Switch expression, break and continue, if statement
synchronizedalso lock, monitor, synchronized block: A keyword that lets only one thread at a time run code guarded by the same object's lock. Other threads wait their turn, so steps such as count++ behave as one step that nothing can cut into.; Learn it in 60. Thread creation and synchronizationSee also Race condition, ReentrantLock, Deadlock

T18

Terminal operationalso toList, count, forEach, collect: The last step of a stream pipeline, which produces a result or an action and starts the work: toList(), count(), forEach(...), collect(...) or reduce(...). A stream can run only one, and using it again throws an IllegalStateException.; Learn it in 53. Streams: processing collections step by stepSee also Intermediate operation, Collectors, reduce
Ternary operatoralso ?:, conditional operator: A one-line if-else that produces a value: condition ? valueIfTrue : valueIfFalse. For example, String label = age >= 18 ? "adult" : "minor";.; Learn it in 4. Making decisions: if, else and switchSee also if statement, Switch expression
@Test: The JUnit annotation that marks a method as a test, such as @Test void emptyCartTotalsZero(). JUnit finds and runs every such method, and the test fails if an assertion fails or an exception escapes.; Learn it in 22. Testing your code with JUnitSee also JUnit, Assertion, Annotation
Test-driven developmentalso TDD, red, green, refactor: Writing a failing test first, then the simplest code that makes it pass, then tidying the code while the tests stay green. The cycle is called red, green, refactor, and it repeats for each small piece of behavior.; Learn it in 22. Testing your code with JUnitSee also Unit test, Refactoring
Text blockalso """, multi-line string: A string literal that spans several lines between triple quotes, """, where line breaks and quotes need no escaping. Java removes the indentation the lines share, which makes text blocks a good fit for JSON, SQL and HTML inside code.; Learn it in 56. Modern Java syntax: var, text blocks and moreSee also String, JSON
thisalso this keyword: Inside a method or constructor, this is the object the code is running on. this.name = name; stores the parameter name in the object's own field when the two share a name.; Learn it in 15. The this keyword and object references and 13. ConstructorsQuick guide: this vs super in Java, with ExamplesSee also Constructor, Field, super
Threadalso Thread class, main thread, start, run: One path of execution through a program; every program begins with one, the main thread. new Thread(task).start() starts another that runs task.run() alongside the code that started it, while calling run() yourself just runs the code on the current thread.; Learn it in 59. Introduction to threads and 60. Thread creation and synchronizationSee also Runnable, Concurrency, Thread lifecycle
Thread lifecyclealso thread states, join, sleep, NEW, RUNNABLE, TERMINATED: The states a thread passes through: new before start(), runnable while it can run, blocked or waiting while it needs a lock, sleeps or waits for another thread, and terminated once run() ends. Thread.sleep(500) pauses the current thread for half a second, and t.join() waits until thread t has terminated.; Learn it in 60. Thread creation and synchronizationSee also Thread, synchronized, Deadlock
Thread safetyalso thread-safe: A class is thread-safe when it behaves correctly even while several threads use it at once. Immutable objects, locks, atomic variables and concurrent collections such as ConcurrentHashMap get you there, while ArrayList and HashMap are not thread-safe.; Learn it in 63. Safe sharing: atomics, locks and concurrent collections and 20. Strings, StringBuilder, StringBufferSee also Race condition, Immutable, ConcurrentHashMap
throwalso throw new: The statement that raises an exception yourself: throw new IllegalArgumentException("Amount must be positive");. The method stops at that line, and Java looks for the nearest matching catch up the call stack.; Learn it in 48. Exception handlingSee also throws, Custom exception, IllegalArgumentException
throwsalso throws clause: The part of a method's declaration that lists the checked exceptions it may pass on to its caller: void load() throws IOException. It throws nothing by itself; it warns every caller to catch that exception or declare it too.; Learn it in 48. Exception handling and 46. Reading filesSee also throw, Checked exception
toStringalso toString(): The method that turns an object into text, called for you by println and by + with a string. Every class inherits a version from Object, the class at the top of every class family, which prints the class name and a hash code such as Dog@1b6d3586, so classes override it to show their fields.; Learn it in 36. equals, hashCode and toString and 29. Records: data classes in one lineSee also equals, hashCode, Overriding
TreeMapalso sorted map: A map that keeps its keys in sorted order, so it can answer questions such as the smallest key or the first key after 50. Its keys must be comparable, or you give it a Comparator.; Learn it in 35. HashMap and HashSet: finding things fast and 37. Comparable, Comparator and sortingSee also HashMap, TreeSet, Comparator
TreeSetalso sorted set: A set that keeps its values in sorted order and can answer questions such as the smallest value or the first one after 50. It decides whether two values are the same with compareTo or its comparator, never with equals.; Learn it in 37. Comparable, Comparator and sortingSee also TreeMap, Set, Comparable
try-catchalso try, catch, try/catch, multi-catch: The statement that handles exceptions: code that might fail goes in the try block, and a catch (IOException e) block runs only if that kind of exception is thrown. One catch can handle several types at once, as in catch (IOException | SQLException e).; Learn it in 48. Exception handling and 46. Reading filesSee also finally, Exception, Try-with-resources
Try-with-resourcesalso try with resources, AutoCloseable: A try that opens resources in parentheses and closes them for you when the block ends, even if an exception is thrown: try (BufferedReader in = new BufferedReader(new FileReader("data.txt"))) { ... }. It works with anything that implements AutoCloseable, such as readers, writers, scanners and database connections.; Learn it in 46. Reading files, 47. Writing files and 70. Creating and executing queriesSee also try-catch, finally, BufferedReader
Two-dimensional arrayalso 2D array, matrix, grid, nested loop, jagged array: An array whose elements are arrays, used for grids and tables: new int[3][4] has 3 rows of 4 columns, and grid[r][c] reads row r, column c. You walk it with nested loops, an outer loop over the rows and an inner one over the columns.; Learn it in 8. Arrays, two dimensions, and practiceSee also Array, for loop, O(n^2)
Type erasurealso erasure: The compiler checks generic types and then removes them, so while the program runs a List<String> and a List<Integer> are both just a List. That is why code such as new T() or new T[10] does not compile.; Learn it in 33. Generics: one class for many typesSee also Generics, Wildcard

U6

UML class diagramalso UML, class diagram: A drawing of classes as boxes listing their fields and methods, joined by lines that show how they relate: a solid line with a hollow triangle for inheritance, a dashed one for implementing an interface, and a filled diamond for composition. UML stands for Unified Modeling Language.; Learn it in 31. Designing classes wellSee also Class, Inheritance, Composition
Unchecked exceptionalso RuntimeException, unchecked: An exception the compiler does not make you catch or declare: RuntimeException and its subclasses, such as NullPointerException and IllegalArgumentException, and every Error. They usually point to a bug in the code rather than a problem outside it.; Learn it in 48. Exception handlingSee also Checked exception, Exception, NullPointerException
Unit testalso test, automated test: A small automatic check that runs one piece of code, usually one method, and compares its result with the answer you wrote down. A suite of them reruns in seconds after every change and tells you at once what broke.; Learn it in 22. Testing your code with JUnitSee also JUnit, Assertion, Arrange-act-assert
Unmodifiable collectionalso List.of, Set.of, Map.of, immutable list, read-only: A collection that throws UnsupportedOperationException when code tries to add, remove or replace an element. List.of, Set.of, Map.of and copyOf make them, and they also refuse null elements.; Learn it in 34. The Collections Framework and 7. ArrayList: a list that can growSee also Immutable, List, Collections Framework
Unnamed variablealso _, underscore: A single _ in place of a name you will never use, as in catch (NumberFormatException _) or the lambda (a, _) -> a. It arrived in Java 22 and tells the reader that the value is ignored on purpose.; Learn it in 30. Sealed types and pattern matching and 56. Modern Java syntax: var, text blocks and moreSee also Pattern matching, Lambda expression
Upcasting and downcastingalso upcast, downcast: Moving a reference up or down a class family. Upcasting, as in Animal a = new Dog();, happens by itself and is always safe; downcasting, as in Dog d = (Dog) a;, needs a cast and fails if the object is not a Dog.; Learn it in 18. PolymorphismSee also ClassCastException, instanceof, Casting

V3

varalso local variable type inference, type inference: Lets the compiler work out a local variable's type from its starting value: var names = new ArrayList<String>(); is still an ArrayList<String>. The type is fixed when the code compiles, as always, and var works only for local variables given a value straight away.; Learn it in 2. Variables, types, and input/output, 56. Modern Java syntax: var, text blocks and more and 30. Sealed types and pattern matchingSee also Static typing, Variable, Generics
Variablealso declaration, local variable, scope: A named place that holds a value, declared with a type: int score = 10;. The value can change later but the type cannot. A variable declared inside a method, a local variable, exists only until the closing } of its block, which is its scope.; Learn it in 2. Variables, types, and input/output and 12. Methods: parameters and return valuesSee also Static typing, Primitive type, Field
Virtual threadalso Thread.ofVirtual, newVirtualThreadPerTaskExecutor, platform thread, blocking I/O: A lightweight thread run by the JVM instead of the operating system, final since Java 21. When it blocks, waiting for a file, the network or sleep, it steps off the platform thread (an operating system thread) that was carrying it, so one program can run hundreds of thousands of them. Start one with Thread.ofVirtual().start(task), or one per task with Executors.newVirtualThreadPerTaskExecutor().; Learn it in 62. Virtual threadsSee also Thread, ExecutorService, Structured concurrency

W3

while loopalso while, do-while, infinite loop: A loop that checks its condition before each round, so its body may run zero times: while (balance < goal) { ... }. A do { ... } while (...); loop checks after the body, so it always runs at least once, and a loop whose condition never becomes false is an infinite loop.; Learn it in 5. Loops: for, while, do-while and 45. Scanner and console applicationsSee also for loop, break and continue, boolean
Wildcardalso ?, ? extends, ? super: A ? in a generic type that stands for some type you do not name. List<? extends Number> accepts a list of any kind of number to read from, and List<? super Integer> accepts any list you can put integers into.; Learn it in 33. Generics: one class for many typesSee also Generics, Type erasure
Wrapper classalso Integer, Double, Boolean, Character: A class that holds one primitive value as an object: Integer for int, Double for double, Character for char and so on. Collections can only hold objects, so a List of numbers is a List<Integer>.; Learn it in 32. Wrapper classes and autoboxingSee also Primitive type, Autoboxing, Integer cache