247 docs tagged with "java"

A creational pattern that produces families of related objects without specifying their concrete classes.

Hide complexity behind a clean contract — when to use abstract classes vs. interfaces, default methods, and the design forces that govern the choice.

Hands-on code examples and step-by-step walkthroughs for Abstraction in Java.

A structural pattern that allows incompatible interfaces to work together by wrapping one interface with a compatible one.

Hands-on examples of the Adapter pattern — wrapping incompatible APIs, integrating third-party SDKs, and using Spring DI as an adapter.

Built-in annotations, custom annotations, meta-annotations, annotation processing.

The single REST endpoint, full request and response shapes, Bean Validation rules, and what happens when validation fails.

Principles and patterns for designing clear, versioned, and client-friendly REST, gRPC, and GraphQL APIs in Java/Spring Boot services.

Scenario-based walkthrough of designing a production-quality REST API with versioning, pagination, error handling, and rate-limiting headers in Spring Boot 3.

Single and multi-dimensional arrays, creation, initialization, traversal, and the Arrays utility class.

Lock-free thread-safe operations using AtomicInteger, AtomicReference, LongAdder, and the compare-and-swap (CAS) CPU primitive that powers them.

Hands-on walkthroughs of AtomicInteger, AtomicReference, LongAdder, and CAS-based patterns including the ABA problem.

A comparison of Git Flow, GitHub Flow, and trunk-based development — what each model is, when to use it, and how it shapes your CI/CD pipeline.

A creational pattern that separates the construction of a complex object from its representation, allowing the same construction process to produce different results.

Hands-on examples of the Builder pattern — from the classic Effective Java idiom to Lombok @Builder to a step-by-step Director.

The structure of Java .class files — constant pool, bytecode instructions, and using javap to disassemble compiled code — plus how generics erasure, lambdas, and string concatenation look at the bytecode level.

Patterns for caching application data — cache-aside, write-through, write-behind — eviction policies, TTL design, and cache stampede prevention in Spring Boot with Redis.

Scenario-based walkthrough of implementing cache-aside with Redis in Spring Boot — including TTL configuration, cache eviction, and stampede prevention.

A behavioral pattern that passes a request along a chain of handlers, each deciding to process it or pass it to the next handler.

Quick-reference pages for common Java APIs, collections, concurrency, and streams.

How the JVM loads, links, and initializes classes on demand — the parent-delegation model, the three standard classloaders, and how frameworks use custom classloaders for isolation and hot reload.

Understand Java classes as blueprints and objects as runtime instances — fields, methods, constructors, and the `this` keyword.

Hands-on code examples and step-by-step walkthroughs for Classes & Objects in Java.

AWS/GCP/Azure, cloud-native patterns, managed services.

Collections hierarchy, List, Set, Map, iterators, Comparable vs Comparator, Collections utility class, immutability.

Consolidated interview Q&A for the Java Collections Framework — hierarchy, List, Set, Map, Queue, iterators, sorting, and immutability — from beginner through advanced.

Quick-reference summary of the Java Collections Framework — hierarchy, implementations, complexity, and top interview questions.

The complete interface tree of the Java Collections Framework — Iterable, Collection, List, Set, Queue, and why Map stands apart.

Hands-on examples showing how the Collection/Map interface tree works in practice.

Java's built-in Collector implementations — toList, groupingBy, partitioningBy, joining, toMap, counting, and how to build custom collectors.

Hands-on examples for groupingBy, toMap, joining, partitioningBy, and custom collectors.

A behavioral pattern that encapsulates a request as an object, enabling undo/redo, queuing, logging, and parameterization of operations.

A structural pattern that composes objects into tree structures to represent part-whole hierarchies, letting clients treat individual objects and compositions uniformly.

How Git detects and marks merge conflicts, what three-way merge means, how to resolve conflicts efficiently with rerere and merge tools, and strategies to avoid them in the first place.

Why connection pooling is essential, how HikariCP works, and how to configure it correctly in Spring Boot applications.

Hands-on Spring Boot HikariCP configuration examples, pool monitoring, leak detection, and Kubernetes multi-pod sizing.

if/else, switch expressions, for, while, do-while, break, continue — directing program execution in Java.

