Both abstract classes and interfaces are used to achieve abstraction in Java, but they differ in purpose and implementation.

---

Abstract Class

An abstract class can contain:

• abstract methods
• concrete methods

It is used when classes share common behavior.

---

Example

abstract class Animal {

    abstract void sound();

    void sleep() {
        System.out.println("Sleeping");
    }
}

---

Interface

An interface defines a contract that classes must implement.

---

Example

interface Animal {

    void sound();
}

---

Difference Table

---

When to Use

---

Important Interview Point:

Java does not support multiple inheritance using classes, but interfaces provide multiple inheritance capability.

---

***2. What are marker interfaces?

A marker interface is an interface with no methods or fields.

It is used to provide metadata or special information to JVM/compiler.

---

Example Marker Interfaces

• Serializable
• Cloneable
• Remote

---

Example

class Student implements Serializable {
}

---

Purpose

Marker interfaces tell JVM:

"This class has special behavior."

---

Common Use Cases

---

Important Interview Point:

Marker interfaces are also called:

Tag Interfaces

---

***3. Composition vs Aggregation

Both represent:

HAS-A relationship

but differ in ownership and lifecycle dependency.

---

Composition

Strong relationship where child object cannot exist independently.

---

Example

class Engine {
}

class Car {

    private Engine engine = new Engine();
}

If Car is destroyed, Engine is also destroyed.

---

Aggregation

Weak relationship where child object can exist independently.

---

Example

class Student {
}

class College {

    List<Student> students;
}

Students can exist without college.

---

Difference Table

---

Important Interview Point:

Composition represents:

Part-of relationship

---

***4. Why is composition preferred over inheritance?

Composition is preferred because it provides:

• loose coupling
• better flexibility
• easier maintenance

---

Problems with Inheritance

• Tight coupling
• Fragile hierarchy
• Difficult maintenance
• Limited flexibility

---

Advantages of Composition

1. Better Code Reusability

Behavior can be reused dynamically.

---

2. Loose Coupling

Changes in one class minimally affect others.

---

3. Runtime Flexibility

Objects can change behavior dynamically.

---

Example

class Engine {
    void start() {
    }
}

class Car {

    private Engine engine;

    Car(Engine engine) {
        this.engine = engine;
    }
}

---

Famous Design Principle

Favor composition over inheritance

---

Important Interview Point:

Modern design patterns heavily prefer composition.

Examples:

• Strategy Pattern
• Decorator Pattern

---

**5. What is Association in Java?

Association represents a relationship between two separate classes.

It shows how objects communicate with each other.

---

Example

class Teacher {
}

class Student {

    Teacher teacher;
}

Student is associated with Teacher.

---

Types of Association

1. One-to-One

One object linked with one object.

---

2. One-to-Many

One object linked with multiple objects.

---

3. Many-to-Many

Multiple objects linked with multiple objects.

---

Features

• Represents relationship
• Objects remain independent
• No ownership required

---

Important Interview Point:

Aggregation and composition are specialized forms of association.

---

**6. Explain IS-A and HAS-A relationships

These relationships are fundamental in OOP design.

---

IS-A Relationship

Represents inheritance.

---

Example

class Animal {
}

class Dog extends Animal {
}

Dog IS-A Animal.

---

Features

• Achieved using inheritance
• Promotes code reuse

---

HAS-A Relationship

Represents composition or aggregation.

---

Example

class Engine {
}

class Car {

    Engine engine;
}

Car HAS-A Engine.

---

Difference Table

---

Important Interview Point:

• IS-A → inheritance
• HAS-A → composition

---

**7. What are covariant return types?

Covariant return type means an overridden method can return a subclass type instead of parent type.

Introduced in:

Java 5

---

Example

class Animal {
}

class Dog extends Animal {
}

class Parent {

    Animal getObject() {
        return new Animal();
    }
}

class Child extends Parent {

    Dog getObject() {
        return new Dog();
    }
}

---

Benefits

• More specific return types
• Improved readability
• Better type safety

---

Important Interview Point:

Covariant return types work only in method overriding.

---

*8. What are virtual methods in Java?

A virtual method is a method whose execution is determined at runtime based on the actual object type.

In Java:

• all non-static methods are virtual by default

except:

• private methods
• static methods
• final methods

---

Example

class Animal {

    void sound() {
        System.out.println("Animal");
    }
}

class Dog extends Animal {

    void sound() {
        System.out.println("Bark");
    }
}

---

Runtime Behavior

Animal a = new Dog();

a.sound();

Output:

Bark

