Preparing for a Core Java interview? This guide contains 85+ Core Java interview questions and answers covering the concepts most commonly tested in Java interviews—from OOP, constructors, strings, collections, and exceptions to multithreading, JVM internals, and modern Java features.

Each answer focuses on what you should actually explain in an interview, with practical examples, common mistakes, and important concepts such as the Java memory model, == vs equals(), HashMap internals, synchronization, garbage collection, and virtual threads.

Core Java Basics and OOP

1. What is a class?

A class is a user-defined blueprint or template from which objects are created. It represents the set of properties (instance variables) and methods (functions) that are common to all objects of one type.

2. What is an object?

An object is an instance of a class. Objects are generally allocated on the heap, although JVM optimizations such as escape analysis can sometimes eliminate or optimize an allocation.

3. What are the four pillars of OOP?

• Encapsulation: Binding data and methods into a single unit (class) and restricting access via access modifiers.
• Abstraction: Hiding internal implementation details and showing only essential features (via abstract classes and interfaces).
• Inheritance: A mechanism where a new class acquires properties and behaviors of an existing class.
• Polymorphism: The ability of a variable, function, or object to take on multiple forms (via overloading and overriding).

4. What is encapsulation?

Encapsulation is the practice of wrapping data (variables) and code acting on the data (methods) together as a single unit. It is typically achieved by declaring class variables as private and providing public getter and setter methods to access and update them securely.

5. What is abstraction?

Abstraction is the process of hiding complex implementation details from the user and providing only a simplified interface. In Java, this is achieved using abstract classes and interfaces.

6. What is the difference between an instance variable and a reference variable?

Instance variables: State properties declared within a class (e.g., int age). Each time an object is created, it gets its own distinct copy.
Reference variables: A reference variable holds a reference to an object, allowing the program to access its fields and methods. Java does not expose raw memory addresses or pointers to application code.

7. Why is Java platform-independent?

Java is platform-independent because its compiler (`javac`) compiles source code into an intermediate format called Bytecode (`.class` files), which can be executed on any operating system equipped with a Java Virtual Machine (JVM).

8. Why is Java not fully object-oriented?

Java is not fully object-oriented because it supports eight primitive data types (int, char, boolean, float, double, byte, short, long) which are not objects.

9. Composition vs. Inheritance?

Inheritance (IS-A): A Car IS-A Vehicle (tight coupling).
Composition (HAS-A): A Car HAS-A Engine (looser coupling, greater runtime flexibility). Composition is generally favored over inheritance.

10. How does the Object-Oriented approach improve software development?

Key benefits include code reusability (via inheritance and composition), real-world domain mapping (via encapsulation), and modular architecture, leading to higher software quality and reduced development time.

11. What is the use of inheritance in programming?

Inheritance provides code reusability by allowing a subclass to acquire the properties and methods of a superclass using the extends keyword, establishing the hierarchy required for runtime polymorphism.

12. What is method overloading?

Method overloading is a form of compile-time polymorphism where multiple methods in the same class share the same name but have different parameter lists.

13. Does Java support multiple inheritance?

Java does not support multiple inheritance through classes to avoid the Diamond Problem. However, it fully supports multiple inheritance through interfaces.

For a detailed explanation of how Java handles multiple inheritance, see our multiple inheritance in Java guide.

14. Explain runtime polymorphism.

Runtime polymorphism (dynamic method dispatch) resolves calls to overridden methods at runtime based on the actual object instance referenced, rather than the reference variable’s compile-time type.

15. What is an abstract class?

An abstract class is declared with abstract and cannot be instantiated. If a class contains even one abstract method, the class must be declared abstract. Subclasses must implement all abstract methods.

16. What are the differences between an abstract class and an interface?

An interface defines a contract containing abstract, default, static, and private methods with implicit public static final fields. An abstract class can hold instance variables and constructors. A class can implement multiple interfaces but extend only one class.

Bonus: What is Recursion in Java, and what happens if you don’t define a base case?

Answer: Recursion is a programming technique where a method calls itself to solve smaller instances of the same problem. Every recursive method must have a “base case” to terminate the calls. If a base case is missing or never reached, the program will throw a StackOverflowError because the call stack runs out of memory.

For a detailed breakdown of how the call stack works during recursive calls, read our full tutorial on Recursion in Java Example Program & Execution.

Constructors and Object Initialization

17. What is a constructor and its use?

A constructor is a special block invoked automatically during object creation via new. It shares the exact class name and has no return type. Its primary purpose is initializing instance variables.

