Pick a focused question that fits your time, stack, and interview goal.
How much time do you have?
Show one-drill sessions you can finish now.
208 results across 1 active filter
Page 6 of 9
Uses the JPA slice for mappings and repositories while recognizing embedded-database substitutions and transaction-owned blind spots.
Defines encapsulation as control over state and valid transitions, then connects it to defensive copying and persistence boundaries.
Separates final assignment, method overriding, and class inheritance while making clear that a final reference does not make an object immutable.
Explains visibility and ordering through synchronization actions instead of misleading main-memory and thread-cache folklore.
Explains which side writes a foreign key or join table and why both sides of an in-memory bidirectional relationship must remain consistent.
Explains configuration loading, bean-definition processing, dependency resolution, lifecycle, events, resources, and environment access.
Treats isolation as concurrency behavior and read-only and timeout as resource hints whose enforcement depends on the transaction stack.
Separates dependency bundles, tested version alignment, transitive dependencies, and runtime auto-configuration.
Explains monitor mutual exclusion, visibility, reentrancy, lock identity, scope, and contention.
Designs scheduled work for overlap, multiple replicas, restart, failure, and durable ownership instead of assuming one execution.
Explains the path from Java source to bytecode and running code, including class loading and the JIT without turning the answer into JVM trivia.
Defines abstraction as a deliberate contract over essential behavior and keeps Java mechanisms secondary to the design purpose.
Explains Java lambdas as implementations of single-abstract-method contracts and connects standard interfaces to API design.
Explains the persistence context as an identity map and unit of work that tracks managed entities through EntityManager.
Defines OOP directly and connects Java objects, responsibilities, state, behavior, and collaboration to a practical design.
Explains making a fully constructed object visible through valid happens-before edges and final-field semantics.
Distinguishes a Java type definition from a concrete runtime instance and keeps identity, state, and polymorphism tied to the question.
Separates rapidly created short-lived objects from object graphs that remain reachable and chooses evidence and fixes accordingly.
Separates proving an identity from deciding whether that identity may perform a specific action on a resource.
Distinguishes a type's natural order from external, reusable sort strategies and connects comparison consistency to sorted collections.
Separates managing overlapping tasks from executing work simultaneously and connects both to Java backend design.
Separates view-oriented controller return handling from class-level response-body semantics without implying different request mapping.
Contrasts blocking result retrieval with composable completion stages, explicit executors, failure handling, and limited cancellation guarantees.
Separates mandatory persistence-context identity from optional shared entity caching and its consistency tradeoffs.