Master Java Interview Essentials: 8 Classic Questions Explained

The author, with nearly seven years at Oracle, shares insights from interviewing Java engineers of all levels, emphasizing the importance of solid computer‑science fundamentals and the ability to articulate the reasoning behind technical choices.

Common pitfalls observed in candidates:

Knowing the "what" but not the "why". Many can code but fail to explain the rationale behind technology decisions.

Fragmented knowledge. Candidates often cannot describe their systems holistically, focusing on narrow details without a broader view.

To address these issues, the author presents eight classic Java interview questions, focusing on the "key points analysis" for each.

1. Understanding the Java Platform

Interviewers expect candidates to demonstrate comprehensive knowledge of Java, covering language features (generics, lambdas), core libraries (collections, IO/NIO, networking, concurrency, security), and the ability to summarize these areas concisely.

2. Exception vs. Error

The distinction lies in the design of the Throwable hierarchy. Candidates should explain the roles of Exception, RuntimeException, and Error, name common subclasses, and describe best‑practice handling patterns such as try‑catch‑finally and custom exceptions.

3. Reflection and Dynamic Proxies

Reflection provides runtime introspection, enabling flexible manipulation of classes and objects. Dynamic proxies extend this capability to reduce boilerplate code in repetitive scenarios. Interviewers may probe:

Depth of understanding of the reflection API and its performance implications.

Typical use cases for dynamic proxies and differences between JDK proxies and libraries like cglib.

4. I/O, NIO, and NIO.2

Key discussion points include:

Basic API differences between InputStream/OutputStream and Reader/Writer.

Core components of NIO and NIO.2 (channels, buffers, selectors).

Design of BIO vs. NIO models and how multiplexing is achieved in NIO.

Potential shortcomings of NIO implementations and ideas for improvement.

5. Ensuring Thread Safety and ConcurrentHashMap

Traditional synchronization (e.g., synchronized blocks, Collections.synchronizedMap) offers coarse‑grained locking, which can degrade performance under high concurrency. Modern approaches favor the java.util.concurrent package:

Concurrent collections such as ConcurrentHashMap and CopyOnWriteArrayList.

Thread‑safe queues like ArrayBlockingQueue and SynchronousQueue.

Fine‑grained locking techniques (e.g., lock striping in ConcurrentHashMap).

6. Interfaces vs. Abstract Classes

Interviewers assess:

Correct syntax and ability to declare interfaces and abstract classes.

Appropriate design choices—when to favor an interface for multiple implementations versus an abstract class for shared code.

Evolution of Java language features (default methods, functional interfaces) that affect this decision.

7. How synchronized Works Internally

The intrinsic lock is implemented using object headers, with lock states (biased, lightweight, heavyweight) that can be upgraded or downgraded based on contention. Understanding these mechanisms helps explain performance characteristics and common pitfalls.

8. synchronized vs. ReentrantLock

Both provide mutual exclusion, but ReentrantLock offers additional capabilities such as fairness policies, interruptible lock acquisition, and condition variables. Performance varies by Java version and contention level; recent JVMs have optimized synchronized considerably.