Java Interview Questions and Answers for Freshers

Java basics questions

Strong fundamentals separate average candidates from confident ones. Most java basic interview questions revolve around clarity in these core areas.

What is Java? Features and advantages

• Java is a high-level, object-oriented, platform-independent programming language developed by Sun Microsystems and now owned by Oracle.
• It is widely used in enterprise applications, Android development, backend systems, and financial platforms.
• Key features include platform independence, object-oriented architecture, robust memory management, multithreading support, and a strong security model.
• Its biggest advantage is portability. Java applications can run on different systems without rewriting code.

JVM vs JRE vs JDK

This is one of the most common Java basic questions.

• JVM (Java Virtual Machine) executes Java bytecode.
• JRE (Java Runtime Environment) provides the libraries and JVM needed to run applications.
• JDK (Java Development Kit) includes the JRE plus development tools such as the compiler.

If you are writing Java code, you need JDK. If you are only running it, the JRE is enough.

What are primitive data types in Java?

• Java has eight primitive data types: byte, short, int, long, float, double, char, and boolean.
• They store simple values directly in memory and are not objects.

Explain “Write Once, Run Anywhere”

• Java source code is compiled into bytecode.
• Bytecode runs on the JVM, which exists for different operating systems.
• This makes Java platform-independent.

Difference between == and .equals()

• == compares memory references.
• .equals() compares actual object content.
• For objects like String, always use .equals() to compare values.

What is the main method in Java?

The main method is the entry point of a Java program:

public static void main(String[] args)

It allows the JVM to start program execution.

OOP concepts questions

Object-Oriented Programming forms the backbone of many core Java interview questions for freshers. Understanding these concepts deeply is essential.

What are the four pillars of OOP?

• The four pillars are Encapsulation, Abstraction, Inheritance, and Polymorphism.
• These principles improve code reusability, scalability, and maintainability.

Class vs Object

• A class is a blueprint that defines properties and behaviours.
• An object is an instance of that class created in memory.
• For example, “Car” is a class, while your specific car is an object.

Inheritance vs Composition

• Inheritance represents an “is-a” relationship. For example, Dog is an Animal.
• Composition represents a “has-a” relationship. For example, Car has an Engine.
• Composition is often preferred because it provides better flexibility and loose coupling.

Method Overloading vs Method Overriding

• Method overloading occurs within the same class. Methods share the same name but have different parameters.
• Method overriding happens in a subclass. The child class provides a new implementation of a parent class method.

Interface vs Abstract Class

• An interface defines a contract that classes must implement and supports multiple inheritance.
• An abstract class can contain both abstract and concrete methods and supports single inheritance.

Encapsulation, Polymorphism, and Abstraction explained

• Encapsulation protects data by restricting direct access and exposing it through methods.
• Abstraction hides implementation details and shows only essential functionality.
• Polymorphism allows the same method to behave differently depending on the object that calls it.

The next step is understanding how Java actually behaves in real programs — memory, access control, strings, exceptions, and collections. This is where interviews start testing applied knowledge rather than definitions.

Core Java questions

These topics form the backbone of most core java interview questions for freshers. Clear understanding here shows maturity as a developer.

Access modifiers: public, private, protected, default

Access modifiers control the visibility of classes, methods, and variables.

• public – Accessible from anywhere
• private – Accessible only within the same class
• protected – Accessible within the same package and subclasses
• default (no modifier) – Accessible only within the same package

Interviewers often ask this to test encapsulation knowledge.

What is a constructor?

• A constructor is a special method used to initialise objects.
• It has the same name as the class and does not have a return type.
• Constructors can be default or parameterised.

Static keyword, final keyword, and this keyword

• The static keyword makes a member belong to the class rather than an instance.
• The final keyword prevents modification. A final variable cannot be reassigned, a final method cannot be overridden, and a final class cannot be inherited.
• The this keyword refers to the current object and helps differentiate instance variables from parameters.

String vs StringBuilder vs StringBuffer

