Java Reference ยท Language Features by Version
Java glossary
A glossary of Java terms from API and autoboxing to JVM, JDK, JRE, JPMS, lambda, record, sealed class, thread and virtual thread, with short explanations.
Java has its own vocabulary, and some words mean something different from everyday English or from other languages. This glossary defines the terms you meet most often in the reference and in other people's code. Each entry is short; follow the links for details.
The first group names the pieces of the platform, because "Java" can mean the language, the runtime or the whole ecosystem. After the platform terms, the glossary runs alphabetically through language and library terms.
// Language : the syntax you write (classes, lambdas, records) // Compiler : javac turns .java files into .class files (bytecode) // JVM : the virtual machine that runs the bytecode // JDK : compiler + tools + the standard library + a runtime
Platform terms
| Term | Meaning |
|---|---|
| Bytecode | The instruction set of the JVM, stored in .class files. It is the same on every operating system. |
| JVM (Java Virtual Machine) | The program that loads classes, verifies and runs bytecode, compiles hot code and manages memory. HotSpot is the main implementation. |
| JRE (Java Runtime Environment) | The JVM plus the standard library, enough to run programs. Separate JRE downloads are rare since Java 11. |
| JDK (Java Development Kit) | The JRE plus the compiler and tools such as javac, jar and jshell. |
| OpenJDK | The open-source project behind most JDK builds; vendors (Temurin, Corretto, Zulu, Oracle and others) publish builds of it. |
| LTS (long-term support) | A release that vendors support for years. Java 8, 11, 17, 21 and 25 are LTS releases. |
| JCP, JEP, JLS | Java Community Process; JDK Enhancement Proposal (a numbered design document for each feature); Java Language Specification. |
| JPMS (module system) | The Java Platform Module System of Java 9, with module-info.java. See modules. |
| Class path / module path | The places where the JVM looks for classes and modules. |
| JNI / FFM | Java Native Interface (old) and the Foreign Function and Memory API (Java 22, final) for calling native code. |
| JFR | Java Flight Recorder, the low-overhead event recorder built into the JVM. |
A to Z
| Term | Meaning |
|---|---|
| Abstract class | A class that cannot be instantiated and may contain abstract (bodyless) methods that subclasses must implement. |
| Annotation | Metadata attached to code with @, such as @Override. Read by the compiler, tools or reflection. |
| API | Application Programming Interface: the public classes and methods of a library. |
| Autoboxing | Automatic conversion between a primitive and its wrapper, such as int and Integer. Unboxing a null throws NullPointerException. |
| Checked exception | An exception the compiler forces you to catch or declare (IOException). RuntimeException and Error are unchecked. |
| Class | A blueprint that defines fields and methods; objects are its instances. |
| Class loader | The component that finds and defines classes. See class loading. |
| Constructor | A special member that initializes a new object; it has the class name and no return type. |
| Covariant return | An overriding method may return a more specific type than the method it overrides. |
| Default method | An interface method with a body, marked default (Java 8). |
| Diamond operator | <>: lets the compiler infer type arguments, as in new ArrayList<>(). |
| Effectively final | A local variable that is never reassigned after initialization; lambdas can capture it. |
| Enum | A class with a fixed set of named instances. |
| Erasure | Generic type information is removed at compile time; at run time a List<String> is a List. |
| Functional interface | An interface with exactly one abstract method; a lambda or method reference can implement it. |
| Garbage collection | Automatic reclamation of unreachable objects. See garbage collection. |
| Generics | Type parameters (List<T>) that give compile-time type safety to classes and methods. |
| Heap | The memory area for objects and arrays. See JVM memory. |
| Immutable | An object whose state cannot change after construction, such as String and records. |
| Inheritance | A class acquiring members of a superclass with extends. |
| Interface | A type that declares methods a class promises to provide (implements). |
| JAR | Java ARchive: a ZIP file of classes and resources with an optional manifest. |
| JIT compiler | Compiles hot bytecode to machine code at run time. See JIT. |
| Lambda | An anonymous function written (a, b) -> a + b (Java 8). |
| Method reference | A short form of a lambda that names a method: String::length. |
| Module | A named group of packages with declared dependencies and exports. |
| Monitor | The lock built into every object; used by synchronized, wait and notify. |
| Optional | A container that may or may not hold a value, used as a return type instead of null. |
| Overloading | Several methods with the same name and different parameter lists in one class. |
| Overriding | A subclass replacing an inherited instance method with the same signature. |
| Package | A namespace for classes, matching a directory structure. |
| Pattern matching | Testing a value's shape and extracting parts, in instanceof and switch. |
| Polymorphism | The same call running different code depending on the actual object type. |
| Primitive | One of the eight non-object types: byte, short, int, long, float, double, char, boolean. |
| Record | A concise immutable data class declared with record (Java 16). |
| Reflection | Inspecting and using classes, fields and methods at run time (java.lang.reflect). |
| Sealed class | A class or interface that lists exactly which classes may extend it (Java 17). |
| Serialization | Converting an object to bytes and back. Native Java serialization is discouraged for untrusted data. |
| Source launcher | java File.java: compiles and runs a single source file in memory (Java 11). |
| Stack | The per-thread memory of method frames. |
| Static | Belonging to the class instead of to an instance. |
| Stream | A pipeline for processing sequences of elements with map, filter and collect (Java 8). |
| Text block | A multi-line string literal delimited by """ (Java 15). |
| Thread | A path of execution. Platform threads map to operating-system threads. |
| Try-with-resources | A try statement that closes AutoCloseable resources automatically. |
| Type inference | The compiler deducing a type, as with var (Java 10) and the diamond operator. |
| Varargs | A method parameter String... names that accepts zero or more arguments. |
| Virtual thread | A lightweight thread managed by the JVM, cheap enough to create millions (Java 21). |
| Wildcard | ? in generics: List<? extends Number> means a list of some unknown subtype of Number. |
| Wrapper class | An object type for a primitive: Integer, Long, Boolean, and so on. |
Try it
Press Run (or Ctrl + Enter) to see the result here.
Program input ยท what you'd type while the program runs
Type the answers before you press Run, one per line. Each time the program reads a line (with IO.readln() or a Scanner), it gets the next line from this box.
Press Run (or Ctrl + Enter) to see the result here.
Program input ยท what you'd type while the program runs
Type the answers before you press Run, one per line. Each time the program reads a line (with IO.readln() or a Scanner), it gets the next line from this box.
Usage notes
- "Java" has four meanings: the language, the compiler, the JVM and the standard library. Say which one you mean when you debug.
- Jakarta EE is the enterprise API set formerly called Java EE; its packages moved from
javax.*tojakarta.*in version 9. Packages such asjavax.swingandjavax.cryptostay in the JDK. - Release names: since Java 9 there is a feature release every six months, named by number only (Java 25, not "Java 1.25"). Older notation like
1.8still appears for Java 8. - Terms people confuse: overloading versus overriding,
==versusequals, checked versus unchecked exceptions,IteratorversusIterable,CollectionversusCollections,Arrays.asList(fixed-size view) versusList.of(immutable). - POJO ("plain old Java object") means an ordinary class that does not depend on a framework. JavaBean is a convention: a no-argument constructor, private properties, getters and setters. DTO is an object that only carries data, a role for which records fit well.
Related
- Java versions overview
- JDK tools
- Code conventions
- Tutorial: Introduction to Java
- Tutorial: Classes and objects