Java Features and Problems Solved

Explain how bytecode, JVM implementations, and compatibility rules support “write once, run anywhere.”

Build a milestone timeline from Oak and Java 1.0 through OpenJDK, the JCP, and the time-driven release model.

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 bytecode verification and the original sandbox model addressed untrusted mobile-code risks.

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.

Determine when escape analysis can enable stack allocation, lock elimination, or scalar replacement.

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

Trace object allocation through thread-local allocation buffers, Eden, survivor regions, and promotion.

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 the Collections Framework replaced incompatible container classes with shared interfaces and algorithms.

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

Compare the problems addressed by JNI, RMI, and early distributed-object middleware.

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

Explain how dynamic proxies and object serialization enabled middleware while introducing compatibility and security risks.

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.

Use enums to model type-safe finite domains with fields, methods, and behavior.

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

Explain how the revised Java Memory Model defined visibility, ordering, final-field safety, and happens-before relationships.

Compare executors, locks, atomics, synchronizers, and concurrent collections with manual monitor-based coordination.

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.

Use `opens`, service loading, and layers to reason about reflection, dependency injection, and plug-in architectures.

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

Use JShell to test language, API, and JVM behavior in small reproducible experiments.

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

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.

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 sealed classes and interfaces to define closed domain hierarchies.

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

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.

Explain how the Foreign Function and Memory API addresses JNI complexity and off-heap memory safety.

Explain how structured concurrency treats related subtasks as a single failure, cancellation, and observability unit.

Compare scoped values with thread-local variables for immutable context propagation.

Classify major post-Java 21 changes by the problems they target and by final, preview, or incubator status.

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.

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.

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.