• String is immutable. Once created, it cannot be changed.
• StringBuilder is mutable and not thread-safe. It is faster in single-threaded environments.
• StringBuffer is mutable and thread-safe, but slightly slower due to synchronisation.

Exception handling: checked vs unchecked exceptions

• Checked exceptions are verified at compile time, such as IOException.
• Unchecked exceptions occur at runtime, such as NullPointerException.
• Java uses try, catch, finally, throw, and throws for exception handling.

Garbage Collection in Java

• Garbage Collection automatically removes unused objects from memory.
• The JVM identifies objects with no references and frees memory.
• Developers cannot directly control it, but they can suggest it using System.gc().

Packages and imports

• Packages group related classes and help avoid naming conflicts.
• The import statement allows access to classes from other packages.
• Organised packaging improves maintainability and readability.

Now, let us move to one of the most practical and frequently asked areas in interviews — the Collections Framework.

Collections framework questions

Collections are heavily tested in both theoretical and Java coding interview questions.

List vs Set vs Map

• List allows ordered elements and duplicates.
• Set does not allow duplicates.
• Map stores key-value pairs and does not allow duplicate keys.

ArrayList vs LinkedList

• ArrayList uses a dynamic array and provides fast random access.
• LinkedList uses a doubly linked list and is efficient for insertions and deletions.

HashMap vs Hashtable

• HashMap is not thread-safe and allows one null key.
• Hashtable is thread-safe but does not allow null keys or values.
• In modern applications, HashMap is more commonly used.

HashSet vs TreeSet

• HashSet stores unique elements without maintaining order.
• TreeSet stores unique elements in sorted order using a tree structure.

Comparator vs Comparable

• Comparable defines natural ordering within the class using compareTo().
• Comparator defines custom ordering externally using compare().

When to use which collection?

• Use ArrayList when fast retrieval is required.
• Use LinkedList when frequent insertions and deletions occur.
• Use HashMap for fast key-based lookups.
• Use TreeSet when sorted unique data is needed.

Strong command over collections often differentiates average candidates from confident ones in Java interviews.

Multithreading questions

Multithreading is common in server-side and enterprise applications. Even freshers are expected to understand the fundamentals.

What is a thread?

• A thread is a lightweight unit of execution within a process.
• Multiple threads can run concurrently, allowing better CPU utilisation and improved performance.
• In Java, multithreading helps build responsive and high-performing applications.

Creating threads: Runnable vs Thread class

There are two main ways to create threads:

• Extending the Thread class
• Implementing the Runnable interface

Implementing Runnable is generally preferred because Java supports single inheritance. It also promotes better design and separation of concerns.

Thread lifecycle

A thread goes through several states:

• New → Runnable → Running → Blocked/Waiting → Terminated

Understanding these states helps in debugging concurrency issues.

Synchronisation in Java

• When multiple threads access shared resources, data inconsistency can occur.
• Synchronisation ensures that only one thread accesses critical sections at a time.
• The synchronised keyword is commonly used for this purpose.

Executor framework basics

• The Executor framework, introduced in Java 5, simplifies thread management. Instead of manually creating threads, you use thread pools such as ExecutorService.
• It improves scalability and resource management.

Deadlock and how to prevent it

• Deadlock occurs when two or more threads wait indefinitely for each other’s locks.
• Prevention strategies include maintaining a consistent lock order and avoiding nested locks.
• Interviewers often ask this to test your understanding of concurrency risks.

Once you understand how Java handles concurrency, the next logical step is mastering modern Java features. Recruiters today expect familiarity not just with basic syntax, but also with Java 8 and beyond.

Java 8 / 9 / latest features questions

Modern Java versions introduced powerful features that simplify coding and improve readability.

Lambda expressions in Java 8

• Lambda expressions allow you to write concise functional-style code.
• Example: (x) -> x * 2
• They are widely used with collections and streams.

Streams API: map, filter, reduce

The Streams API enables functional data processing.

• map() transforms elements
• filter() applies conditions
• reduce() combines elements into a single result

Streams make code cleaner and more expressive.

Optional class usage