18. What is constructor overloading?

Constructor overloading means defining multiple constructors within a class with unique parameter lists, offering flexible instantiation options.

19. Can a constructor be inherited or overridden?

No. Constructors are not standard class members, so they are never inherited or overridden. Subclasses invoke parent constructors via explicit or implicit super().

20. Can we make the constructor of a class static?

No. Static context belongs to the class level, whereas constructors initialize specific object instances. A static constructor causes a compile error.

21. What is the difference between this() and super()?

this() chains to another constructor in the same class; super() invokes the parent class constructor. Both must be the absolute first statement in a constructor.

Java Keywords and Access Modifiers

22. Explain the different access specifiers in Java.

• Private: Accessible only within the same class.
• Default (Package-private): Accessible within the same package.
• Protected: Accessible within the same package and subclasses across packages.
• Public: Accessible universally.

23. What is the ‘this’ keyword in Java?

this is an implicit reference pointing to the current object context executing a method or constructor, used to resolve shadowing and pass current instance references.

24. What is the ‘super’ keyword in Java?

super provides access to members of the immediate superclass, such as overridden methods and hidden fields, and can be used to invoke the superclass constructor.

25. What is the ‘static’ keyword in Java?

The static keyword associates variables, methods, or nested classes with the class itself rather than instances, enabling class-level sharing and invocation without object instantiation.

26. What happens if the static keyword is not included in the main method signature?

Without static, the class may compile, but the Java launcher cannot use that method as the program entry point because the required main method must be static. Running the class therefore fails because a valid static main method cannot be found.

27. Can static methods be overridden?

No. Static methods are resolved at compile time, so redefining a static method in a subclass results in method hiding, not overriding.

28. Can we call a non-static function from within a static function?

Not directly. Static contexts lack a this reference. Invoking a non-static method requires an explicit object instance reference.

29. What is the final keyword in Java?

final restricts modification: final variables become constants, final methods cannot be overridden, and final classes cannot be extended.

Strings and the Object Class

30. What is the Object class?

java.lang.Object is the root of all Java classes, providing fundamental methods like equals(), hashCode(), toString(), wait(), and notify().

31. Why is String immutable in Java?

String immutability enables safe sharing, supports String Pool reuse, provides stable hash codes, and makes String instances naturally thread-safe because their state cannot change after creation.

32. What is the String Pool?

The String Pool is a special heap memory region where literal strings are cached. If a literal already exists, the JVM reuses its reference rather than allocating duplicate objects.

33. What is the difference between == and .equals()?

== compares primitive values or object reference identity; .equals() evaluates logical object equality when properly overridden.

34. What does intern() do?

Calling intern() on a heap-allocated String checks the String Pool; if present, it returns the pooled reference, otherwise it adds the string to the pool.

35. What is the difference between String, StringBuilder, and StringBuffer?

String is immutable; StringBuilder is mutable and high-performance (non-thread-safe); StringBuffer is mutable and thread-safe via synchronization.

36. What is the use of the toString() function?

toString() supplies a textual representation of an object. Developers override it to output meaningful state descriptions instead of default class hash codes.

Object Copying, Serialization, and Design Patterns

37. What is the difference between a shallow copy and a deep copy?

A shallow copy duplicates object references, meaning nested objects are shared. A deep copy recursively clones all referenced nested objects, creating fully independent copies.

38. What is a marker interface?

A marker interface has no methods or fields and is used to mark a class as having a particular property or to signal special handling by Java APIs or frameworks. Examples include Serializable and Cloneable.

39. Why do we implement the Serializable interface?

Implementing Serializable marks a class as supporting Java’s built-in object serialization mechanism, allowing its object state to be written to and reconstructed from a byte stream.

40. What is the transient keyword in Java?

transient marks fields to be excluded from Java’s default serialization mechanism (useful for security credentials or un-serializable runtime handles).

41. What is an immutable class and how do you create one?

An immutable class cannot change state post-creation. Build one by declaring the class final, making all fields private final, omitting setters, and making defensive copies of mutable components.

42. Explain the Singleton Design Pattern.

Singleton guarantees a single instance within the JVM with global access.

public class Singleton {
    private static Singleton instance;
    private Singleton() {}
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}
// Interview note: Lazy Singleton implementations require proper
// synchronization for thread safety. Common approaches include the
// initialization-on-demand holder idiom (Bill Pugh) or an enum.

Exception Handling