Core classes — Object, String, Math, wrapper classes.

Consolidated interview Q&A for Java's Core APIs — Object class, String, StringBuilder, Math, wrapper types, and Optional.

Quick-reference summary of Java's core utility classes — Object, String, StringBuilder, Math, wrapper types, and Optional — with a learning path and top interview questions.

Language basics — variables, data types, operators, control flow, type conversion.

Consolidated interview Q&A for Core Java covering beginner through advanced topics — variables, types, operators, control flow, arrays, strings, methods, and packages.

Quick-reference summary of Core Java concepts, APIs, and interview questions for rapid revision.

How to create domain-specific exception classes in Java — checked vs. unchecked choice, adding context fields, exception chaining, and hierarchy design.

Hands-on examples for building domain-specific exception hierarchies, adding typed fields, chaining exceptions, and integrating with Spring Boot's @ControllerAdvice.

Common data structures, algorithms, complexity analysis, Java implementations.

SQL, NoSQL, connection pooling, schema migration (Flyway/Liquibase).

Consolidated interview Q&A for the Databases domain — SQL, indexes, transactions, connection pooling, NoSQL, and schema migration — beginner through advanced.

Quick-reference summary of SQL, indexes, transactions, connection pooling, NoSQL trade-offs, and schema migration for Java backend engineers.

A structural pattern that dynamically adds behavior to an object by wrapping it in decorator objects, without altering the original class.

Common GoF design patterns expressed with Java examples.

CI/CD pipelines, monitoring, observability, Spring Boot Actuator.

Core theory behind distributed systems — CAP theorem, consistency models, idempotency, and the Saga pattern for distributed transactions — for Java/Spring Boot backend engineers.

Scenario-based walkthrough of implementing a choreography-based Saga for an e-commerce order flow with idempotent Kafka consumers in Spring Boot.

The entities, DTOs (Java Records), and enums that represent the core concepts of a loan application — and why each was designed the way it was.

Hide internal state behind a controlled interface — access modifiers, getters/setters, and the art of designing immutable classes.

Hands-on code examples and step-by-step walkthroughs for Encapsulation in Java.

Production-proven rules for when to throw, catch, wrap, and log exceptions in Java — covering the checked vs. unchecked debate, layered architecture patterns, and common anti-patterns.

Hands-on code contrasting good and bad exception handling patterns — swallowing, double-logging, flow control misuse, and InterruptedException restoration.

How GlobalExceptionHandler uses @RestControllerAdvice to intercept validation failures and unexpected errors and convert them into structured JSON responses.

Hands-on Spring Boot demo of @ControllerAdvice, ProblemDetail error responses, validation error shaping, and the catch-all exception handler pattern.

How to centralise HTTP error responses in Spring Boot — @ExceptionHandler, @ControllerAdvice, ProblemDetail (RFC 7807), and mapping domain exceptions to the right status codes.

The Throwable tree in Java — how Error, Exception, and RuntimeException relate, and what checked vs. unchecked means for API contracts.

Hands-on code examples exploring the Throwable tree, checked vs. unchecked exceptions, and how to inspect exception types at runtime.

Exception hierarchy, checked vs unchecked exceptions, try/catch/finally, try-with-resources, custom exceptions.

Consolidated interview Q&A for Java Exceptions — hierarchy, try/catch/finally, custom exceptions, and best practices from beginner through advanced.

Quick-reference summary of Java exception handling — hierarchy, try/catch/finally, custom exceptions, and best practices — for rapid revision.

A structural pattern that provides a simplified interface to a complex subsystem, hiding its internal complexity from client code.

A creational pattern that defines an interface for creating an object but lets subclasses decide which class to instantiate.

Hands-on examples of the Factory Method pattern — from classic inheritance-based variants to static factories to Spring @Bean factories.

What functional interfaces are, the built-in types (Function, Predicate, Consumer, Supplier), and how to compose them.

Hands-on examples for Function, Predicate, Consumer, Supplier, and composition patterns.

Lambdas, functional interfaces, Streams API, method references, Optional.

Consolidated interview Q&A for Java Functional Programming — lambdas, functional interfaces, method references, streams, collectors, parallel streams, and Optional.

