Java Interview Questions

Java achieves platform independence through its "Write Once, Run Anywhere" (WORA) philosophy. The Java compiler converts source code into an intermediate form called bytecode, which is executed by the Java Virtual Machine (JVM). Since JVM implementations exist for different operating systems, the same bytecode can run across multiple platforms without modification.

• Java is purely object-oriented, while C++ supports both procedural and object-oriented paradigms.
• Java has automatic memory management via garbage collection, whereas C++ requires manual memory management.
• Java does not support multiple inheritance using classes but uses interfaces instead.
• Unlike C++, Java lacks pointers for direct memory manipulation, improving security.
• Java is interpreted at runtime via JVM, while C++ code is compiled directly to machine code.

Java is not fully object-oriented because it includes primitive data types (int, char, float, etc.) that are not objects. Pure OOP languages treat everything as an object, whereas Java allows operations on primitives without wrapping them in objects.

• Heap Memory: Stores objects and instance variables; shared among threads. Objects remain until garbage collection removes them.
• Stack Memory: Stores method calls, local variables, and function execution contexts. Each thread has its own stack, and memory is released as methods finish execution.

• Instance Variable: Declared within a class but outside methods, belongs to an object, and persists as long as the object exists.
• Local Variable: Declared inside a method or block, exists only during method execution, and is stored in stack memory.

Encapsulation is an OOP principle where data and methods that operate on the data are bundled within a single unit (class). It ensures data security by restricting direct access using access modifiers (private, protected, public).

• Static Methods: Belong to the class rather than instances; can be accessed without object creation.
• Static Variables: Shared among all instances of the class; memory is allocated only once in the class’s lifetime.
• Static Classes: Nested static classes exist within another class and can be accessed without an instance of the outer class.

Garbage collection in Java automatically reclaims memory occupied by objects that are no longer referenced, preventing memory leaks and improving application efficiency.

A ClassLoader is responsible for dynamically loading classes into memory at runtime. Java has three primary ClassLoaders:

• Bootstrap ClassLoader: Loads core Java classes (e.g., java.lang package).
• Extension ClassLoader: Loads classes from the ext directory.
• Application ClassLoader: Loads classes from the classpath.

Method Overloading: Defining multiple methods in the same class with the same name but different parameters.

class MathOperations {
    int add(int a, int b) { return a + b; }
    double add(double a, double b) { return a + b; }
}

Method Overriding: A subclass provides a new implementation for a method inherited from its superclass.

class Parent {
    void show() { System.out.println("Parent class"); }
}
class Child extends Parent {
    void show() { System.out.println("Child class"); }
}

No, static methods are associated with the class itself rather than any specific instance, which means they cannot be overridden.

Since the JVM calls main() without creating an object of the class, it must be static to allow execution at the class level.

• final: A keyword used for variables (constant values), methods (prevent overriding), and classes (prevent inheritance).
• finally: A block that executes after a try-catch, ensuring resources are released.
• finalize: A method used for cleanup before garbage collection.

Yes, multiple catch blocks allow handling different exception types separately.

try {
    int result = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println("Cannot divide by zero");
} catch (Exception e) {
    System.out.println("General Exception");
}

• String: Immutable; every modification creates a new object.
• StringBuffer: Mutable and thread-safe but slower due to synchronization.
• StringBuilder: Mutable and faster but not thread-safe.

Strings are immutable and remain in memory until garbage collection, making them a security risk. A char array can be explicitly cleared after use.

• Extending Thread class
• Implementing Runnable interface
• Using ExecutorService for thread pooling

Synchronization prevents multiple threads from accessing shared resources concurrently, avoiding data inconsistency.

class SharedResource {
    synchronized void display() { System.out.println("Thread-safe execution"); }
}

• HashMap: Not synchronized, allows one null key, faster.
• HashTable: Synchronized, does not allow null keys, slower.

Removing an element in a linked list involves changing pointers, whereas an array requires shifting elements.

Composition provides better flexibility and reduces tight coupling compared to inheritance, making code easier to maintain and modify.

• Setting the reference to null
• Assigning a new reference to an existing object
• Object goes out of scope

States: New → Runnable → Running → Blocked/Waiting → Terminated