LLD / Java / OOP Interview Questions Bank

Overview

• Part A: Conceptual Q&A
• Part B: 30 LLD Problems

Part of the Interview Prep series. Dotted-underline words are glossary terms: hover for the meaning or open the Glossary. Track your progress on the Interview Prep tracker. Series index: Start here.

Part A: 60 conceptual questions with crisp answers. Part B: 30 LLD problems with difficulty and patterns.

---

Part A: Conceptual Q&A

OOP and design principles

1. Abstract class vs interface? Interface: contract/capability, multiple implementation, no instance state (default/static methods allowed). Abstract class: shared state + partial implementation, single inheritance. Start with an interface; add an abstract skeleton (AbstractX) if sharing code.
2. Overloading vs overriding? Overloading: same name, different params, resolved at compile time. Overriding: subclass redefines inherited method, resolved at runtime (dynamic dispatch); same signature, covariant return allowed, no narrower access, no broader checked exceptions.
3. Composition vs inheritance? Prefer composition: runtime flexibility, no fragile base class, better testing. Inheritance only for genuine is-a honoring LSP.
4. Explain each SOLID letter with a smell. S: class with many reasons to change. O: if/else on type. L: override throws UnsupportedOperationException. I: stub methods in implementors. D: new ConcreteX() inside business class.
5. What is Liskov violation example? Square extends Rectangle where setWidth also changes height; or FixedDeposit.withdraw() throwing. Callers using the base type break.
6. DI vs DIP vs IoC? DIP: principle (depend on abstractions). DI: technique (pass dependencies in). IoC: framework controls object creation/wiring (Spring).
7. Tell, Don't Ask / Law of Demeter? Ask objects to do work rather than reading their state to decide externally; only talk to immediate collaborators (a.b().c().d() is a smell).
8. Cohesion and coupling? Aim high cohesion (focused class), low coupling (few abstract dependencies).
9. Association, aggregation, composition? Uses; has-a with independent life; owns with same lifetime (delete parent -> delete child).
10. Immutable object: how to build? final class, private final fields, no setters, defensive copies of mutable inputs/outputs, no this escape. Benefits: thread-safe, cache/hash-key safe.
11. Why override equals and hashCode together? Contract: equal objects must have equal hashes, else HashMap/HashSet break. Use value-based fields; make keys immutable.
12. Value object vs entity? Value object: no identity, immutable, equality by value (Money). Entity: identity + lifecycle (Account).
13. Why not double for money? Binary floating point can't represent 0.1 exactly. Use BigDecimal (with scale + RoundingMode) or integer minor units (long paise); store currency with amount.
14. What is an anemic domain model and why avoid? Entities with only getters/setters and logic in services; loses encapsulation and invariants. Put behavior with data.
15. YAGNI vs extensibility? Build for stated requirements; place interfaces at known volatility points; describe, don't build, other extensions.
16. Checked vs unchecked exceptions in domain design? Checked for recoverable business failures the caller must handle (InsufficientFundsException); unchecked for programming errors/invalid args. Never swallow; preserve cause; no exceptions for control flow in hot paths.
17. Why favor Optional return over null? Makes absence explicit; don't use it for fields/params.
18. What is the Open/Closed principle in practice? Add a new class implementing an interface and register it; no edits to existing tested code.

Design patterns