Quick-reference summary of Java 8+ functional programming — lambdas, functional interfaces, method references, Streams, Collectors, parallel streams, and Optional — for rapid revision.

How the JVM automatically reclaims heap memory — GC roots, reachability analysis, generational collection, and the major collectors (Serial, Parallel, G1, ZGC) with tuning flags.

How Java generics provide compile-time type safety through parameterised types — covering generic classes, generic methods, bounded type parameters, and the key constraint that generics only work with reference types.

Hands-on code examples for generic classes, generic methods, bounded type parameters, and the diamond operator.

The foundational Git concepts every developer needs — the three-area model, core commands, branching, .gitignore, and the daily workflow from init to push.

How Git hooks let you automate quality checks at every stage of the commit and push lifecycle — pre-commit linting, commit-msg validation, pre-push tests, and managing hooks across a team with tools like pre-commit.

How Git stores every file, directory, and commit as content-addressable objects — blobs, trees, commits, and tags — and why this design makes Git so powerful and reliable.

A deep dive into the HTTP protocol — methods, status codes, headers, content negotiation, and HTTP/2 basics — as used in Java backend development.

Hands-on Spring Boot examples demonstrating HTTP methods, status codes, headers, ETags, and content negotiation.

File handling, streams, buffers, channels, serialization, and NIO APIs.

How to create truly immutable List, Set, and Map instances in Java using the Java 9+ factory methods and how they differ from the older Collections.unmodifiable wrappers.

Hands-on examples comparing List.of, Collections.unmodifiableList, and Arrays.asList — and showing defensive copying at API boundaries.

How database indexes work, when to add them, how to read EXPLAIN plans, and common indexing pitfalls that hurt performance.

Hands-on examples covering index creation, composite indexes, covering indexes, and reading EXPLAIN plans in PostgreSQL.

Extend classes with `extends`, override behavior with `@Override`, use `super` for parent delegation, and learn when inheritance causes more harm than good.

Hands-on code examples and step-by-step walkthroughs for Inheritance in Java.

How to use @SpringBootTest with TestRestTemplate and WebTestClient to write full-context Spring Boot integration tests.

Hands-on walkthrough of @SpringBootTest with TestRestTemplate, @MockBean for external dependencies, and Testcontainers for real database integration.

Consolidated domain-specific Q&A for Java backend engineering interviews.

Hands-on examples for Iterator, ListIterator, ConcurrentModificationException, and safe removal patterns.

How the Iterator protocol works, what ConcurrentModificationException means and how to avoid it, and how the enhanced for-each loop is compiled.

Core Java language, standard library, JVM, and runtime concepts organized as dedicated subdomains.

Consolidated interview Q&A for GoF design patterns in Java — creational, structural, and behavioral — covering beginner through advanced topics.

Quick-reference summary of all 15 GoF design patterns in Java — participants, intent, Java/Spring examples, and top interview questions.

Language and platform changes across Java versions — Java 8, 11, 17, 21.

Java 9+ module system (JPMS), module-info.java, strong encapsulation, requires/exports.

Primitives vs objects, autoboxing/unboxing, generics, type inference, wildcards, type erasure, bounded type parameters.

Consolidated interview Q&A for the Java Type System — primitives, autoboxing, generics, wildcards, type erasure, and type inference.

Quick-reference summary of Java's type system — primitives, autoboxing, generics, wildcards, type erasure, and type inference — for rapid revision before interviews.

The high-level concurrency toolkit — ExecutorService, Future, CompletableFuture, CountDownLatch, CyclicBarrier, and Semaphore — that replaces manual thread management in production Java.

Hands-on walkthroughs of ExecutorService, CompletableFuture pipelines, CountDownLatch, and Semaphore.

How the JVM's Just-In-Time compiler converts hot bytecode into native machine code at runtime — tiered compilation (C1/C2), inlining, escape analysis, and the warmup behavior you see in every production service.

The foundational Java testing framework — lifecycle annotations, assertions, parameterized tests, and test organization.

Hands-on code examples and step-by-step walkthroughs for JUnit 5 lifecycle, assertions, and parameterized tests.

Class loading, memory management, garbage collection, JIT compilation.