Method is resolved during runtime.

---

Why Virtual Methods Matter

They enable:

• runtime polymorphism
• dynamic method dispatch

---

Important Interview Point:

Java achieves runtime polymorphism through virtual methods.

***9. Internal working of HashMap

HashMap stores data in:

key-value pairs

It uses:

• hashing
• bucket arrays
• linked list / balanced tree

internally.

---

Basic Working Steps

Step 1: Hash Calculation

When inserting:

map.put(key, value);

HashMap calculates:

hashCode()

of the key.

---

Step 2: Bucket Index Calculation

Hash is converted into bucket index.

Formula:

index = hash & (n - 1)

where:

• n = bucket array size

---

Step 3: Store Entry

Data stored as:

Node<Key, Value>

inside bucket.

---

Collision Handling

If multiple keys map to same bucket:

• Java 7 → Linked List
• Java 8+ → Balanced Tree (after threshold)

---

Java 8 Optimization

If bucket size exceeds:

8

Linked list converts into:

Red-Black Tree

for faster lookup.

---

Time Complexity

Worst case:

O(log n)

in Java 8 tree buckets.

---

Important Interview Point:

HashMap allows:

• one null key
• multiple null values

---

***10. How does HashSet store elements?

HashSet internally uses:

HashMap

to store elements.

---

Internal Logic

When adding element:

set.add("Java");

HashSet internally does:

map.put("Java", PRESENT);

---

Key Points

• Elements become HashMap keys
• Dummy object used as value

---

Internal Dummy Value

private static final Object PRESENT = new Object();

---

Why Duplicates Are Not Allowed

HashMap keys must be unique.

Therefore HashSet also stores unique elements.

---

Important Interview Point:

HashSet performance depends on:

• proper hashCode()
• proper equals()

implementation.

---

***11. Difference between HashMap and ConcurrentHashMap

Both store key-value pairs, but they differ in thread safety and concurrency handling.

---

HashMap

• Not synchronized
• Faster
• Not thread-safe

---

Example

HashMap<Integer, String> map = new HashMap<>();

---

ConcurrentHashMap

• Thread-safe
• Designed for concurrent access
• Uses fine-grained locking

---

Example

ConcurrentHashMap<Integer, String> map =
    new ConcurrentHashMap<>();

---

Difference Table

---

Internal Working

HashMap

Single-thread unsafe structure.

---

ConcurrentHashMap

Java 8 uses:

• CAS operations
• bucket-level locking

instead of locking whole map.

---

Important Interview Point:

ConcurrentHashMap provides better scalability than Hashtable.

---

***12. Difference between fail-fast and fail-safe iterators

These iterators differ in behavior during concurrent modification.

---

Fail-Fast Iterator

Throws:

ConcurrentModificationException

if collection is modified during iteration.

---

Example Collections

• ArrayList
• HashMap
• HashSet

---

Example

Iterator<Integer> it = list.iterator();

list.add(10);

May throw exception.

---

Fail-Safe Iterator

Works on cloned copy of collection.

Does not throw exception during modification.

---

Example Collections

• ConcurrentHashMap
• CopyOnWriteArrayList

---

Difference Table

---

Important Interview Point:

Fail-fast behavior is implemented using:

modCount

internal modification counter.

---

***13. Why is remove operation faster in LinkedList?

LinkedList removal is faster because elements are connected using nodes.

---

LinkedList Structure

Each node stores:

• data
• previous pointer
• next pointer

---

Removal in LinkedList

Only pointer references are updated.

No shifting required.

---

Example

A ↔ B ↔ C

Removing B:

A ↔ C

---

ArrayList Removal

Elements must shift after removal.

---

Complexity

---

Important Interview Point:

LinkedList removal is fast only if node reference is already known.

Searching still takes:

O(n)

---

**14. How does ArrayList grow dynamically internally?

ArrayList internally uses a dynamic array.

When capacity becomes full:

• new larger array is created
• old elements copied

---

Growth Formula

Java increases capacity by approximately:

50%

---

Example

If capacity:

10

new capacity becomes:

15

---

Internal Steps

1. Create Larger Array

newCapacity = oldCapacity + (oldCapacity >> 1)

---

2. Copy Elements

Uses:

System.arraycopy()

---

3. Replace Old Array

New array becomes active storage.

---

Important Interview Point:

Frequent resizing impacts performance.

Use:

ensureCapacity()

for optimization.

---

**15. Why can’t generic arrays be created?

Java does not allow generic array creation because of:

Type Erasure

---

Invalid Example

T[] arr = new T[10];

