Glossar
Jeder Java-Begriff, dem du begegnest - in verständlicher Sprache.
- Abstraction
- Exposing what an object does while hiding how it does it, via interfaces and abstract classes.
- Annotation
- Metadata attached to code (e.g. @Override) that tools and frameworks read to alter behavior.
- API
- Application Programming Interface - the set of methods a class or library exposes for others to use.
- ArrayList
- A resizable, index-based list backed by an array; the default List implementation.
- Bytecode
- The portable, intermediate instructions produced by the Java compiler and run by the JVM.
- Class
- A blueprint that defines the fields and methods of objects created from it.
- Collection
- A data structure holding multiple elements - List, Set, Map, or Queue.
- Composition
- Building objects from other objects (has-a), favored over inheritance for flexibility.
- Constructor
- A special method that initializes a new object, run when you use 'new'.
- Dependency Injection
- Supplying a class's dependencies from outside rather than creating them internally.
- Encapsulation
- Bundling data with methods and hiding internals behind a controlled interface.
- Exception
- An object representing an error or unusual condition that interrupts normal flow.
- Garbage Collection
- Automatic reclamation of memory used by objects no longer reachable by the program.
- Generics
- Type parameters (like List<String>) that give compile-time type safety without casting.
- HashMap
- A collection storing key-value pairs with fast, average O(1) lookup via hashing.
- Immutability
- The property of an object whose state cannot change after creation.
- Inheritance
- A class reusing and extending another's fields and methods (an is-a relationship).
- Interface
- A contract of methods a class promises to implement, with no (required) implementation.
- JAR
- Java ARchive - a zip of compiled classes; a 'fat JAR' also bundles dependencies.
- JDK
- Java Development Kit - the compiler and tools needed to develop Java, including the JRE.
- JIT
- Just-In-Time compiler - converts hot bytecode into optimized native code at runtime.
- JRE
- Java Runtime Environment - the JVM plus core libraries needed to run (not build) Java apps.
- JVM
- Java Virtual Machine - the engine that runs bytecode on any platform.
- Lambda
- A concise, passable piece of behavior: (params) -> body, implementing a functional interface.
- LTS
- Long-Term Support - a Java release (8, 11, 17, 21, 25) with years of updates.
- Method
- A named, reusable block of code that may take parameters and return a value.
- Object
- A concrete instance created from a class, with its own field values.
- Optional
- A container representing a value or its absence, used to avoid null.
- ORM
- Object-Relational Mapping - mapping Java objects to database tables (e.g. JPA/Hibernate).
- Overloading
- Multiple methods sharing a name but differing in parameters.
- Overriding
- A subclass providing its own version of an inherited method (@Override).
- Polymorphism
- One method call behaving differently depending on the actual object type.
- PreparedStatement
- A parameterized SQL statement that prevents SQL injection.
- Record
- A concise, immutable data class that auto-generates constructor, accessors, equals, hashCode, and toString.
- Reflection
- Inspecting and manipulating classes, methods, and fields at runtime.
- Sealed class
- A class or interface that restricts which types may extend or implement it.
- Stack & Heap
- Memory areas: the stack holds method calls and local variables; the heap holds objects.
- Stream
- A pipeline for processing sequences of data declaratively (filter, map, reduce).
- String pool
- A cache of String literals the JVM reuses to save memory.
- Thread
- A single path of execution within a process; multiple threads share memory.
- Virtual thread
- An ultra-lightweight thread (Java 21+) enabling millions of concurrent tasks.