19. Strategy vs State? Both delegate to a polymorphic object. Strategy: client chooses interchangeable algorithms, strategies don't know each other. State: the context transitions between states itself; states know the next states.
20. Factory vs Abstract Factory vs Builder? Factory: creates one product by input. Abstract Factory: families of related products. Builder: assembles one complex object step by step.
21. Decorator vs Proxy vs Adapter vs Facade? Decorator adds behavior (same interface). Proxy controls access (same interface). Adapter converts interface. Facade simplifies a subsystem with a new, simpler interface.
22. Observer vs Pub-Sub? Observer: subject holds direct references to observers (in-process). Pub-Sub: broker/topic decouples publisher from subscriber (often async, cross-process).
23. Thread-safe Singleton options? Enum; static holder (lazy, lock-free); eager static final; DCL with volatile. Mention reflection/serialization (enum immune), testability cost, prefer DI.
24. Why volatile in DCL? Without it, object construction can be reordered so another thread sees a non-null but partially constructed instance.
25. Command pattern use? Request as object: queue, log, retry, undo/redo. Needs execute/undo.
26. Chain of Responsibility use? Pipeline of handlers, each handles or forwards: validators, middleware, ATM note dispensing, logger levels.
27. Template Method vs Strategy? Template: inheritance, fixed skeleton, vary steps (compile-time). Strategy: composition, swap whole algorithm at runtime.
28. When is Singleton an anti-pattern? Hidden global state, hard to mock, concurrency/lifecycle issues, couples classes. Use only for stateless/shared infra; otherwise inject a single instance.
29. Visitor: when? Adding operations over a stable class hierarchy without modifying it (AST, tax rules by item type). Cost: adding new element types is hard.
30. Repository vs DAO? DAO is table/CRUD oriented; Repository is collection-like over aggregates in domain language. Practically similar.
31. Flyweight / Prototype / Memento: one-liners? Flyweight: share immutable intrinsic state (chess pieces, glyphs). Prototype: clone existing object. Memento: snapshot state for undo.
32. What is dependency injection types? Constructor (preferred, immutable, required deps), setter (optional), interface/field (avoid).

Java and collections

33. HashMap internals? Array of buckets, hash(key) & (n-1), collisions as linked list -> tree (>=8, Java 8). Resize at load 0.75, doubling. Average O(1); not thread-safe.
34. HashMap vs ConcurrentHashMap vs Hashtable vs synchronizedMap? HashMap: fast, unsafe. Hashtable: whole-table lock, legacy. synchronizedMap: one mutex, compound ops still need external sync. CHM: CAS + per-bin locks, atomic compute/merge, no nulls.
35. LinkedHashMap for LRU? new LinkedHashMap(cap, 0.75f, true) with removeEldestEntry returning size() > cap; access-order. O(1). Manual alternative: HashMap + doubly linked list.
36. ArrayList vs LinkedList? ArrayList: O(1) random access, amortized O(1) append, cache-friendly. LinkedList: O(1) insert at known node, O(n) index; rarely better; use ArrayDeque for queues.
37. PriorityQueue complexity and ordering? Binary heap: offer/poll O(log n), peek O(1); iteration order not sorted. Needs Comparable or Comparator; not thread-safe (use PriorityBlockingQueue).
38. TreeMap use? Red-black tree, sorted keys, O(log n); floorKey/ceilingKey/subMap for range queries (e.g., interval/slab pricing).
39. final vs finally vs finalize? Constant/non-overridable; always-run cleanup block; deprecated GC hook (use try-with-resources/Cleaner).
40. String immutability and why? Safe sharing, hash caching, security, string pool. Use StringBuilder for concatenation loops.
41. Streams: pitfalls? Don't mutate external state in lambdas, avoid parallel streams for small/IO tasks, don't reuse a stream, Collectors.toMap throws on duplicate keys.
42. Generics: ? extends vs ? super? PECS: Producer Extends, Consumer Super. Type erasure: no new T(), no generic arrays.
43. Equality: == vs equals? BigDecimal.equals gotcha? == reference. new BigDecimal("1.0").equals(new BigDecimal("1.00")) is false (scale differs); use compareTo.
44. Functional interfaces and lambdas in design? Supplier/Function/Predicate make strategies and callbacks terse; single-method interface = lambda target.
45. Serializable / transient / serialVersionUID? Marker for Java serialization; transient skips field; set serialVersionUID to control compat. Prefer JSON/Protobuf for APIs.