43. What is an exception in Java?

An exception is an event that disrupts the normal flow of program execution. Java provides try, catch, finally, throw, and throws to handle or propagate exceptions.

44. What is the difference between checked and unchecked exceptions?

Checked exceptions must be caught or declared by the compiler (e.g., IOException). Unchecked exceptions extend RuntimeException and do not require explicit catch-or-declare handling (e.g., NullPointerException).

45. final vs finally vs finalize?

final restricts assignments/inheritance; finally defines a block that normally executes after try/catch processing; finalize() is deprecated and unreliable, superseded by try-with-resources.

46. Can we have multiple catch blocks?

Yes, ordered from most specific to most general exception type.

47. Can we have a try block without a catch block?

Yes, if accompanied by a finally block or configured as try-with-resources.

48. Can a finally block be skipped?

Yes. A finally block normally executes even when an exception or return occurs. However, it may not execute if the JVM is terminated abruptly, such as through System.exit(), Runtime.halt(), or a JVM/process crash.

49. Explain the use of the throw vs throws keyword.

throw explicitly throws an exception object, while throws declares exceptions that a method may propagate to its caller.

50. How do you create a custom exception?

Extend Exception (checked) or RuntimeException (unchecked) and call super(message).

Collections and Generics

51. ArrayList vs LinkedList?

Dynamic array index lookup (fast read, shifting overhead on mid-inserts) versus doubly-linked node links (fast mutation once position is resolved, sequential reads).

52. HashSet vs TreeSet?

Hash table with average O(1) basic operations and no guaranteed ordering vs. Red-Black Tree with O(log n) operations and sorted ordering.

53. HashMap vs Hashtable?

HashMap is generally unsynchronized and permits one null key and multiple null values, while Hashtable is a legacy synchronized map that does not permit null keys or values.

54. How does HashMap work internally?

Uses hash-based buckets to store entries. When collisions cause a bucket to become sufficiently large, modern implementations can convert the bucket to a Red-Black Tree; treeification uses a threshold of 8 and requires a table capacity of at least 64, otherwise resizing may occur.

55. What is the difference between HashMap and LinkedHashMap?

LinkedHashMap maintains a doubly-linked list through entries to preserve predictable insertion iteration order.

56. Why must equals() and hashCode() be consistent?

Equal objects must return matching hash codes. Violating this contract can cause lookups, removals, and other operations in hash-based collections such as HashMap to fail unexpectedly.

57. What is ConcurrentHashMap?

ConcurrentHashMap is a thread-safe Map designed for concurrent access. Modern implementations use techniques such as CAS and fine-grained synchronization to allow multiple threads to read and update the map efficiently.

58. What is the difference between fail-fast and weakly consistent iterators?

Fail-fast iterators are designed to detect structural modifications during iteration and may throw ConcurrentModificationException. This behavior is best-effort and should not be relied upon for thread synchronization. Weakly consistent iterators, such as those used by ConcurrentHashMap, can tolerate concurrent modifications.

59. What are the advantages of using generics?

Generics provide compile-time type safety, reduce the need for explicit casts, and help catch type errors earlier rather than at runtime.

60. How does the Comparator interface differ from Comparable?

Comparable is implemented by the class whose objects are being compared to define their natural ordering through compareTo(). Comparator is a separate comparison strategy that can define one or more alternative orderings through compare() without modifying the original class.

Multithreading and Concurrency

61. Thread vs Process?

Threads within the same process share memory such as the heap, which can make communication between threads less expensive than inter-process communication. Thread and process context-switch costs depend on the operating system and workload.

62. What is the thread lifecycle?

States include NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, and TERMINATED.

63. How do you create multiple threads?

Implement Runnable (preferred) or extend Thread.

For a more detailed explanation with examples, see our how to create threads in Java .

64. What is the difference between sleep() and wait()?

sleep() pauses execution and retains locks; wait() releases object monitor locks for inter-thread coordination.

65. What is synchronization?

Controls concurrent access to shared blocks. Instance methods lock this, static methods lock the Class object, and blocks target arbitrary monitors.

66. What is the purpose of the volatile keyword?

The volatile keyword guarantees visibility of writes between threads and establishes happens-before relationships for volatile accesses. It does not provide mutual exclusion or make compound operations such as count++ atomic.

67. Can you explain the difference between Callable and Runnable?

Runnable represents a task that returns no result and cannot declare checked exceptions from run(). Callable can return a result and can throw checked exceptions. When submitted to an ExecutorService, a Callable produces a Future representing its pending result.

