Java Core Concepts

Compile and run a Java 21 program using the JDK command-line tools.

Explain how Java source code becomes bytecode executed by the JVM.

Declare and use primitive values, object references, strings, and local type inference.

Predict the results of Java numeric conversions, promotion, and integer overflow.

Implement branching and iteration using Java statements and switch expressions.

Define and call methods with typed parameters, return values, and overloads.

Trace Java's pass-by-value behavior for primitives and object references.

Create, access, and copy single-dimensional and multidimensional arrays.

Define a class whose constructors establish valid object state.

Enforce encapsulation using packages and Java access modifiers.

Distinguish instance members from static members in executable code.

Represent immutable data using final fields and Java records.

Model a fixed set of domain values with enums.

Implement behavior contracts with interfaces.

Choose composition or inheritance for a given backend design scenario.

Implement consistent equals, hashCode, and toString methods for a value object.

Create a Maven project with reproducible dependency versions and appropriate scopes.

Run targeted build phases and distinguish Maven lifecycle phases from plugin goals.

Write isolated unit tests with JUnit 5 assertions and lifecycle hooks.

Express multiple test cases with JUnit parameterized tests.

Replace an external collaborator with Mockito and verify observable interactions.

Launch PostgreSQL for an integration test with Testcontainers and manage its test lifecycle.

Measure test coverage and identify behavior that remains unverified.

Debug a failing Java test from its stack trace and root cause.

Select an appropriate List, Set, Map, or Queue implementation for a stated requirement.

Implement collection operations while accounting for ordering, uniqueness, and mutation.

Write a reusable method using a generic type parameter.

Apply bounded wildcards using the producer-extends, consumer-super rule.

Pass behavior with standard functional interfaces, lambdas, and method references.

Build a lazy stream pipeline using filtering, mapping, and reduction.

Transform stream elements into grouped or indexed results with collectors.

Represent an optional return value without unsafe null handling.

Choose between a checked exception and an unchecked exception for an API failure.

Translate a low-level exception into a domain-specific exception while preserving its cause.

Execute a parameterized JDBC query while managing connection, statement, and result-set lifetimes with try-with-resources.

Inspect compiled classes and method bytecode with javap.

Trace local variables and objects through JVM stack and heap memory.

Explain the loading, linking, and initialization of a Java class.

Compare common garbage-collection strategies and their latency-throughput trade-offs.

Use JVM diagnostic data to identify a likely source of excessive memory retention.

Identify a race condition caused by a non-atomic shared-state operation.

Use happens-before relationships to reason about visibility between threads.

Protect mutable state using synchronization or explicit locks.

Select an atomic type or concurrent collection for a stated concurrency requirement.

Execute bounded background work with ExecutorService and handle task failures.

Compose asynchronous operations and errors with CompletableFuture.

Use virtual threads for a blocking I/O workload and state when they are unsuitable.

Use a thread dump to diagnose a deadlock or blocked-thread bottleneck.

Explain inversion of control and dependency injection in terms of a Spring application context.

Register application components and connect them using constructor injection.

Define third-party or conditional beans with Java configuration.

Choose an appropriate Spring bean scope for a stated use case.

Use configuration properties and profiles for type-safe environment-specific settings.

Trace the main steps in Spring Boot auto-configuration for a selected feature.

Identify behavior introduced by a Spring AOP proxy and its effect on internal method calls.

Organize the course service into enforceable application and domain boundaries.

Implement REST routes with Spring MVC controllers and typed request binding.

Define request and response DTOs without exposing persistence entities.

Reject invalid API input using Jakarta Bean Validation constraints.

Return consistent RFC 9457 problem details from centralized exception handling.

Control JSON serialization and deserialization with Jackson annotations and configuration.

Implement pagination, sorting, and filtering for a collection endpoint.

Publish an OpenAPI description for the service and verify that it matches controller behavior.

Test controller behavior and HTTP contracts with MockMvc.

Map a domain entity and value types to a relational schema with JPA.

Model an entity association with an explicit fetch and cascade strategy.

Implement repository queries using derived methods and JPQL.

Detect and eliminate an N+1 query problem in a JPA request path.

Version a PostgreSQL schema using Flyway migrations.

Define a transaction boundary and predict rollback behavior through Spring proxies.

Prevent a lost update using optimistic locking.

Implement a PostgreSQL-backed idempotency-key check for a retryable write endpoint.

Trace an HTTP request through the Spring Security filter chain.

Configure a stateless Spring Security resource server that validates JWT access tokens.

Map token claims to application roles and authorities.

Enforce authorization rules at both route and method levels.

Store locally managed passwords using an adaptive password hash.

Configure CORS and CSRF protections for a stated browser-client architecture.

Return safe and consistent responses for authentication and authorization failures.

Test authenticated, unauthorized, and forbidden API scenarios.

Expose meaningful liveness, readiness, and dependency health indicators with Spring Boot Actuator.

Publish service-level metrics with Micrometer.

Propagate trace and correlation identifiers across an HTTP request path.

Configure Logback to emit structured JSON logs with specified sensitive fields masked.

Apply timeouts, retries, and a circuit breaker to an outbound HTTP client.

Implement cache-aside behavior with Spring Cache and Redis.

Publish and consume a durable domain event with Spring AMQP and RabbitMQ.

Make message processing safe under redelivery using an idempotent-consumer strategy.

Build a layered, minimal, non-root container image for the Spring Boot service.

Derive container-aware JVM memory settings from explicit CPU and memory limits.

Configure Java-focused CI quality gates for Maven tests, coverage, dependency scanning, and container scanning.

Configure Kubernetes probes and graceful shutdown for Spring Boot, then verify rollout behavior.

Capture and interpret a Java Flight Recorder profile for a service workload.

Solve a timed Java coding problem using collections and justify its time and space complexity.

Diagnose an interview-style Spring scenario involving dependency injection, proxies, and transaction boundaries.

Create a portfolio-ready architecture brief that justifies the completed service's reliability, security, and data-consistency trade-offs.