Top Java Interview Topics — Summary, Flashcards & Quiz Summary & Study Notes

☕ Java Platform

JDK, JRE, and JVM are distinct layers: JDK (Java Development Kit) provides development tools and compilers, JRE (Java Runtime Environment) provides the runtime libraries and JVM, and JVM executes bytecode on the target platform. The Java philosophy "write once, run anywhere" relies on compiling to platform-independent bytecode executed by the JVM.

🧠 Object-Oriented Principles

Java implements the main OOP principles: Encapsulation, Abstraction, Inheritance, and Polymorphism. Use classes and interfaces to model behavior; prefer composition over inheritance when coupling can be reduced.

🧩 Classes, Objects, and Lifecycle

Constructors initialize objects; a class can have a default constructor provided by the compiler when none is declared. final, static, and abstract have specific restrictions for constructors and methods; e.g., constructors cannot be static or final.

🔒 Access, Final, and Immutability

Mark fields final to make references immutable; immutability requires careful handling of mutable members. final classes prevent inheritance; final methods prevent overriding. Immutable objects are inherently safer for concurrency.

🧵 Threads & Concurrency

Java threads provide concurrency; synchronization and locks ensure mutual exclusion. Use synchronized blocks/methods, volatile for visibility of single variables, and higher-level constructs from java.util.concurrent (Executors, CountDownLatch, Semaphore, ConcurrentHashMap) for better performance and scalability. Beware of deadlocks, livelocks, and thread starvation; design with minimal lock scope and prefer non-blocking techniques where suitable.

♻️ Garbage Collection & Memory

JVM memory areas include Heap, Stack, Method Area, and others. Objects become eligible for GC when no live references remain. Finalization is unreliable as a cleanup mechanism; prefer try-with-resources and explicit cleanup for external resources.

🗂 Class Loading & Reflection

ClassLoader loads classes at runtime in a parent-first model by default. Reflection allows runtime inspection and dynamic invocation but breaks encapsulation and can impact performance; use it judiciously.

📚 Collections Framework

Choose collections based on access patterns: ArrayList for fast random access, LinkedList for frequent insertions/removals, HashMap for key-value with O(1) average lookup, and TreeMap when sorted order is required. Understand contracts of equals() and hashCode() for keys. Prefer generics for type safety and clarity.

⚠️ Exception Handling & I/O

Differentiate checked (compile-time) and unchecked (runtime) exceptions. Use try-catch-finally or try-with-resources for deterministic resource management. Prefer specific exception types and avoid swallowing exceptions silently.

🧩 Java 8 Features

Java 8 introduced Lambda expressions, the Stream API, Default/Static methods in interfaces, and a new Date/Time API. Use Streams for expressive, parallelizable data processing and prefer functional-style code where it improves clarity and reduces boilerplate.

🔁 Serialization & Persistence

Implement Serializable to allow object serialization; mark non-serializable fields transient. Consider custom readObject/writeObject for versioning. For ORM, Hibernate provides mapping between Java objects and relational tables, caching, and lifecycle states (transient, persistent, detached).

🏗 Spring & Dependency Injection

Spring is an application framework that provides IoC/DI, MVC, AOP, transaction management and integration modules. Define beans via XML, annotations (@Configuration, @Bean, @Component, @Autowired) or Java configuration. Prefer constructor injection for mandatory dependencies and setter injection for optional ones.

🧩 Design Patterns & Best Practices

Know common patterns: Singleton, Factory, Builder, Decorator, Strategy, Observer, and DAO. Apply SOLID principles and favor small, testable components. Use design patterns to solve recurring architectural problems but avoid overusing them.

✅ Interview Preparation Tips

Be prepared to explain trade-offs (e.g., ArrayList vs LinkedList, synchronized vs concurrent collections), describe lifecycle/state transitions (threads, Hibernate entities, Spring beans), and write/interpret small code snippets demonstrating core concepts. Practice explaining answers concisely and justify design choices.