Concurrency

46. synchronized vs ReentrantLock? synchronized: simple, auto-release. Lock: tryLock/timeouts, interruptible, fair, multiple Conditions, manual unlock in finally.
47. volatile vs atomic vs synchronized? volatile: visibility only. Atomic: lock-free single-variable atomic ops (CAS). synchronized: compound atomicity + visibility.
48. How does deadlock occur and how to prevent? Circular wait on locks. Fix: global lock ordering, tryLock + back-off, fewer locks, lock-free structures, one lock per transfer in DB with ordered FOR UPDATE.
49. Race condition vs data race? Data race: unsynchronized conflicting accesses. Race condition: outcome depends on timing (check-then-act), possible even with atomic ops.
50. How do you make a wallet debit thread-safe? Per-wallet lock around check+update, or CAS loop on an AtomicLong, or DB conditional UPDATE ... WHERE balance >= :amt. Transfers: ordered double-locking.
51. Optimistic vs pessimistic locking? Optimistic: version check at commit, retry on conflict (low contention). Pessimistic: lock upfront (high contention, must not fail).
52. ReadWriteLock when? Read-mostly data (config, rate cache). Not useful when writes are frequent or reads are trivially short.
53. Thread pool sizing? CPU-bound: ~cores. I/O-bound: cores x (1 + wait/compute). Use bounded queues and a rejection policy; separate pools per workload (bulkheads).
54. What does ConcurrentHashMap.computeIfAbsent guarantee? The mapping function runs at most once per key atomically; it must be short and not touch the map.
55. BlockingQueue use cases? Producer-consumer, work queues, back-pressure via bounded capacity; poison pill for shutdown.
56. CompletableFuture vs Future? Future blocks on get(). CF composes callbacks (thenApply/thenCompose/allOf/exceptionally) and completes manually.
57. What is idempotency and how to implement? Same request repeated yields the same effect. Idempotency key + atomic claim (DB unique constraint / putIfAbsent) + stored response; dedupe at-least-once messages.
58. ThreadLocal pitfalls? Leaks in pools if not remove()d; don't rely on it for business state.
59. Semaphore vs CountDownLatch vs CyclicBarrier? Semaphore: N permits (throttle). Latch: one-shot wait for N events. Barrier: reusable rendezvous of N threads.
60. Happens-before examples? unlock -> subsequent lock; volatile write -> subsequent read; Thread.start -> thread actions; thread end -> join return; Future.get after task completion.

System-flavored LLD questions

61. How do you ensure a payment isn't charged twice? Idempotency key, unique DB constraint, state machine preventing re-capture, outbox/ledger reconciliation.
62. How to model money movement? Double-entry ledger (debit one account, credit another, sums to zero), immutable transaction rows, balances derived or updated atomically with the entry.
63. Handling partial failure in multi-step payment? Saga/compensation (release hold, refund), status states (PENDING/SUCCESS/FAILED/UNKNOWN), retries with idempotency, reconciliation job for UNKNOWN.
64. Where do you put retries and timeouts? At the gateway adapter (Decorator/Proxy) with exponential back-off + jitter, circuit breaker; only retry idempotent operations.
65. How would you make the in-memory design persistent/distributed? Repository interface -> DB; unique constraints and conditional updates for atomicity; distributed locks (Redis/DB) sparingly; partition by account id; outbox for events.

---

Part B: 30 LLD Problems

Difficulty: E easy, M medium, H hard (for a 60-min round). Files in this folder cover the first 14.

Fintech-targeted shortlist (Visa/Mastercard/NPCI/Amex/PayU): 4, 6, 7, 29, 30, 28, 2, 3, 27, 8, 11. Prepare these with concurrency + idempotency angles.

Common follow-ups on any problem: "make it thread-safe", "add a new type X", "how to persist", "how to scale to many nodes", "how to test it", "what if two requests arrive together", "how to handle failure midway".