Java Theory Interview Preparation

Answer the interview question: “What are the JDK, JVM, JRE, and bytecode, and how do their roles differ?”

Answer the interview question: “How is Java source code compiled, loaded, and executed?”

Answer the interview question: “How does Java’s static type system differ from JavaScript’s dynamic type system?”

Answer the interview question: “What is the difference between primitive types and reference types in Java?”

Answer the interview question: “What are wrapper classes, autoboxing, and unboxing, and what pitfalls can they cause?”

Answer the interview question: “Is Java pass-by-value or pass-by-reference?”

Answer the interview question: “How do packages and access modifiers control visibility in Java?”

Answer the scenario: “A Java application compiles locally but fails in deployment with UnsupportedClassVersionError. What caused this, and how would you fix it?”

Answer the interview question: “How are classes, objects, fields, methods, and constructors related?”

Answer the interview question: “What is encapsulation, and how does it protect a class’s invariants?”

Answer the interview question: “How do method overriding and dynamic dispatch provide runtime polymorphism?”

Answer the interview question: “What is the difference between method overloading and method overriding?”

Answer the interview question: “What do static and final mean when applied to variables, methods, and classes?”

Answer the interview question: “How does constructor chaining work with this and super?”

Answer the scenario: “A service hierarchy needs code reuse, but its implementations may evolve independently. Would you use inheritance or composition, and why?”

Answer the scenario: “Several unrelated classes need the same capability, while some implementations also share state. Would you use an interface, an abstract class, or both?”

Answer the interview question: “What is java.lang.Object, and which of its methods are commonly overridden?”

Answer the interview question: “What is the difference between == and equals in Java?”

Answer the interview question: “What is the equals and hashCode contract, and why does it matter?”

Answer the interview question: “Why is String immutable in Java?”

Answer the interview question: “How does the String pool work, and how do literals differ from strings created with new?”

Answer the interview question: “What are Java enums, and why are they preferable to untyped constants?”

Answer the scenario: “A single-threaded process repeatedly builds a large response string. Would you use String, StringBuilder, or StringBuffer, and why?”

Answer the scenario: “A class has final fields but exposes a mutable List. Is it truly immutable, and how would you correct the design?”

Answer the interview question: “How do generics provide compile-time type safety?”

Answer the interview question: “What is type erasure, and what practical limitations does it create?”

Answer the interview question: “Why is List<Integer> not a subtype of List<Number>?”

Answer the interview question: “What is the difference between upper-bounded and lower-bounded wildcards?”

Answer the interview question: “What does producer extends, consumer super mean?”

Answer the interview question: “How do generic classes, generic interfaces, and generic methods differ?”

Answer the conceptual question: “Why can you read Numbers from List<? extends Number> but not safely add an Integer to it?”

Answer the scenario: “An API copies values from a source collection into a destination collection. Which wildcard bounds should it use, and how does PECS justify them?”

Answer the interview question: “How are Collection, List, Set, Queue, and Map related?”

Answer the scenario: “A workload performs frequent random reads and occasional middle insertions. Would you choose ArrayList or LinkedList, and why can Big-O alone be misleading?”

Answer the interview question: “How does HashMap work internally?”

Answer the scenario: “A HashMap lookup fails after a field inside a key object is changed. Explain the failure using equals, hashCode, and bucket placement.”

Answer the scenario: “Choose among HashMap, LinkedHashMap, and TreeMap for ordinary lookup, access-order caching, and sorted-key traversal.”

Answer the interview question: “How do HashSet, LinkedHashSet, and TreeSet differ?”

Answer the interview question: “What is the difference between Comparable and Comparator?”

Answer the scenario: “Removing items inside a for-each loop causes ConcurrentModificationException. Why does this happen, and which removal approaches are safe?”

Answer the interview question: “How is the Throwable hierarchy organized, and how do Error and Exception differ?”

Answer the interview question: “What is the difference between checked and unchecked exceptions?”

Answer the interview question: “How does an exception propagate through the Java call stack?”

Answer the interview question: “How do try, catch, finally, throw, and throws differ?”

Answer the interview question: “How do try-with-resources and AutoCloseable ensure resource cleanup?”

Answer the interview question: “When and how should you create custom exceptions?”

Answer the interview question: “What are good practices for wrapping, translating, logging, and preserving exception causes?”

Answer the scenario: “Both a try block and AutoCloseable.close throw exceptions. Which exception propagates, and how can the other one be inspected?”

