Java Features and Problems Solved

Identify the constant pool, fields, methods, attributes, and version metadata in a class file using `javap -verbose`.

Trace JVM instructions through a method’s operand stack and local-variable array.

Explain the loading, verification, preparation, resolution, and initialization phases of a class lifecycle.

Predict class and interface initialization order for code involving static fields, inheritance, and default methods.

Compare bootstrap, platform, application, and custom class loaders using the parent-delegation model.

Map Java objects, method calls, metadata, and native operations to JVM runtime data areas.

Explain how verification, class loading, permissions, and sandboxing addressed untrusted mobile code, and why the Security Manager model was later deprecated.

Explain how the interpreter, C1 compiler, C2 compiler, and tiered compilation cooperate in HotSpot.

Explain how runtime profiling enables speculative optimization, uncommon traps, and deoptimization.

Explain how escape analysis can enable scalar replacement and lock elimination without assuming that HotSpot must perform literal stack allocation.

Trace an ordinary object allocation through a thread-local allocation buffer, the young generation, survivor processing, and promotion while accounting for collector-specific layouts.

Classify strong, soft, weak, and phantom reachability from GC roots.

Compare Serial, Parallel, G1, ZGC, and Shenandoah by latency, throughput, footprint, and operational goals.

Capture and interpret unified GC logs to identify allocation pressure, pause causes, and reclamation results.

Explain how reflection and introspection enabled tools, containers, plug-ins, and framework conventions.

Explain how Java serialization represented object graphs for persistence and RMI while introducing compatibility and deserialization-security risks.

Explain how JDBC separated application code from database-specific drivers and protocols.

Select JNI or RMI for a stated native-integration or remote-communication problem and explain the costs of crossing that boundary.

Explain how the Collections Framework replaced incompatible container classes with shared interfaces and algorithms.

Explain how J2EE containers centralized transactions, security, pooling, naming, and component lifecycle management.

Explain how dynamic proxies enabled interface implementations for RPC stubs, AOP, and middleware decorators at runtime.

Use NIO channels, buffers, and selectors to explain the move beyond stream-per-connection I/O.

Explain how generics added compile-time type safety while type erasure preserved binary compatibility.

Apply bounded wildcards and PECS to design flexible, type-safe APIs.

Inspect bridge methods and erased signatures to diagnose generics-related runtime behavior.

Explain how annotations replaced naming conventions and external metadata in tools and frameworks.

Explain why enums replaced int and String constant idioms, relating generated methods and constant-specific class bodies to their implementation.

Diagnose correctness and performance problems caused by boxing, unboxing, and wrapper caching.

Derive visibility and ordering guarantees for synchronization, volatile fields, safe publication, and final fields from the revised Java Memory Model.

Map executors, explicit locks, atomics, and concurrent collections to limitations of coordination based only on `synchronized`, `wait`, and `notify`.

Use try-with-resources and suppressed exceptions to implement deterministic resource cleanup.

Use NIO.2 paths, file operations, attributes, and watchers to solve filesystem portability problems.

Explain how `invokedynamic` decoupled dynamic call-site behavior from fixed JVM invocation instructions.

Translate lambda expressions and method references into functional-interface and captured-state semantics.

Analyze a Stream pipeline for laziness, fusion, encounter order, side effects, and parallelization risk.

Explain how default methods allowed interfaces to evolve without breaking existing implementations.

Use the `java.time` type system to avoid mutability, timezone, and calendar defects in legacy date APIs.

Use `Optional` appropriately for return-value absence while avoiding common API and performance misuse.

Explain how classpath ambiguity, split packages, and internal-API dependence motivated the Java Platform Module System.

Write and interpret module descriptors using readability, exports, requires, and qualified exports.

Explain how `opens` directives and open modules permit framework reflection while retaining stronger encapsulation.

Decouple service consumers and providers using JPMS `uses` and `provides` directives with `ServiceLoader`.

