Best Java interview questions for 1 year experience and freshers

Java is a high-level, object-oriented programming language where the whole concept runs on top of a virtual machine called the JVM. Instead of directly compiling to machine code like C/C++, Java compiles to bytecode, and this bytecode runs inside the JVM. Because of this extra layer, the same Java program can run on any OS as long as that OS has a JVM installed. That is what write once, run anywhere means — the code stays same but the JVM implementation changes internally for each OS.

Java handles memory on its own using something called Garbage Collection. This means you don’t manually free memory (like in C). JVM continuously tracks objects in memory; once an object has no references pointing to it, GC clears it out, preventing memory leaks.

Java is widely used in enterprise systems because it focuses on stability, long-term maintainability, and strong type safety. Java gives predictable performance because everything is strict: types, memory allocation, exceptions, multi-threading model etc.

The JVM is the actual engine that executes Java bytecode. It loads .class files, verifies them, interprets them, and sometimes compiles frequently used parts into native machine code using JIT (Just-In-Time compiler). JVM is the core reason Java is platform independent.

JRE is basically JVM + the set of core Java libraries (like java.lang, java.util, etc.) required to run Java applications. If you only want to run Java programs, you need JRE.

JDK is the complete development package. It contains the compiler (javac) which converts your .java file into .class bytecode. It also contains debugging tools, documentation tools, and everything required to build Java applications.

Summary:

JDK = tools to build + JRE

JRE = JVM + libraries

JVM = executes bytecode

Java follows OOP because it wants everything grouped into objects so that the structure is more manageable as systems grow. The main concepts are:

Encapsulation: You wrap data (variables) and operations (methods) inside a class. Access modifiers restrict how outside code interacts with this class.

Inheritance: A class can reuse code from another class. Child class extends parent class and automatically gets its fields and methods.

Polymorphism: Same method name behaves differently based on context.

1. Compile-time polymorphism (overloading) → based on different parameter types/counts.
2. Runtime polymorphism (overriding) → JVM decides which version to call based on actual object in memory.

Abstraction: Hide complex details and expose only the main structure. Abstract classes and interfaces define “what to do” but hide “how it’s done.”

A class is a template. It defines what variables and methods the objects created from it will have. A class does not occupy memory for instance variables.

An object is a real entity in memory created using the class’s blueprint. When you use new, memory is allocated on the heap and the constructor runs to initialize the object. Each object stores its own instance variable data. Methods exist once at class level but operate on each object’s data.

A constructor is a special method with the same name as the class and no return type. It executes when an object is created. The purpose is to initialize the object’s internal state so the object is valid before use.

Java allows constructor overloading so you can initialize the object in multiple ways. If no constructor is defined, Java provides a default constructor which sets default values like 0, null, false.

Overloading happens inside the same class with the same method name but different parameters. Compiler decides which one to run. This is compile-time polymorphism.

Overriding happens between parent and child classes. Child class provides its own implementation of a method from the parent. JVM decides which method runs depending on the actual object type at runtime. This is runtime polymorphism.

ArrayList uses a dynamic array in contiguous memory. Access by index is O(1). But inserting in the middle or deleting requires shifting elements, which is slow.

LinkedList uses nodes stored separately in memory with references to next/previous nodes. Access is O(n) because you must traverse nodes one by one. But insertion and deletion are O(1) if you already have the node reference, since only pointers are updated.

ArrayList → fast reading

LinkedList → fast insertion/deletion in middle

== compares memory references (for objects). It checks if both variables point to the exact same object in memory. For primitives, == compares actual values.

equals() compares content. It only works properly when the class overrides equals(). For example, String overrides equals() so comparing two separate String objects with same characters returns true.

If equals() is not overridden, default equals() behaves same as ==.

Exception handling is Java’s mechanism to handle unexpected runtime issues without crashing the program. Code that can cause problems goes inside try. If something fails, the exception is thrown and caught by the matching catch. The finally block always runs, usually to close resources like files or DB connections.

Java also supports manual throwing using throw and declaring exceptions using throws.

Internally, when an exception occurs, JVM creates an exception object, fills stack trace, and jumps to the nearest matching catch block. If none match, JVM stops the program.

The main idea is stable error control and preventing abrupt termination.

A thread is the smallest execution unit in Java. Java supports multithreading where multiple threads execute in parallel or concurrently depending on CPU capability. Each thread has its own stack memory but shares heap with other threads. Shared heap can cause race conditions if not synchronized properly.

You create threads by extending Thread or implementing Runnable. Logic goes inside run(). When you call start(), a new thread is created and run executes separately.