The JVM's runtime memory layout — heap regions, stack frames, Metaspace, and per-thread vs. shared areas — and why understanding it matters for diagnosing OutOfMemoryErrors and tuning performance.

Lambda expressions in Java — syntax, effectively-final capture, `this` behavior, and how they relate to functional interfaces.

Hands-on code examples and step-by-step walkthroughs for Lambda expressions in Java.

Understand Java's List interface, when to use ArrayList vs LinkedList, and how their internal structures drive performance trade-offs.

Hands-on examples for ArrayList vs LinkedList, pre-sizing, safe removal, and subList behavior.

A Spring Boot REST service that evaluates loan applications using risk classification, EMI calculation, and eligibility rules — covered layer by layer.

Explicit locking with ReentrantLock, ReadWriteLock, and StampedLock — when and why to reach for them over synchronized.

Hands-on walkthroughs of ReentrantLock, ReadWriteLock, tryLock with timeout, and Condition-based signaling.

Deep dive into Java's Map implementations — how HashMap buckets work, when to use LinkedHashMap or TreeMap, and why ConcurrentHashMap is the thread-safe choice.

Hands-on examples for HashMap, LinkedHashMap, TreeMap, and ConcurrentHashMap — frequency counting, LRU cache, range queries, and atomic operations.

Java's Math and StrictMath classes — trigonometry, rounding, overflow-safe arithmetic, random numbers, and when cross-platform reproducibility matters.

Hands-on examples for rounding, overflow-safe arithmetic, trigonometry, and cross-platform reproducibility.

Kafka, RabbitMQ, async patterns, event-driven architecture.

The four kinds of method references in Java — static, bound instance, unbound instance, and constructor — and when to prefer them over lambdas.

Hands-on examples for all four kinds of method references — static, bound, unbound, and constructor.

Method signatures, overloading, varargs, pass-by-value semantics, and recursion in Java.

An architectural style that structures an application as a collection of small, independently deployable services — each owning its data and business logic.

Scenario-based walkthrough of building a two-service Order + Inventory microservices topology with service discovery, Kafka events, and Spring Boot 3.

How to create mock objects, stub method calls, verify interactions, and capture arguments in Java unit tests.

Hands-on code examples for creating mocks, stubbing behavior, verifying interactions, and capturing arguments with Mockito.

How to test Spring MVC and Spring WebFlux controllers at the HTTP level without starting a real server, using MockMvc and WebTestClient.

Hands-on walkthrough of HTTP-level controller testing with MockMvc and WebTestClient — requests, assertions, security, and validation.

Threads, lifecycle, synchronization, concurrency utilities, volatile, virtual threads.

Consolidated interview Q&A for Java Multithreading — threads, synchronization, wait/notify, ExecutorService, locks, atomics, thread safety, and virtual threads from beginner through advanced.

Quick-reference summary of Java concurrency — threads, synchronization, locks, atomics, ExecutorService, CompletableFuture, virtual threads — for rapid revision.

Practical guide to MySQL, PostgreSQL, and H2 for Java developers — architecture differences, UUID handling, H2 for development, and migration paths to production databases.

CAP theorem, BASE properties, and when to choose Redis, MongoDB, Cassandra, or Elasticsearch over a relational database.

Hands-on Spring Boot examples for Redis caching, MongoDB document CRUD, and Spring Cache abstraction.

The root of every Java class hierarchy — toString, equals, hashCode, clone, wait, notify, and finalize explained with contracts and pitfalls.

Hands-on code examples and step-by-step walkthroughs for equals, hashCode, toString, and clone.

OOP principles — classes, objects, inheritance, polymorphism, encapsulation, abstraction, interfaces, records, sealed classes.

A behavioral pattern where an object (subject) maintains a list of dependents (observers) and notifies them automatically when its state changes.

Hands-on examples of manual Observer, Spring Application Events, @TransactionalEventListener, and @Async observers.

Consolidated interview Q&A for Java OOP covering beginner through advanced topics — classes, encapsulation, inheritance, polymorphism, abstraction, records, and sealed classes.

Quick-reference summary of Java OOP concepts — classes, encapsulation, inheritance, polymorphism, abstraction, records, and sealed classes.