• The Optional class helps avoid NullPointerException. It forces developers to explicitly handle possible null values.

Functional interfaces

• A functional interface has exactly one abstract method. Examples include Runnable and Comparator. They are essential for lambda expressions.

New features in Java 9+ (modules, var keyword, etc.)

• Java 9 introduced the module system to better structure applications.
• The var keyword (Java 10) allows local variable type inference.
• JShell was also introduced for interactive experimentation.

Records and Sealed classes (latest versions)

• Records provide a concise way to create immutable data classes.
• Sealed classes restrict which classes can extend or implement them.
• These features improve readability and code safety.

At this stage, you have covered fundamentals, OOP, core concepts, collections, concurrency, and modern Java. Now it is time to apply everything through coding and scenario-based questions — the part that truly differentiates candidates in interviews.

Coding / scenario-based questions

These are common Java coding interview questions asked in technical rounds. Most of them test logic, not complexity.

Reverse a String

• One of the simplest but most frequently asked problems.
• Using StringBuilder: String reversed = new StringBuilder(str).reverse().toString();
• Alternatively, you can reverse manually using a loop to demonstrate a deeper understanding.

Check if a String is a palindrome

• A palindrome reads the same forward and backwards.
• Approach: Reverse the string and compare it with the original using .equals().
• Or compare characters from both ends moving inward.

Find the largest element in an array

• Initialise a variable with the first element.
• Iterate through the array and update the variable if a larger value is found.
• This tests your understanding of loops and conditions.

Fibonacci series implementation

• Fibonacci series: 0, 1, 1, 2, 3, 5, 8...
• Using a loop is preferred in interviews because recursion may cause stack overflow for large inputs.
• The logic involves tracking the previous two numbers and summing them.

Count vowels in a string

• Convert the string to lowercase.
• Iterate through each character and increment a counter when encountering a, e, i, o, or u.
• This tests string handling and condition logic.

Java program to remove duplicates from an array

• Use a HashSet to remove duplicates easily. Alternatively, use nested loops to show algorithmic thinking without collections.
• Interviewers often appreciate it when you explain time complexity.

Scenario-based: Design a small class hierarchy for a bank system

• Base class: Account
• Attributes: accountNumber, balance
• Common methods: deposit(), withdraw(), getBalance()
• Subclasses: SavingsAccount (includes interest calculation) and CurrentAccount (includes overdraft limit)

This demonstrates inheritance, abstraction, and polymorphism together. If you are still exploring the complete roadmap beyond interviews, read our detailed guide on how to become a java developer to understand the skills, projects, and career path required in 2026.

Tips to crack Java interviews

• Clarity beats complexity in interviews. Recruiters prefer candidates who can explain concepts simply and confidently rather than those who use complicated terminology without real understanding.
• Revise fundamentals regularly, especially Java basic questions and OOP concepts, because most interviews begin with these areas. A strong foundation makes advanced questions easier to handle.
• Practice explaining answers aloud, as interviewers evaluate communication skills along with technical accuracy. Clear thinking and structured responses leave a strong impression.
• Solve problems consistently to build confidence, and focus on understanding concepts instead of memorising answers.
• Before applying, make sure your profile reflects your skills clearly. A well-structured Java Developer resume can significantly improve your chances of getting shortlisted.

How to prepare for Java interviews

• Begin with a structured revision of core Java interview questions to strengthen basics like collections, exceptions, and multithreading.
• Practice at least 40–50 frequently asked Java coding interview questions to improve speed and logical thinking. Writing code regularly helps you stay comfortable during technical rounds.
• Review Java 8 features such as streams and lambda expressions, and build small projects to demonstrate practical understanding.
• Consistency over time matters far more than last-minute preparation.

Common mistakes to avoid

• Avoid memorising answers without understanding the logic behind them, as interviewers quickly identify superficial knowledge.
• Do not ignore edge cases in coding problems, and always explain your thought process clearly as you solve them.
• Resist the urge to overcomplicate simple questions, and make sure your knowledge includes modern Java features like streams and Optional to stay current.

Frequently Asked Questions