Glossary
Every Java term you'll meet, in plain language.
- Abstraction
- Exposing what an object does while hiding how it does it, via interfaces and abstract classes.
- Actuator
- Spring Boot's production-ready endpoints - health, metrics, info - for monitoring and managing a running application.
- Advice
- In AOP, the code an aspect runs at a matched join point - before, after, or around a method.
- Annotation
- Metadata attached to code (e.g. @Override) that tools and frameworks read to alter behavior.
- AOP
- Aspect-Oriented Programming: factoring cross-cutting concerns (logging, transactions) into reusable aspects.
- API
- Application Programming Interface - the set of methods a class or library exposes for others to use.
- Application Server
- A runtime (WildFly, Open Liberty, Payara) that hosts Jakarta EE applications and provides implementations of the EE specs; modern apps often embed the server instead.
- ApplicationContext
- Spring's IoC container interface: it creates, wires, and manages beans for the application's lifetime.
- ArrayList
- A resizable, index-based list backed by an array; the default List implementation.
- Aspect
- A module bundling a cross-cutting concern together with the advice and pointcut that apply it.
- Autoboxing
- Automatic conversion between primitives (int) and their wrapper objects (Integer).
- Autowiring
- Spring automatically supplying a bean's dependencies from the container, e.g. via a constructor.
- BCrypt
- A deliberately slow, salted password-hashing function; the standard way to store passwords so a database leak doesn't expose them.
- Bean
- Any object the Spring container instantiates, wires, and manages.
- Bytecode
- The portable, intermediate instructions produced by the Java compiler and run by the JVM.
- CDI
- Contexts and Dependency Injection - the Jakarta EE standard for dependency injection and contextual lifecycles (@Inject, scopes), analogous to Spring's container.
- Checked exception
- An exception the compiler forces you to handle or declare with 'throws' (e.g. IOException).
- Circuit Breaker
- A resilience pattern (Resilience4j) that stops calling a failing service for a while, failing fast with a fallback to prevent cascading outages.
- 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.
- Component Scanning
- Spring discovering stereotype-annotated classes (@Component, @Service…) in a package and registering them as beans.
- 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.
- DTO
- A Data Transfer Object - a simple carrier for API request/response data, kept separate from JPA entities so the contract and the model can evolve independently.
- Encapsulation
- Bundling data with methods and hiding internals behind a controlled interface.
- Enum
- A type with a fixed, type-safe set of named constant values.
- Exception
- An object representing an error or unusual condition that interrupts normal flow.
- Flyway
- A database migration tool that applies versioned SQL scripts in order, so the schema is explicit, reviewable, and reproducible instead of auto-generated.
- Functional interface
- An interface with exactly one abstract method, implementable by a lambda.
- 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.
- Generics erasure
- The removal of generic type information at compile time, leaving raw types at runtime.
- HashMap
- A collection storing key-value pairs with fast, average O(1) lookup via hashing.
- Heap dump
- A snapshot of all objects on the heap, used to diagnose memory leaks.
- Immutability
- The property of an object whose state cannot change after creation.
- Immutable
- An object whose state cannot change after construction (e.g. String, records).
- 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.
- IoC Container
- The Spring engine that inverts control of object creation - instantiating and injecting beans so you don't use new.
- Jakarta EE
- The Eclipse-stewarded successor to Java EE: a suite of enterprise specifications (JPA, Servlet, CDI, JAX-RS, Bean Validation) whose packages live under jakarta.*.
- JAR
- Java ARchive - a zip of compiled classes; a 'fat JAR' also bundles dependencies.
- JAX-RS
- The Jakarta RESTful Web Services specification for building REST APIs with annotations (@Path, @GET); Jersey and RESTEasy implement it.
- JDBC
- Java Database Connectivity - the standard API for talking to relational databases.
- 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.
- JIT warm-up
- The early period where code runs interpreted before the JIT optimizes hot paths.
- JPA
- Jakarta Persistence API - the standard for object-relational mapping, often via Hibernate.
- 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.
- JWT
- A JSON Web Token: a signed, self-contained token carrying a user's identity and claims, used for stateless authentication.
- 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.
- Method reference
- A shorthand for a lambda that just calls one existing method, written Class::method.
- Micrometer
- A vendor-neutral metrics facade ('SLF4J for metrics') that records measurements and exports them to systems like Prometheus.
- MicroProfile
- Specifications extending Jakarta EE for cloud-native microservices (config, health, metrics, fault tolerance, JWT), implemented by runtimes like Quarkus and Open Liberty.
- N+1 problem
- An ORM anti-pattern: one query loads N rows, then N more queries load their relations.
- NullPointerException
- The runtime error from using a reference that points to null.
- 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).
- Package
- A namespace grouping related classes, named in reverse-domain style (com.myapp.orders).
- Pattern matching
- Testing a value's shape and binding its parts in one step (instanceof / switch patterns).
- Pointcut
- An expression selecting which join points (method executions) an aspect's advice applies to.
- Polymorphism
- One method call behaving differently depending on the actual object type.
- PreparedStatement
- A parameterized SQL statement that prevents SQL injection.
- ProblemDetail
- The RFC 9457 standard error body (type, title, status, detail) Spring returns for failures, giving APIs a consistent, machine-readable error shape.
- Profile
- A named set of beans and properties activated per environment via spring.profiles.active.
- Proxy
- A stand-in object Spring wraps around a bean to apply AOP advice like @Transactional before delegating.
- Record
- A concise, immutable data class that auto-generates constructor, accessors, equals, hashCode, and toString.
- Record pattern
- Destructuring a record directly in instanceof or switch (Java 21+).
- Reflection
- Inspecting and manipulating classes, methods, and fields at runtime.
- REST
- An architectural style for web APIs using HTTP methods (GET/POST/PUT/DELETE) over resources.
- Sealed class
- A class or interface that restricts which types may extend or implement it.
- Serialization
- Converting an object into bytes for storage or transmission; deserialization reverses it.
- Spring Boot
- A framework that auto-configures Spring so you can build apps with minimal setup.
- Spring Framework
- The core Spring library: the IoC container, dependency injection, and AOP that the whole ecosystem builds on.
- Stack & Heap
- Memory areas: the stack holds method calls and local variables; the heap holds objects.
- Starter
- A curated Spring Boot dependency (e.g. spring-boot-starter-web) that pulls in everything needed for a feature.
- Stereotype
- An annotation marking a class as a bean and documenting its role: @Component, @Service, @Repository, @Controller.
- 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.
- Testcontainers
- A library that runs real dependencies (like PostgreSQL) in throwaway Docker containers during integration tests, for higher fidelity than in-memory fakes.
- Text block
- A multi-line string literal delimited by triple quotes (""").
- Thread
- A single path of execution within a process; multiple threads share memory.
- try-with-resources
- A try statement that automatically closes AutoCloseable resources when it ends.
- Unchecked exception
- A RuntimeException the compiler doesn't force you to handle; usually signals a bug.
- Varargs
- A method parameter accepting a variable number of arguments, written Type... name.
- Virtual thread
- An ultra-lightweight thread (Java 21+) enabling millions of concurrent tasks.
- volatile
- A keyword guaranteeing that reads/writes of a field are visible across threads.
- Wildcard
- The ? in generics representing an unknown type, refined with extends or super (PECS).