Auto-generating interactive API documentation for Spring Boot REST APIs using springdoc-openapi — setup, @Operation/@Schema annotations, security schemes, and customisation.

Hands-on Springdoc setup, @Operation/@Schema annotations, JWT security scheme, and production-safe configuration for Spring Boot REST APIs.

Arithmetic, relational, logical, bitwise, ternary, and instanceof operators — how Java evaluates expressions.

Hands-on examples for Optional creation, chained transformations, orElseGet laziness, and common anti-patterns.

Java's Optional container type — what it is, when it genuinely clarifies code, and the common anti-patterns that make it worse than a null check.

How to use Optional correctly — creation, retrieval patterns, chaining, and the anti-patterns that make Optional worse than null.

Hands-on examples for Optional creation, safe retrieval, chaining, and the anti-patterns to avoid.

Quick-reference summaries for every domain — designed for rapid revision before interviews.

Package structure, the import statement, the classpath, access modifiers, and how Java locates classes.

When parallel streams improve throughput, when they hurt, and how the ForkJoin common pool governs parallel execution.

Hands-on examples demonstrating when parallel streams help, when they hurt, and common correctness pitfalls.

How LoanApplication is mapped to H2 using JPA @Embeddable value objects, @ElementCollection for rejection reasons, and @PrePersist for UUID generation.

Compile-time (overloading) vs. runtime (overriding) dispatch — how Java decides which method to call and why this is the foundation of flexible design.

Hands-on code examples and step-by-step walkthroughs for Polymorphism in Java.

How Java's eight primitive types differ from object references — stack vs. heap, null safety, autoboxing, unboxing, and the performance tradeoffs involved.

Hands-on code examples and step-by-step walkthroughs for Java primitives, autoboxing, unboxing, the Integer cache, and null NPE traps.

What the Loan Application Evaluator does, why it exists, its tech stack, and how to run it locally.

End-to-end Java Spring Boot project walkthroughs — annotated source code deep-dives for interview preparation and real-world learning.

Quick-reference summary of the Loan Application Evaluator project — architecture, key patterns, tech stack decisions, and top interview talking points.

A creational pattern that creates new objects by copying (cloning) an existing instance rather than instantiating from scratch.

A structural pattern that provides a surrogate object which controls access to another object, adding security, caching, logging, or lazy initialization transparently.

Hands-on examples showing manual proxies, JDK dynamic proxies, and how Spring AOP uses proxies for @Transactional and @Cacheable.

Understand Java's Queue and Deque interfaces, how ArrayDeque and PriorityQueue work internally, and when to use BlockingQueue for producer-consumer patterns.

Hands-on examples for ArrayDeque as stack/queue, PriorityQueue for task scheduling, and BlockingQueue for producer-consumer.

The difference between git merge and git rebase — when each produces a better history, how interactive rebase cleans up commits, and the golden rule you must never break.

Hands-on code examples and step-by-step walkthroughs for Records (Java 16+) in Java.

Java's concise immutable data carrier — understand what records generate automatically, compact constructors, and when records replace traditional value classes.

Circuit Breaker, Retry, Bulkhead, Timeout, and Rate Limiter — the five resilience patterns that prevent cascading failures in distributed Spring Boot services, implemented with Resilience4j.

Scenario-based walkthrough of implementing Circuit Breaker, Retry, Bulkhead, and Timeout with Resilience4j in a Spring Boot 3 microservice.

How to design clean, coherent REST APIs — resource naming, HTTP verb mapping, versioning strategies, HATEOAS, and idempotency patterns used in production Spring Boot services.

Hands-on examples of REST resource naming, versioning, idempotency keys, HATEOAS links, and pagination in Spring Boot.

Interview Q&A mapped directly to resume experiences — legacy migration, security hardening, containerization, Apache POI, and behavioral STAR stories.

Horizontal vs vertical scaling, stateless services, read replicas, database sharding, and load balancing — the patterns that allow a Java/Spring Boot system to handle growing traffic.

Scenario-based walkthrough of making a Spring Boot service horizontally scalable — stateless sessions with Redis, connection pool tuning, read replica routing, and async offloading.

Step-by-step Flyway and Liquibase migration examples in Spring Boot — from first migration to rollback-safe production patterns.