Java’s thread scheduler decides CPU time allocation and handles state changes like New, Runnable, Running, Waiting, Terminated.

In Java, String is stored in a special memory area called the String Constant Pool. This is a separate block of the heap where Java stores string literals in a way that avoids duplicate string objects. For example:

Both a and b point to the same memory location in the String Pool because Java internally checks if the literal already exists. If it does, it reuses the existing reference.

String is immutable because:

1. The same literal might be shared across multiple references. If one changed it, it would affect all.
2. It guarantees safe use of Strings in class loading, hashing, and caching.
3. Immutable strings allow JVM to optimize heavily with String Pool.

Any modification like a = a + "x" creates a new object in the heap, not in the pool, because new values don’t replace existing pool entries.

This immutability ensures safe memory-sharing and predictable behavior.

When you do something like:

The JVM performs multiple internal steps:

1. Class metadata check: JVM first checks if the class’s bytecode is loaded.
2. If not, JVM loads .class file, verifies it, and allocates metadata in the Method Area.
3. Heap allocation: JVM requests raw memory from the heap large enough to fit all instance variables of Employee.
4. Default initialization: Before constructor runs, the object gets default values:
5. Numbers → 0
6. boolean → false
7. object references → null
8. Set object's object header: JVM fills internal header fields like hashcode, GC metadata, class pointer, lock bits.
9. Execute constructor: After memory is allocated and raw default values are set, Java calls your constructor to initialize the object with real values.
10. Reference assignment: The variable emp stores the reference (memory address) pointing to that heap object.

This entire process is optimized differently based on the garbage collector, memory layout, and JVM architecture.

JVM uses a reachability-based memory model. It starts with something called GC Roots. These are special references that are always reachable:

1. Local variables in stack frames
2. Active thread references
3. Static variables
4. References from JIT compiled code
5. JNI (native code) references

The GC begins from these GC Roots and performs a graph traversal (like DFS).

Everything reachable from a root is “alive”.

Anything not reachable from any GC Root is considered “garbage”, meaning no part of the program can access it anymore. GC then marks these objects and frees the memory.

Java does not use reference counting (like Python) because reference counting fails for cyclic references. Reachability solves this because cycles get collected if they have no root path.

Stack memory stores:

1. local variables
2. method parameters
3. return addresses
4. part of thread state

Each thread has its own stack, so no two threads share stack memory.

Stack memory is faster because it grows/shrinks linearly with method calls.

Heap memory stores:

1. all objects
2. arrays
3. class-level objects
4. String pool (till Java 7; now it's in heap but special area)

Heap is shared across all threads.

Because it is shared, heap memory operations require more control, GC, locking states (for synchronized), and safety checks.

Stack overflow happens when the method call depth exceeds limit.

Heap overflow happens when no more memory is available to allocate new objects.

In multithreading, each thread can store copies of variables in its own CPU cache. So if one thread updates a variable, another thread may not see the latest value because it's still reading from its cache.

volatile solves this by:

1. Forcing the variable to always be read from main memory, not CPU cache.
2. Forcing all writes to the variable to go immediately to main memory.
3. Preventing reordering of read/write operations.

So volatile ensures visibility and ordering, but not atomicity.

Example:

If one thread sets flag = true, all threads immediately see the updated value.

Without volatile, threads may use old cached values, causing unpredictable behavior.

HashMap stores key-value pairs inside an internal array called buckets. For each key, HashMap calls hashCode() and then applies internal hashing to decide which bucket the entry should go into. If the bucket is empty, entry is stored directly. If bucket already contains entries, HashMap uses a linked list or a balanced tree (red-black tree) when collisions exceed a threshold.

When two keys have same hash (collision), HashMap compares using equals() to check if they are same key or different keys. If same key, value gets updated. If different keys, it gets appended in the bucket chain.

From Java 8 onwards, if the bucket has too many collisions (linked list becomes large), HashMap converts the list into a Red-Black Tree, reducing worst-case search time from O(n) to O(log n). Normal operation is average O(1).

Immutability means once an object is created, its internal state cannot change. Java’s String class is immutable. This means every time you modify a string (e.g., concatenate), Java creates a new String object instead of modifying the existing one.

String achieves immutability by:

1. storing characters in a final char array
2. making the class itself final so no subclass can override behavior
3. no setter methods that change existing values

Immutability is important because strings are heavily used in class loading, security checks, and storing sensitive data. If strings were mutable, security vulnerabilities could occur (like altering a file path or changing a key).

Because of immutability, Strings are stored in the String Pool. If two strings have same content, they share the same reference which saves memory.