Use `jdeps` to identify module dependencies and internal-API usage, then propose a migration for one reported issue.

Build a reduced custom runtime image with `jlink` and explain its deployment trade-offs.

Use the standardized HTTP client to implement synchronous, asynchronous, and HTTP/2 requests.

Explain how the six-month cadence, LTS releases, deprecations, and removals changed Java upgrade strategy.

Explain the scope and type-inference limits of local-variable `var`.

Use switch expressions and exhaustiveness to replace error-prone statement-style selection.

Use text blocks while controlling indentation, line endings, and interpolation expectations.

Use records to model transparent data carriers and identify cases where records are inappropriate.

Use pattern matching for `instanceof` to combine type testing, casting, and flow scoping safely.

Use sealed classes and interfaces to define closed domain hierarchies.

Explain how strong encapsulation of JDK internals changed reflective frameworks and migration practices.

Diagnose failures with helpful null-pointer messages while distinguishing symptom localization from null-safety design.

Use record patterns to deconstruct nested data while preserving type and scope safety.

Use pattern matching for switch with guarded cases, null handling, dominance, and exhaustiveness.

Explain how virtual threads use continuations and carrier threads to make thread-per-task designs scalable.

Use sequenced collection interfaces to express first, last, and reversed encounter-order operations.

Compare JNI with the Foreign Function and Memory API in linking, data access, lifecycle safety, and target-JDK status.

Analyze how structured concurrency treats related subtasks as one failure, cancellation, and observability unit on a supporting preview JDK.

Compare scoped values with thread-local variables for immutable context propagation on a supporting JDK.

Create a release-status matrix for selected post-Java 21 features and ongoing projects using JEPs and release notes, distinguishing final, preview, incubating, and proposed work.

Design a JMH benchmark that avoids dead-code elimination, constant folding, inadequate warmup, and accidental sharing.

Record and inspect JFR events to investigate latency, allocation, locking, I/O, and CPU behavior.

Use `jcmd`, `jstack`, `jmap`, and class histograms to answer targeted production-diagnostic questions.

Interpret CPU, wall-clock, allocation, and lock profiles without confusing correlation with causation.

Read compilation and deoptimization evidence to explain a performance change in hot code.

Run a controlled GC experiment and justify heap, pause-time, and collector choices from measured results.

Compare class-data sharing, ahead-of-time techniques, and GraalVM native images by startup, footprint, peak throughput, and build cost.

Explain how container CPU and memory limits affect heap ergonomics, processor counts, GC behavior, and observability.

Prove visibility and ordering claims in concurrent code using happens-before rules.

Choose between intrinsic monitors, `ReentrantLock`, read-write locks, and stamped locks for a stated contention pattern.

Explain compare-and-set, memory effects, ABA risk, and contention in atomic operations.

Select concurrent collections according to consistency, ordering, blocking, and traversal requirements.

Explain work stealing and choose appropriately between executors and fork/join decomposition.

Compose, recover, combine, and time-bound asynchronous workflows with `CompletableFuture`.

Choose between bounded platform-thread pools and virtual-thread-per-task execution for a production workload.

Diagnose deadlock, starvation, pinning, and carrier-thread saturation using thread dumps and JFR evidence.

Trace the evolution from J2EE through Java EE to Jakarta EE, including the governance and namespace transition.

Compare the problems solved by EJB containers with those solved by Spring dependency injection and aspect-oriented infrastructure.

Explain how Spring Boot’s auto-configuration, starters, and embedded servers changed Java application delivery.

Compare Maven and Gradle in dependency resolution, reproducibility, lifecycle modeling, and build performance.

Explain how application servers, microservices, containers, and orchestration changed Java deployment architecture.

Choose between reactive pipelines and virtual-thread-based blocking code for a stated scalability problem.

Evaluate JVM deployment against native-image deployment for a cloud workload using operational evidence.

Deliver a concise architecture briefing that connects a Java feature to its historical problem, internal mechanism, trade-offs, and modern alternatives.