How to manage database schema evolution safely in Spring Boot using versioned migrations with Flyway and Liquibase.

Hands-on code examples and step-by-step walkthroughs for Sealed Classes (Java 17+) in Java.

Restrict which classes can extend or implement a type — enabling exhaustive pattern matching and modeling closed, well-known type hierarchies safely.

How the LoanApplicationService evaluates a loan — risk classification, interest rate calculation, EMI formula, and the two-tier eligibility check — step by step.

Understand Java's Set interface, how each implementation handles uniqueness and ordering, and when to choose HashSet, LinkedHashSet, or TreeSet.

Hands-on examples for HashSet, LinkedHashSet, and TreeSet — uniqueness enforcement, ordering differences, and set operations.

A creational pattern that ensures a class has exactly one instance and provides a global access point to it.

Hands-on step-by-step examples of all four Java Singleton idioms with thread-safety analysis.

Five design principles that make object-oriented code easier to maintain, extend, and test — the foundation of clean Java design.

Step-by-step scenario showing a notification system refactored through all five SOLID principles in a Spring Boot context.

Understand the difference between Comparable (natural ordering defined on the class) and Comparator (external ordering strategy), and how to use both with collections, streams, and sorted data structures.

Hands-on examples for Comparable, Comparator factory methods, multi-field sorting, and null-safe ordering.

How to use @WebMvcTest, @DataJpaTest, and @JsonTest to write fast, focused Spring Boot tests that load only the layers you need.

Hands-on walkthrough of @WebMvcTest, @DataJpaTest, and @JsonTest with realistic Order API examples.

How Spring MVC processes HTTP requests — DispatcherServlet, @RestController, request mapping, parameter binding, and ResponseEntity patterns used in everyday Spring Boot APIs.

Hands-on Spring MVC examples covering DispatcherServlet internals, parameter binding, validation, content negotiation, and interceptors.

Core SQL syntax and concepts — SELECT, JOIN types, GROUP BY, window functions, and subqueries — with Spring Boot JDBC context.

Hands-on SQL examples covering JOINs, GROUP BY, window functions, and subqueries in a Spring Boot JDBC context.

A behavioral pattern that allows an object to change its behavior when its internal state changes, as if the object changed its class.

A behavioral pattern that defines a family of algorithms, encapsulates each one, and makes them interchangeable at runtime without changing the client.

Hands-on examples of Strategy using classic classes, lambdas, Spring DI, and the strategy registry for runtime selection.

How Java streams work — pipeline anatomy, lazy evaluation, intermediate vs. terminal operations, and common pitfalls.

Hands-on walkthroughs of stream pipelines — filtering, mapping, flatMap, reduce, and lazy evaluation.

Java's text APIs — String immutability and the string pool, mutable alternatives with StringBuilder, and declarative list-joining with StringJoiner.

Hands-on examples for String immutability, StringBuilder loop-building, and StringJoiner delimited assembly.

String immutability, the string pool, StringBuilder, and the most useful String APIs in Java.

How Java's synchronized keyword, intrinsic locks, volatile, and the happens-before relationship prevent race conditions in multithreaded programs.

Hands-on examples showing race conditions, synchronized fixes, volatile usage, and the happens-before relationship.

High-level architecture, microservices, distributed systems, SOLID principles, caching, reliability patterns, API design, and scalability for Java/Spring Boot engineers.

Consolidated interview Q&A for System Design — covering SOLID principles, microservices, API design, caching, reliability patterns, distributed systems, and scalability.

Quick-reference summary of System Design concepts — SOLID, microservices, API design, caching, reliability patterns, distributed systems, and scalability — with top interview questions.

A behavioral pattern that defines the skeleton of an algorithm in a base class, deferring specific steps to subclasses without changing the overall structure.

How to use Testcontainers to run real PostgreSQL, MySQL, Redis, and Kafka instances inside Docker containers during Java tests.

Hands-on examples for running PostgreSQL, Redis, and Kafka in Docker containers during tests, with Spring Boot 3.1+ @ServiceConnection.

Unit testing, integration testing, Testcontainers, Mockito, JUnit 5.