Compile-time error occurs.

---

Why?

Arrays

Arrays are:

Reified

They know actual type at runtime.

---

Generics

Generics use:

Type Erasure

Type information removed at runtime.

---

Problem

Runtime type safety cannot be guaranteed.

---

Example Risk

Object[] obj = new String[5];

obj[0] = 100;

Causes:

ArrayStoreException

---

Important Interview Point:

Use collections instead of generic arrays.

Example:

List<T>

---

**16. Difference between PriorityQueue and TreeSet

Both maintain sorted order but differ in storage and duplicate handling.

---

PriorityQueue

Maintains priority-based ordering using heap.

---

Features

• Allows duplicates
• Does not maintain full sorted order
• Head element has highest priority

---

Example

PriorityQueue<Integer> pq =
    new PriorityQueue<>();

---

TreeSet

Maintains fully sorted unique elements using Red-Black Tree.

---

Features

• No duplicates
• Fully sorted traversal

---

Example

TreeSet<Integer> set =
    new TreeSet<>();

---

Difference Table

---

Important Interview Point:

PriorityQueue guarantees only head priority ordering, not complete sorting.

---

**17. What is BlockingQueue?

BlockingQueue is a thread-safe queue used in multithreaded environments.

Defined in:

java.util.concurrent

---

Key Feature

Threads automatically wait when:

• queue is empty
• queue is full

---

Common Methods

---

Example

BlockingQueue<Integer> queue =
    new ArrayBlockingQueue<>(5);

---

Common Implementations

• ArrayBlockingQueue
• LinkedBlockingQueue
• PriorityBlockingQueue

---

Use Cases

• Producer-Consumer problem
• Thread pools
• Task scheduling

---

Important Interview Point:

BlockingQueue removes need for manual synchronization in producer-consumer scenarios.

---

*18. Explain EnumSet

EnumSet is a specialized Set implementation for enum types.

Defined in:

java.util

---

Features

• High performance
• Type-safe
• Internally uses bit vectors

---

Example

enum Day {
    MON, TUE, WED
}

EnumSet<Day> set =
    EnumSet.of(Day.MON, Day.WED);

---

Advantages

• Faster than HashSet
• Memory efficient
• Optimized for enums

---

Internal Working

Each enum constant represented as a bit.

---

Important Interview Point:

EnumSet allows only enum values of one enum type.

---

*19. How does TreeMap work internally?

TreeMap stores key-value pairs in sorted order.

Internally uses:

Red-Black Tree

---

Features

• Keys sorted naturally
• O(log n) operations
• No null keys

---

Example

TreeMap<Integer, String> map =
    new TreeMap<>();

Internal Working

Step 1: Compare Keys

Keys compared using:

• Comparable
  or
• Comparator

Step 2: Insert Node

Node inserted into Red-Black Tree.

Step 3: Tree Balancing

Tree automatically balanced after insertion/deletion.

Why Red-Black Tree?

Provides:

O(log n)

performance consistently.

Time Complexity

Important Interview Point:

TreeMap sorting is based on keys, not values.

***20. Explain Java Memory Model

The Java Memory Model (JMM) defines how threads interact with memory in Java.

It specifies:

• how variables are stored
• how threads access shared data
• visibility rules between threads

---

Purpose of JMM

JMM ensures:

• thread safety
• memory consistency
• predictable multithreading behavior

---

Main Components of JMM

1. Main Memory

Shared memory area where:

• objects
• instance variables
• static variables

are stored.

---

2. Thread Local Memory

Each thread has its own working memory.

Thread copies variables from main memory into local cache.

---

Working Process

Step 1

Thread reads data from main memory.

---

Step 2

Thread performs operations locally.

---

Step 3

Updated values written back to main memory.

---

Important JMM Concepts

Example Problem

Without synchronization:

count++;

may produce inconsistent results in multithreading.

---

JMM Solutions

• synchronized
• volatile
• locks
• atomic classes

Important Interview Point:

JMM is mainly designed to solve:

Concurrency and visibility issues

---

***21. What are Heap, Stack, Metaspace, and Method Area?

These are important JVM memory areas.

---

1. Heap Memory

Stores:

• objects
• instance variables

Shared among all threads.

---

Example

Student s = new Student();

Object stored in heap.

---

Features

• Managed by Garbage Collector
• Largest memory region

---

2. Stack Memory

Stores:

• method calls
• local variables
• references

Each thread has its own stack.

---

Example

int x = 10;

Stored in stack.

---

Features

• Faster access
• Automatically managed

---

3. Method Area

