Tell me about yourself

Start with your current role and most relevant experience, then connect that to the job you want. Focus on the past five to ten years and highlight two to three achievements that show your skills and impact. Try a structure: "I'm a Java developer at [company], where I built X that improved Y by Z. Before that, I worked on A and B which gave me experience with C." Practice keeping this under two minutes and adapt the details to the role. Avoid reciting your resume line by line or going into unrelated personal history. End by stating why this role fits your next step so the interviewer sees the connection.

What are the four main principles of object oriented programming in Java?

Explain each principle briefly: encapsulation, abstraction, inheritance, and polymorphism, and give a line about how each helps structure code. Keep the definitions simple and tied to practical benefits like code reuse and maintainability. Give a short example: encapsulation is grouping fields and methods into a class and using private access with getters and setters; polymorphism lets you treat different implementations through a common interface. Mention a real case, such as using interfaces for multiple payment providers to simplify switching implementations. Avoid long theoretical lectures, and do not use dense jargon. If asked for deeper detail, ask whether they want design examples, runtime behavior, or code samples.

Explain the difference between == and equals() in Java

State that == compares object references while equals() compares logical equality as defined by the class. Note that for primitives == compares values, and for objects you should override equals when logical equality differs from reference equality. Give a concrete example: two String objects created with new will have different references so == is false, but equals() is true because String overrides equals to compare characters. If you implement a POJO, override equals and hashCode together to ensure correct behavior in collections. Warn against using == for strings and boxed primitives in business logic, and recommend code reviews to catch accidental reference comparisons. If performance is a concern, profile before optimizing equality checks.

How does Java memory model and garbage collection work at a high level?

Describe heap and stack briefly, noting that objects live on the heap and references are on the stack or in static fields. Explain that the garbage collector reclaims objects that are no longer reachable from live references and that there are different collectors with trade offs. Give a practical example: short-lived objects often end up in the young generation and are collected cheaply, while long-lived objects survive to the old generation. Mention a common troubleshooting step: use a heap dump and a profiler to find memory leaks caused by unintended strong references, such as caches never cleared. Avoid deep JVM internals unless asked, and offer to show sample GC logs or configuration for the app you worked on. When discussing tuning, emphasize measuring before and after changes rather than guessing.

What is the difference between Thread and Runnable in Java?

Explain that Runnable is a functional interface with a single run method that contains the task logic, while Thread is a class that represents an executing thread and can take a Runnable to run. Recommend preferring Runnable or Callable with executors to separate task logic from thread management. Provide a simple example: implement Runnable to define work and submit it to an ExecutorService, which handles pooling and lifecycle. Contrast that with creating new Thread for each task, which can lead to many threads and resource issues in production. Advise using higher level concurrency utilities from java.util.concurrent for production systems, and test concurrency paths to catch race conditions. Mention common gotchas like not handling InterruptedException properly and sharing mutable state without synchronization.

How would you design and build a REST API in Java?

Outline the typical stack: use Spring Boot to define controllers for endpoints, services for business logic, and repositories for data access. Emphasize clear URL design, proper HTTP verbs, status codes, and simple DTOs for input and output. Give a short example: a POST to /orders creates an order DTO validated with annotations, the service handles transaction boundaries, and the controller returns 201 with a Location header. Add examples of cross-cutting concerns: use exception handlers for consistent error responses and add metrics and logging for observability. Mention common security practices such as input validation, authentication with JWT or OAuth, and avoiding exposing internal entity structures. Recommend documenting the API with OpenAPI to help front end and client teams.

What are Java Streams and when should you use them?

Describe Streams as a way to process collections through a pipeline of operations like map, filter, and collect, with lazy evaluation for intermediate operations. Explain that streams can make code more expressive and concise, especially for transformations and aggregations. Show a simple use case: filter a list of orders, map to totals, and collect to a list or sum using stream().filter(...).map(...).collect(...). Caution that streams may introduce overhead for trivial operations and that parallel streams should be measured for performance benefits. Point out pitfalls like accidentally using stateful lambda expressions or relying on side effects inside stream operations. Recommend writing unit tests for complex stream pipelines and preferring readable code over clever one-liners.

How do checked and unchecked exceptions differ, and when do you use each?

Explain that checked exceptions must be declared or handled at compile time, while unchecked exceptions inherit from RuntimeException and do not require declaration. Advise using checked exceptions for recoverable conditions the caller can handle and unchecked for programming errors that should bubble up. Provide an example: use checked exceptions for recoverable IO issues where the caller can retry or fallback, and use IllegalArgumentException for invalid method arguments that indicate a caller bug. Also suggest wrapping low level exceptions in application-specific exceptions to provide clearer context. Warn against overusing checked exceptions which can clutter method signatures, and avoid swallowing exceptions without logging or context. When designing an API, document which exceptions callers should expect and how to handle them.

Which design patterns are common in Java backend development and why?