Consolidated interview Q&A for Java Testing covering JUnit 5, Mockito, Spring Boot test slices, integration tests, Testcontainers, MockMvc, and WebTestClient.

Quick-reference summary of Java testing concepts — JUnit 5, Mockito, Spring Boot test slices, integration tests, Testcontainers, MockMvc, and WebTestClient.

How LoanApplicationService is unit-tested with JUnit 5 and Mockito — covering risk classification, EMI calculation, and all eligibility rules using @Nested test classes.

Three design-level strategies for writing correct concurrent code — immutability, ThreadLocal confinement, and explicit object confinement — without reaching for locks.

Hands-on walkthroughs of immutable objects, defensive copying, ThreadLocal usage (and cleanup), and safe publication.

What a Java thread is, how to create one, and the six lifecycle states a thread transitions through from creation to termination.

Hands-on code examples and step-by-step walkthroughs for Thread creation, lifecycle states, start/join/interrupt.

Database transactions, the four ACID properties, isolation levels, and how deadlocks occur — with Spring @Transactional context.

Hands-on examples of Spring @Transactional — propagation, isolation levels, deadlock handling, and common pitfalls.

How to throw, catch, and clean up after exceptions in Java — covering multi-catch, finally guarantees, and the try-with-resources statement.

Hands-on examples for try/catch/finally, multi-catch, try-with-resources, suppressed exceptions, and finally pitfalls.

How Java converts values between types — widening, narrowing, implicit promotion, and explicit casting.

How the Java compiler removes all generic type information before producing bytecode, why this design choice was made for backward compatibility, and what limitations it imposes at runtime.

Hands-on code examples demonstrating what you can and cannot do because of Java's type erasure — instanceof, new T(), overloading, and the super type token pattern.

How the Java compiler deduces types automatically — covering the diamond operator, generic method type inference, `var` (Java 10+), and lambda target typing — and where inference has limits.

Hands-on code examples for the diamond operator, generic method inference, var for local variables, and lambda target typing.

The 8 primitive types, reference types, literals, constants, and the final keyword in Java.

Git internals, branching strategies, workflows, and collaboration best practices.

Consolidated interview Q&A for Git and version control covering beginner through advanced topics — Git basics, three-area model, object model, branching, rebase, remotes, conflict resolution, and hooks.

Quick-reference summary of Git basics, object model internals, branching strategies, rebase vs. merge, remotes, conflict resolution, and hooks for Java backend engineers.

Hands-on walkthroughs of creating virtual threads, measuring scalability, detecting pinning, and using StructuredTaskScope.

Project Loom's virtual threads — how they work, how they remove the scalability ceiling of thread-per-request servers, and what pinning and structured concurrency mean for your code.

How Object.wait(), notify(), and notifyAll() coordinate threads using the intrinsic monitor — including the spurious wakeup rule and when to use each method.

Hands-on walkthroughs of Object.wait(), notify(), notifyAll() with producer-consumer patterns and timed waits.

Consolidated interview Q&A for the Web & REST domain — HTTP fundamentals, REST design, Spring MVC, exception handling, WebFlux, and OpenAPI — beginner through advanced.

Quick-reference summary of HTTP fundamentals, REST design, Spring MVC, exception handling, WebFlux, and OpenAPI for Java backend engineers.

Hands-on Spring WebFlux examples covering Mono/Flux basics, annotated controllers, functional routing, parallel I/O with Mono.zip, and SSE streaming.

Spring WebFlux — the reactive, non-blocking alternative to Spring MVC — covering Mono, Flux, functional endpoints, backpressure, and when to choose reactive over the blocking model.

How Java's wildcard type arguments — `?`, `? extends T`, and `? super T` — express variance in generic APIs, and how the PECS rule guides correct usage.

Hands-on code examples for unbounded wildcards, upper-bounded (? extends T), lower-bounded (? super T), and the PECS rule.

How Git remotes work under the hood — fetch vs. pull, push, remote-tracking branches, upstream conventions, and collaborating safely with a team via GitHub or GitLab.

Java's eight primitive wrapper types — Integer, Long, Double, and friends — covering autoboxing, caching traps, parsing, and when to use primitives vs objects.

Hands-on examples for autoboxing, the Integer cache trap, parse methods, and unboxing NullPointerException.