Java Backend Interview Preparation

Predict static-field, static-block, instance-field, instance-block, and constructor execution order across an inheritance hierarchy.

Determine member accessibility across classes, packages, subclasses, and Java modules using Java's access-control rules.

Resolve overloaded method calls involving inheritance, boxing, widening, varargs, and null at compile time.

Predict runtime method dispatch for overridden methods and distinguish it from hiding of static, private, and field members.

Choose between inheritance and composition based on coupling, substitutability, and change tolerance.

Compare abstract classes with interfaces containing abstract, default, static, and private methods.

Distinguish the effects of final on variables, references, methods, and classes from true object immutability.

Explain how sealed hierarchies support controlled inheritance and exhaustive pattern-matching switch in modern Java.

Distinguish reference identity, logical equality, and natural ordering in Java object models.

Apply the equals and hashCode contracts to predict behavior in collections and inheritance hierarchies.

Design an immutable Java class using final state, constructor validation, and defensive copying.

Explain String immutability, literal pooling, interning, and the difference between literals and explicitly constructed strings.

Choose among string concatenation, StringBuilder, and StringBuffer based on compilation behavior, mutation, and thread-safety needs.

Explain the generated semantics, restrictions, and appropriate use cases of Java records.

Explain how Java enums can model state and behavior beyond named integer constants.

Use Optional to model possibly absent results while avoiding null-like and field/parameter misuse patterns.

Define and use generic classes, interfaces, constructors, and methods with appropriate type inference.

Explain generic invariance by contrasting parameterized collections with Java array covariance.

Use upper-bounded and lower-bounded wildcards to express producer and consumer relationships.

Apply type-parameter bounds, including recursive and multiple bounds, to constrain generic APIs.

Explain type erasure and predict its effects on runtime type information, casts, and method signatures.

Identify reifiable and non-reifiable types and explain restrictions on generic arrays, instanceof, and class literals.

Diagnose raw-type usage, heap pollution, generic varargs risks, and the purpose of @SafeVarargs.

Explain bridge methods and how erasure interacts with overriding and binary compatibility.

Classify Throwable types as checked exceptions, unchecked exceptions, or errors and justify suitable handling policies.

Trace exception propagation through call stacks, ordered catch clauses, and multi-catch handlers.

Apply the exception compatibility rules for overriding methods and functional interfaces.

Predict control flow when try, catch, and finally blocks contain returns, throws, or state changes.

Explain when checked exceptions clarify an API contract and when unchecked exceptions are more appropriate.

Use try-with-resources to reason about AutoCloseable resources and reverse-order closing.

Inspect primary and suppressed exceptions when both a resource body and resource cleanup fail.

Design custom exceptions that preserve causes, useful context, and an appropriate abstraction boundary.

Compare worst-case, average-case, and amortized time and space complexity for common operations.

Explain the memory layout and operation costs of arrays and dynamically resized arrays.

Compare singly linked and doubly linked structures in terms of traversal, insertion, deletion, and memory overhead.

Select among stacks, queues, and deques based on ordering and access requirements.

Explain hash-table collision strategies, load factor, resizing, and the assumptions behind expected constant-time access.

Explain binary-search-tree ordering and why self-balancing trees protect operation complexity.

Explain binary-heap invariants and derive the complexity of insertion, removal, and heap construction.

Select an appropriate data structure from workload characteristics such as ordering, lookup frequency, mutation, and memory constraints.

Navigate the Collection, List, Set, Queue, Deque, Map, and Java 21 sequenced-collection abstractions and their contracts.

Explain how Iterable, Iterator, and enhanced for loops cooperate and when iterator removal is valid.

Analyze ArrayList capacity growth, indexed access, insertion, removal, and structural modification behavior.

Compare LinkedList with ArrayList and ArrayDeque using operation costs, locality, allocation overhead, and API fit.

Choose correctly among Queue and Deque insertion, removal, and inspection methods that throw exceptions or return sentinel values.