Mention patterns like Singleton for shared resources, Factory for creating objects without exposing construction, Strategy for interchangeable algorithms, and Repository for data access abstraction. Explain that these patterns help with testability, separation of concerns, and code reuse when applied appropriately. Give a concrete scenario: use Strategy to swap sorting or validation logic without changing callers, and use Repository to centralize queries so unit tests can mock data access. Stress that frameworks like Spring provide many patterns out of the box, such as dependency injection which reduces the need for manual singletons. Avoid applying patterns blindly; prefer simple, clear code and refactor to a pattern when the problem clearly benefits. Include unit tests to ensure the chosen pattern does not add unnecessary complexity.

How do you diagnose and resolve a memory leak in a Java application?

Start by reproducing the issue and collecting metrics such as heap usage over time and GC logs to identify growth patterns. Capture a heap dump when memory is high and analyze retained sizes with tools like VisualVM or Eclipse MAT to find suspect objects holding references. Explain a typical fix: if a cache or static collection grows unbounded, implement eviction or use weak references depending on your needs, and correct long-lived references from thread locals or listeners. Run load tests to validate the fix and monitor memory trends to ensure the leak is resolved. Advise documenting the root cause and mitigation so the team learns from the incident. Emphasize adding automated checks or alerts for memory growth to catch regressions early.

Tell me about a time you missed a deadline. What happened and how did you respond?

Situation: On a previous project an integration slipped due to an underestimated dependency and a late API change from a partner. Task: As the feature owner you had to get the project back on track and communicate impact to stakeholders. Action: You called an immediate meeting to reprioritize tasks, negotiated a minimal viable scope to deliver critical functionality, and set up daily progress check ins to remove blockers. You also added a short buffer and more rigorous acceptance criteria for remaining tasks. Result: The revised release delivered core functionality two weeks later with reduced scope, stakeholders accepted the compromise, and you reduced similar risks in future sprints by adding dependency checks and clearer integration tests. This led to fewer last minute surprises in subsequent releases.

Describe a time you improved a team process.

Situation: The team had frequent merge conflicts and slow code reviews that delayed deliveries. Task: As a senior developer you needed to reduce friction while preserving code quality and learning opportunities. Action: You proposed and piloted shorter, focused PRs, introduced a checklist for reviewers, and scheduled two fixed review hours per day to ensure timely feedback. You also held a short training session on writing smaller, testable changes and using feature flags for incremental rollout. Result: Merge conflicts dropped and average PR review time decreased by half, which improved throughput and lowered context switching. The team adopted the practices permanently and reported less frustration during planning and deployments.

Give an example of a difficult bug you fixed and how you approached it.

Situation: In production a nightly job started failing intermittently after a platform upgrade, causing delayed reports for customers. Task: You were responsible for diagnosing the root cause and restoring reliable runs. Action: You gathered logs and correlating metrics, ran the job locally under the same environment variables, and created a minimal reproduction that revealed a race condition triggered by changed timing. You added targeted logging, wrote a failing unit test, and applied a fix that synchronized access to a shared resource and added retries for transient failures. Result: The nightly job ran reliably after the fix and the additional tests prevented regressions during future upgrades. You documented the issue and the fix path in the team wiki so others could recognize similar problems quickly.

How does Java garbage collection work and what are common collectors you might choose?

Explain that the garbage collector reclaims memory by finding objects no longer reachable from live references, and the JVM has multiple collectors optimized for different workloads. Common collectors include G1 for balanced throughput and pause time, CMS for low pauses in older JVMs, and ZGC or Shenandoah for very low pause goals on large heaps. Give a practical tip: choose G1 for general server applications and consider ZGC for very large heaps when low pause is required, but always measure using production-like loads. Use GC logs and tools like jstat or GarbageCollectorMXBean to analyze pause times and throughput. Common pitfalls include tuning without data and changing collectors without load testing. Before changing collector settings, capture baseline metrics and run stress tests to validate improvements.

When would you use synchronized, volatile, or concurrent collections in Java?

Describe synchronized as a simple way to protect a critical section with a monitor, volatile for visibility of a single variable across threads, and concurrent collections like ConcurrentHashMap for higher concurrency without coarse locking. Explain that each has trade offs between simplicity, correctness, and scalability. Provide an example: use volatile for a stop flag checked by multiple threads, synchronized for a small block that must be atomic, and ConcurrentHashMap when many threads read and write a shared map. If you need atomic compound operations, consider using ConcurrentHashMap methods or Atomic* classes rather than manual locking. Warn against mixing strategies without understanding memory visibility, and recommend writing unit and stress tests for concurrency. If performance matters, profile under realistic contention to choose the right approach.

Show a Java Streams example to filter, transform, and collect results

