Top 30 Java Interview Questions Every Backend Engineer Should Master

1. What are the three features of object‑oriented languages? Encapsulation, inheritance, and polymorphism.

2. Difference between class and object; meaning of overriding and overloading in Java; methods in Object class; difference between == and equals?

3. Difference between abstract class and interface; what is interface‑driven programming and its benefits?

4. Common Java collection classes, HashMap implementation principle, differences between ConcurrentHashMap and HashMap, how to sort an ArrayList, whether List, Set, Map all inherit from Collection, requirements for objects used as keys in HashMap, and conditions a Java object must satisfy to be a Map key.

5. Java exception handling mechanism, types of exceptions, and ten or more common exceptions encountered in code.

6. Describe Java I/O system and how byte streams are converted.

7. Basic concepts of threads, thread states and their relationships, thread synchronization and how to achieve it.

8. Difference between synchronized and lock.

9. Ways to implement multithreading, familiarity with java.util.concurrent classes, understanding of thread safety, implementation of ReentrantLock and its internal Sync mechanism.

10. Semantics of wait/notify, how to achieve thread collaboration, and usage of CountDownLatch, CyclicBarrier, BlockingQueue.

11. Why AtomicInteger and AtomicBoolean provide high‑performance concurrency; underlying reason (CAS lock‑free algorithm).

12. What is ThreadLocal, its principle, and scenarios where it can be used? ThreadLocal provides a thread‑local variable, giving each thread its own independent copy to avoid concurrency conflicts.

13. Roles of Atomic, Future, Callable, and Executor.

14. Difference between visibility and sequential consistency in concurrent programming and how to guarantee them.

15. Java memory model, differences between heap and stack, garbage collection mechanisms and algorithms.

16. New features of Java 8, their purposes, impact on programming, and practical usage scenarios.

Lambda expressions

Stream API

Optional to reduce NullPointerException

Functional interfaces

Enhanced annotations

Underlying implementation of collections

New date‑time API

17. Design patterns: examples from JDK or other frameworks, personal experience with patterns.

UML modeling (composition, aggregation, association, dependency)

Six solid principles and 23 design patterns

18. Typical design pattern intents and applicable scenarios, e.g., Singleton, Decorator, with an example.

19. Performance optimization methods across database, code, front‑end, cache, distributed computing, and familiarity with profiling tools.

20. How to run a simple Java "Hello World" program and the steps involved.

21. Meaning of JVM startup parameters -verbose, -Xms, -Xmx.

-verbose[:class|gc|jni] enables verbose output.

-verbose:gc shows garbage‑collection information.

-Xms sets the initial heap size.

-Xmx sets the maximum heap size; when the heap is full, GC is triggered to free memory.

22. Understanding of garbage collection and how to add GC functionality to a C program.

23. Java class loading order, parent‑delegate mechanism, reasons for using it, and ways to break the delegation.

24. Types of OutOfMemoryError, causes, and solutions.

25. Knowledge of Servlets, their operation, lifecycle, thread safety, purpose of listeners and filters.

26. How to write a servlet accessible via a browser, its thread‑safety, and role in MVC.

27. Difference between forward() and redirect() in the Servlet API.

28. Difference between cookie and session.

29. Understanding of the Spring framework, its core concepts, and bean lifecycle management.

30. Principles and purposes of AOP and IoC; how Spring implements transactions.

31. What is MVC, how Spring MVC works, core classes, and the request processing flow.

32. What is Spring Boot?

Simplifies Spring setup and development via configuration files (properties or YAML).

Creates a standalone Spring application with a main method.

Embeds Tomcat, allowing jar execution without a separate WAR deployment.

Reduces Maven configuration complexity.

Provides automatic configuration through starters.

33. Common Spring Boot starters.

spring-boot-starter-web (embedded Tomcat, servlet/JSP support)

spring-boot-starter-data-jpa (database support)

spring-boot-starter-data-redis (Redis support)

spring-boot-starter-data-solr (Solr search support)

mybatis-spring-boot-starter (MyBatis integration)

34. How Spring Boot auto‑configuration works.

@EnableAutoConfiguration guesses configuration based on added starters.

Reads spring.factories in each starter to create required beans.

Uses @Conditional annotations to apply configurations conditionally.

35. How Spring Boot starter mechanism operates.

Scans classpath for JARs containing spring.factories.

Loads AutoConfigure classes defined therein.

Injects beans into the Spring context based on conditions.

36. Advantages of Spring Boot.

Reduces development and testing time.

Encourages JavaConfig over XML.

Avoids Maven version conflicts.

Provides opinionated defaults.

Offers sensible defaults for rapid start.

No separate web server needed; embedded Tomcat runs directly.

Less configuration, no web.xml required.