Stores:

• class metadata
• static variables
• method information
• constant pool

Shared among threads.

---

4. Metaspace

Introduced in:

Java 8

Replaced:

Permanent Generation (PermGen)

---

Features

• Stores class metadata
• Uses native memory
• Dynamically grows

---

Memory Diagram

JVM Memory
 ├── Heap
 ├── Stack
 ├── Method Area
 └── Metaspace

---

Difference Table

---

Important Interview Point:

Stack memory is thread-specific, while heap memory is shared.

---

***22. Minor GC vs Major GC vs Full GC

Garbage collection occurs in different memory regions.

---

JVM Heap Structure

Heap
 ├── Young Generation
 └── Old Generation

---

1. Minor GC

Occurs in:

Young Generation

---

Purpose

Removes short-lived objects.

---

Features

• Fast
• Frequent
• Less pause time

---

2. Major GC

Occurs in:

Old Generation

---

Purpose

Removes long-lived unused objects.

---

Features

• Slower
• Less frequent
• Larger pause time

---

3. Full GC

Cleans entire heap.

Includes:

• Young Generation
• Old Generation
• Metaspace

---

Features

• Slowest GC
• Causes application pause
• Expensive operation

---

Difference Table

---

Important Interview Point:

Frequent Full GC often indicates memory problems or poor JVM tuning.

---

***23. What is memory leak in Java and causes?

A memory leak occurs when unused objects remain reachable and cannot be garbage collected.

---

Why Memory Leaks Happen

Garbage Collector removes only unreachable objects.

If references remain:

• memory cannot be reclaimed

---

Common Causes

1. Static Collections

static List<Object> list = new ArrayList<>();

Objects remain forever.

---

2. Unclosed Resources

• database connections
• streams
• sockets

---

3. Listener Registrations

Objects registered but never removed.

---

4. Caching Without Limits

Large cache retaining unused objects.

---

Example

List<Object> list = new ArrayList<>();

while(true) {
    list.add(new Object());
}

---

Effects

• Increased memory usage
• Slow performance
• OutOfMemoryError

---

Prevention

• Remove unused references
• Close resources properly
• Use WeakHashMap when appropriate

---

Important Interview Point:

Java has garbage collection, but poor reference management can still cause memory leaks.

---

**24. What are soft, weak, and phantom references?

Java provides special reference types for advanced memory management.

Defined in:

java.lang.ref

---

1. Soft Reference

Objects are garbage collected only when memory is low.

---

Use Case

Caching.

---

Example

SoftReference<Object> ref =
    new SoftReference<>(obj);

---

2. Weak Reference

Objects are garbage collected as soon as no strong reference exists.

---

Use Case

WeakHashMap.

---

Example

WeakReference<Object> ref =
    new WeakReference<>(obj);

---

3. Phantom Reference

Used for post-mortem cleanup tracking.

Object already finalized before reference accessible.

---

Example

PhantomReference<Object> ref =
    new PhantomReference<>(obj, queue);

---

Difference Table

---

Important Interview Point:

Strong references prevent garbage collection completely.

---

**25. How does garbage collector work internally?

Garbage Collector automatically removes unused objects from heap memory.

---

Basic Working Steps

Step 1: Mark Phase

GC identifies reachable objects.

---

Step 2: Sweep Phase

Unused objects are removed.

---

Step 3: Compact Phase

Memory fragmentation reduced by rearranging objects.

---

Reachability Analysis

GC starts from:

GC Roots

Examples:

• stack references
• static variables
• active threads

---

Generational GC Concept

Most objects:

die young

So JVM divides heap into:

• Young Generation
• Old Generation

---

Young Generation Areas

Eden + Survivor Spaces

---

Popular Garbage Collectors

---

Important Interview Point:

Modern JVMs use:

Generational Garbage Collection

for performance optimization.

---

*26. What is OutOfMemoryError?

OutOfMemoryError occurs when JVM cannot allocate enough memory for objects.

---

Common Causes

1. Memory Leaks

Unused objects retained in memory.

---

2. Large Object Creation

Creating huge arrays or collections.

---

3. Infinite Object Creation

while(true) {
    list.add(new Object());
}

---

4. Insufficient Heap Size

JVM heap too small.

---

Common Types

---

Example

int[] arr = new int[999999999];

May cause:

OutOfMemoryError

---

Prevention

• Optimize memory usage
• Fix memory leaks
• Tune JVM heap size
• Use profiling tools

---

Important Interview Point:

OutOfMemoryError is an Error, not an Exception, and usually indicates serious memory problems.