Answer the interview question: “What is a functional interface, and what does @FunctionalInterface do?”

Answer the interview question: “What can a lambda capture, and why must local variables be effectively final?”

Answer the interview question: “What is the difference between a lambda expression and a method reference?”

Answer the scenario: “A stream containing peek and filter appears to do nothing because it has no terminal operation. Why?”

Answer the scenario: “Each order contains multiple line items. Would you use map or flatMap to produce one stream of all line items, and why?”

Answer the scenario: “A parallel stream adds results to a shared ArrayList and produces missing or corrupted results. What went wrong, and how should it be redesigned?”

Answer the interview question: “How do collectors perform grouping, partitioning, and reduction?”

Answer the design question: “Which uses of Optional—as a return type, parameter, field, or unchecked get call—communicate absence safely, and which are usually anti-patterns?”

Answer the interview question: “What happens during class loading, linking, and initialization?”

Answer the conceptual scenario: “Two classes have the same fully qualified name but were loaded by different class loaders. Why can assignment or casting between them fail?”

Answer the interview question: “What is stored in JVM stack frames, the heap, metaspace, and native memory?”

Answer the scenario: “An object leaves local scope but remains referenced by a static cache. Is it eligible for garbage collection, and why?”

Answer the scenario: “A service experiences periodic pause spikes as object allocation rises. How might generational garbage-collection behavior contribute?”

Answer the interview question: “What is the difference between strong, soft, weak, and phantom references?”

Answer the interview question: “What does the JIT compiler do, and how does it affect Java performance?”

Answer the diagnostic scenario: “Heap usage keeps growing even though garbage collection runs. How would you distinguish a Java memory leak, OutOfMemoryError, and StackOverflowError?”

Answer the interview question: “What is the difference between concurrency, parallelism, and asynchronous execution?”

Answer the interview question: “What are the Java thread states, and what causes a thread to enter each state?”

Answer the interview question: “How do intrinsic locks and synchronized methods or blocks work?”

Answer the interview question: “What does volatile guarantee, and what does it not guarantee?”

Answer the interview question: “What is a happens-before relationship in the Java Memory Model?”

Answer the scenario: “Two threads increment a shared counter, but the final value is too low. Explain the failure in terms of race conditions and atomicity.”

Answer the scenario: “A configuration object is shared with worker threads after construction. How do immutability and safe publication determine whether they see consistent state?”

Answer the scenario: “Two account-transfer threads acquire locks in opposite orders and stop progressing. Diagnose the problem and distinguish it from livelock and starvation.”

Answer the interview question: “Why are executor services usually preferred to creating threads manually?”

Answer the scenario: “Traffic spikes while tasks are slow. Which executor strategy would you choose, and what queue-growth or thread-growth risks must you consider?”

Answer the scenario: “A background task returns a value, may fail, and triggers dependent asynchronous stages. Which roles would Runnable, Callable, Future, and CompletableFuture play?”

Answer the interview question: “How does CompletableFuture compose asynchronous operations and handle failures?”

Answer the scenario: “A thread must attempt lock acquisition with a timeout and remain interruptible. Would you use synchronized or Lock/ReentrantLock, and why?”

Answer the interview question: “When are atomic variables suitable for lock-free state updates?”

Answer the scenario: “A check-then-act update loses data even though it uses ConcurrentHashMap. Why is the compound action unsafe, and which atomic map operations help?”

Answer the scenario: “A parallel stream performs blocking I/O and slows the application. Explain the common-pool risk and when parallel streams are appropriate.”

Answer the scenario: “Two monetary values, 10.0 and 10.00, compare unexpectedly. How do BigDecimal construction, scale, equals, and compareTo explain the result?”

Answer the scenario: “Users in different time zones see the wrong appointment time. Which java.time types should represent local, instant, and zoned values?”

Answer the interview question: “What are annotation targets and retention policies?”

Answer the scenario: “A framework uses reflection to inspect and invoke otherwise inaccessible members. What flexibility does this provide, and what safety, performance, and encapsulation costs follow?”

Answer the scenario: “A serialized object fails after its class evolves between deployments. Explain the versioning and security risks and why another data format may be preferable.”

Answer the design scenario: “You need a DTO, a mutable ORM entity, and a behavior-rich domain object. For which of these is a record appropriate?”

Answer the scenario: “A payment model has a fixed set of permitted variants. How can a sealed hierarchy enforce this and support exhaustive reasoning?”

Answer the interview question: “What does var do, and what are the limits of local-variable type inference?”