Explain the pipeline approach: source, intermediate operations, and terminal operation. Then show a concise example that is easy to adapt. Example code: List emails = users.stream() .filter(u -> u.isActive()) .map(u -> u.getEmail().toLowerCase()) .distinct() .collect(Collectors.toList()); This filters active users, maps to lowercased emails, removes duplicates, and collects to a list. The pipeline is lazy until the terminal collect runs, which can help with performance for large datasets. Common gotchas include using stateful lambdas, unexpected side effects inside map or filter, and assuming parallel streams always improve speed. Test and measure, and prefer simple loops when clarity or performance is better.

How do you handle database connections and prevent SQL injection in Java?

Recommend using connection pools like HikariCP and always using prepared statements or parameterized queries to avoid SQL injection. Explain that ORMs like JPA/Hibernate can help, but you must still avoid concatenating untrusted input into queries. Provide a code snapshot for prepared statements: String sql = "SELECT id, name FROM users WHERE email = ?"; try (PreparedStatement ps = conn.prepareStatement(sql)) { ps.setString(1, email); try (ResultSet rs = ps.executeQuery()) { // process result } } Also suggest using query parameter binding in JPA or named parameters in Spring to keep queries safe and readable. Monitor and tune the connection pool to avoid leaks by ensuring connections are closed in finally blocks or try-with-resources.

How do you manage transactions in Spring and what are common pitfalls?

Explain that Spring handles transactions declaratively with @Transactional or programmatically via TransactionTemplate, and that the annotation defines transactional boundaries. Note that by default @Transactional rolls back on runtime exceptions and not checked exceptions, so configure rollbackFor when needed. Give an example: annotate a service method with @Transactional to group multiple repository calls into one transaction, making sure the method is public and called from a different bean or proxy for the annotation to apply. Also watch for lazy loaded entities outside the transaction which can cause LazyInitializationException. Common pitfalls include using @Transactional on private methods, catching exceptions inside the transaction and preventing rollback, and running long transactions that hold locks for too long. Keep transactions short and push non transactional work like IO to separate methods.

java developer Interview Questions: Complete Guide

This guide covers common java developer interview questions and what to expect in technical and behavioral rounds. You will see typical formats: live coding, system design, and behavioral interviews, along with practical ways to answer and examples you can adapt. Stay calm, practice aloud, and focus on clear explanations rather than memorized scripts.

Common Interview Questions

Behavioral Questions (STAR Method)

STAR Method: Structure your answers using Situation, Task, Action, and Result to tell compelling stories about your experience.

Technical Questions

Questions to Ask the Interviewer

Show your interest by asking thoughtful questions

•What does success look like in this role after six months, and what are the first priorities?
•Can you describe the current architecture and the biggest technical debt or bottlenecks the team is addressing?
•How does the team measure code quality and what testing practices are expected for new features?
•What is the deployment process and how often do you release to production?
•How does the team handle on call responsibilities and incident postmortems?

Interview Preparation Tips

1
Practice whiteboard or live coding problems aloud and explain your thought process while coding so interviewers can follow your reasoning.
2
Write small, testable code samples for common topics like thread safety, streams, and data access before the interview to build muscle memory.
3
When stuck, describe your assumptions, outline possible approaches, and ask clarifying questions to show structured problem solving.
4
Bring concrete examples from your work that show impact, and quantify results when possible to make your contributions clear.

java developer Interview Questions: Complete Guide

Emily Thompson

Common Interview Questions

Behavioral Questions (STAR Method)

Technical Questions

Questions to Ask the Interviewer

Interview Preparation Tips

Related guides

java Interview Questions: Complete Guide

.net developer Interview Questions: Complete Guide

android developer Interview Questions: Complete Guide

angular developer Interview Questions: Complete Guide

java developer Interview Questions: Complete Guide

Emily Thompson

Common Interview Questions

Q1Tell me about yourself

Q2What are the four main principles of object oriented programming in Java?

Q3Explain the difference between == and equals() in Java

Q4How does Java memory model and garbage collection work at a high level?

Q5What is the difference between Thread and Runnable in Java?

Q6How would you design and build a REST API in Java?

Q7What are Java Streams and when should you use them?

Q8How do checked and unchecked exceptions differ, and when do you use each?

Q9Which design patterns are common in Java backend development and why?

Q10How do you diagnose and resolve a memory leak in a Java application?

Behavioral Questions (STAR Method)

B1Tell me about a time you missed a deadline. What happened and how did you respond?

B2Describe a time you improved a team process.

B3Give an example of a difficult bug you fixed and how you approached it.

Technical Questions

T1How does Java garbage collection work and what are common collectors you might choose?

T2When would you use synchronized, volatile, or concurrent collections in Java?

T3Show a Java Streams example to filter, transform, and collect results

T4How do you handle database connections and prevent SQL injection in Java?

T5How do you manage transactions in Spring and what are common pitfalls?

Questions to Ask the Interviewer

Interview Preparation Tips

Related guides

java Interview Questions: Complete Guide

.net developer Interview Questions: Complete Guide

android developer Interview Questions: Complete Guide

angular developer Interview Questions: Complete Guide