68. What is ExecutorService?

ExecutorService is a high-level concurrency API for managing and executing tasks using thread pools. It handles task submission, scheduling, lifecycle management, and controlled shutdown of worker threads.

ExecutorService executor = Executors.newFixedThreadPool(5);
executor.submit(() -> doWork());
executor.shutdown();

69. Platform Threads vs Virtual Threads (Java 21+)?

Platform threads are backed by OS threads and generally have higher per-thread resource costs than virtual threads. Virtual threads are lightweight threads scheduled by the JVM onto carrier platform threads. During supported blocking operations, a virtual thread can unmount from its carrier, allowing the carrier thread to run other work.

70. What is the difference between deadlock and livelock?

A deadlock happens when two or more threads are permanently blocked, each waiting for a lock held by the other. A livelock happens when threads are not blocked but are constantly changing states in response to each other, making no actual progress.

JVM, Memory, and Java Runtime

71. JDK vs JRE vs JVM?

The JVM executes Java bytecode. Traditionally, the JRE consisted of the JVM plus the Java runtime libraries, while the JDK included the runtime plus development tools such as javac. Modern Java distributions are generally delivered as JDKs rather than as separate JRE installations.

72. What is a ClassLoader?

A ClassLoader is a JVM subsystem responsible for loading classes into the runtime when they are needed. Modern Java uses the Bootstrap, Platform, and Application class loaders in the standard hierarchy.

73. What is bytecode?

Bytecode is the platform-independent intermediate code generated by the Java compiler (javac) and stored in .class files. The JVM loads and executes this bytecode, either through interpretation or JIT compilation.

74. Stack vs Heap memory?

Thread-private stacks store execution frames and local variables; shared heaps store objects and arrays.

75. What is garbage collection and what makes an object eligible?

Automatic memory reclamation targeting objects unreachable from active GC Roots. An object becomes eligible for garbage collection when it is no longer reachable through a chain of references from any GC Root, such as live threads, static references, or JNI references.

76. What is a memory leak in Java?

Unintentional retention of object references preventing Garbage Collection from reclaiming heap space.

77. What is a JIT Compiler?

Just-In-Time compiler translates hot bytecode sections into direct native machine instructions at runtime.

78. OutOfMemoryError vs StackOverflowError?

OutOfMemoryError occurs when the JVM cannot allocate memory for a required operation, while StackOverflowError occurs when a thread’s stack cannot accommodate additional stack frames, often because of deeply nested or recursive calls.

Java 8+ and Modern Java

79. What are Lambda expressions?

Concise inline expressions implementing single-method functional interfaces.

List<Integer> numbers = List.of(1, 2, 3);
numbers.forEach(n -> System.out.println(n));

80. What is a Functional Interface in Java?

An interface containing exactly one abstract method, targeted by lambdas.

81. What are default methods in interfaces?

Interface methods with bodies allowing backward-compatible library evolution.

82. What are method references?

Shorthand syntax (Class::method) substituting standard lambda blocks.

83. Stream API: map() vs filter()?

map(): Used to transform data. It applies a function to every element and returns a stream of the transformed results.
filter(): Used to select data. It applies a boolean condition (Predicate) to every element and returns a stream containing only matching elements.

List<Integer> numbers = List.of(1, 2, 3);
List<Integer> result = numbers.stream().filter(n -> n > 1).map(n -> n * 10).toList();

84. What is the Optional class?

Optional is a container that may or may not contain a value. It makes absence explicit and is particularly useful for representing optional return values; it does not eliminate NullPointerException or replace null handling everywhere.

85. What is a record in Java?

Records were introduced as a preview feature in Java 14 and finalized in Java 16. A record is a concise way to model shallowly immutable data carriers. The compiler automatically generates the constructor, component accessor methods (like name() and age()), equals(), hashCode(), and toString() based on the fields you define, eliminating boilerplate code.

Most Important Java Comparisons

Quickly review distinctions between heavily tested concepts in Java technical interviews:

10 Core Java Interview Traps

Watch out for these classic pitfalls that can expose gaps in Core Java understanding:

Final 5-Minute Interview Checklist

Need structured Core Java training? If you want to strengthen your Core Java fundamentals through live, one-on-one instruction, see our Online Core Java Training program.

Frequently Asked Questions (FAQ)

Need help preparing for an upcoming technical interview? Connect with an online Java tutor for mock interviews, 1-on-1 training, and customized technical coaching.