Explain ArrayDeque's circular-array behavior and PriorityQueue's heap ordering, including why iteration is not sorted.

Diagnose fail-fast iteration and ConcurrentModificationException without mistaking it for a thread-safety guarantee.

Distinguish fixed-size, unmodifiable-view, immutable, and defensive-copy collection creation techniques.

Trace HashMap put and get operations from hash spreading and bucket selection through key comparison.

Explain HashMap collision handling, tree bins, resizing, capacity, and load-factor trade-offs.

Diagnose failed map lookups caused by inconsistent equals and hashCode implementations or mutable keys.

Predict HashMap behavior involving nulls, unspecified iteration order, and absence of thread safety.

Explain how HashSet implements uniqueness using HashMap and the element equality contract.

Use LinkedHashMap insertion order and access order to reason about predictable iteration and LRU-style eviction.

Explain how TreeMap and TreeSet maintain sorted operations using balanced trees.

Apply Comparable and Comparator contracts, including consistency with equals, to prevent lost or merged sorted entries.

Resolve lambdas and method references against target functional-interface types and recognize valid single-abstract-method interfaces.

Explain lambda variable capture, effectively final local variables, and the meaning of this inside a lambda.

Contrast collections with single-use, lazy stream pipelines and explain when stream operations execute.

Distinguish map, flatMap, filter, distinct, sorted, and peek by their transformation and state requirements.

Reason about terminal operations, reductions, short-circuiting, identity values, and associativity.

Build collectors for grouping, partitioning, summarizing, and map creation while handling duplicate keys.

Identify violations of non-interference, statelessness, and encounter-order assumptions in stream pipelines.

Decide when parallel streams are suitable by considering splitting cost, workload size, ordering, shared state, and execution pools.

Distinguish stack frames, the heap, metaspace, code cache, and native memory without relying on misleading stack-versus-heap rules.

Explain parent-delegation class loading and how class identity depends on both the binary name and defining class loader.

Determine object reachability from GC roots and explain why cyclic references can still be collected.

Compare strong, soft, weak, and phantom references by their garbage-collection and cleanup semantics.

Explain generational garbage-collection principles and compare the latency goals of modern collectors such as G1 and ZGC.

Diagnose common Java memory leaks involving static state, listeners, caches, ThreadLocal values, and retained collection entries.

Explain JIT warm-up, profiling, inlining, deoptimization, and why microbenchmarking Java requires special care.

Explain how reflection and runtime annotations work, including encapsulation, performance, and maintainability trade-offs.

Explain Java thread lifecycle states, scheduling limits, cooperative interruption, and interrupt-status handling.

Distinguish atomicity, visibility, and ordering failures when analyzing race conditions.

Use happens-before relationships to determine whether writes are guaranteed to be visible across threads.

Explain intrinsic monitors, synchronized methods and blocks, mutual exclusion, reentrancy, and safe publication.

State precisely what volatile guarantees and identify compound operations it cannot make atomic.

Explain compare-and-set and select atomic variables or accumulators for suitable contention patterns.

Compare intrinsic locking with ReentrantLock, read-write locks, and Condition objects.

Recognize and prevent deadlock, livelock, and starvation using ordering and bounded coordination strategies.

Explain how Executor and ExecutorService separate task submission from thread creation and lifecycle management.

Choose and size thread pools by workload type, queue strategy, saturation behavior, and rejection policy.

Use Callable and Future to reason about results, exceptions, cancellation, timeouts, and executor shutdown.

Compose CompletableFuture stages while reasoning about synchronous versus asynchronous execution and exception propagation.

Explain ConcurrentHashMap concurrency behavior and use its atomic compound operations correctly.

Select CopyOnWriteArrayList or CopyOnWriteArraySet for read-heavy snapshot-iteration workloads.

Use BlockingQueue semantics to explain producer-consumer coordination and backpressure.

Choose among thread confinement, immutability, synchronized wrappers, and concurrent collections for shared data.