Java Fundamentals

***1. Why is Java platform independent?

Java is called platform independent because Java code can run on any operating system without recompilation.

How it works:

1. Java source code (.java) is compiled into bytecode (.class).
2. Bytecode is not machine-specific.
3. The JVM (Java Virtual Machine) converts bytecode into machine code for the specific OS.

This follows the principle:

“Write Once, Run Anywhere (WORA)”

Example:

A Java program compiled on Windows can run on:

• Linux
• macOS
• Unix

as long as a JVM is installed.

Important Interview Point:

Java is platform independent because of the JVM and bytecode, not because of the compiler.

***2. What are the main features of Java?

Java provides many powerful features that make it popular.

Main Features of Java

1. Platform Independent

Runs on any OS using JVM.

2. Object-Oriented

Everything is based on classes and objects.

3. Simple

Easy syntax compared to C++.
Removes complex concepts like:

• Pointer arithmetic
• Multiple inheritance using classes

4. Secure

Java provides:

• Bytecode verification
• Security manager
• No direct memory access

5. Robust

Strong memory management and exception handling.

6. Multithreaded

Supports concurrent execution using threads.

7. High Performance

JIT compiler improves execution speed.

8. Distributed

Supports distributed applications using:

• RMI
• Web services
• Networking APIs

9. Dynamic

Classes can be loaded dynamically during runtime.

10. Automatic Garbage Collection

Unused memory is automatically cleaned.

Important Interview Point:

Interviewers often ask:

“Which feature of Java makes it secure?”

Answer:

• No pointers
• Bytecode verification
• JVM sandbox environment

***3. What is JVM?

JVM stands for Java Virtual Machine.

It is a virtual environment that executes Java bytecode.

Responsibilities of JVM

• Loads class files
• Verifies bytecode
• Executes code
• Manages memory
• Performs garbage collection

JVM Architecture Components

• Class Loader
• Method Area
• Heap Memory
• Stack Memory
• Execution Engine
• Garbage Collector

Important Interview Point:

JVM is platform dependent, while Java is platform independent.

Different OS have different JVM implementations.

***4. What is JRE?

JRE stands for Java Runtime Environment.

It provides everything required to run Java applications.

JRE Contains

• JVM
• Core libraries
• Supporting files

JRE does NOT contain:

• Java compiler (javac)

Usage:

Used only for running Java programs.

Formula:

JRE = JVM + Libraries

***5. What is JDK?

JDK stands for Java Development Kit.

It is used to develop, compile, and run Java applications.

JDK Contains

• JRE
• JVM
• Compiler (javac)
• Debugging tools
• Development utilities

Formula:

JDK = JRE + Development Tools

Important Interview Point:

Developers install JDK because it includes both compiler and runtime environment.

***6. Difference between JVM, JRE, and JDK.

Relationship

JDK = JRE + Development Tools
JRE = JVM + Libraries

Interview Shortcut:

• JVM → Executes
• JRE → Runs
• JDK → Develops

***7. What is JIT Compiler?

JIT stands for Just-In-Time Compiler.

It is part of the JVM that improves Java performance.

How JIT Works

Normally:

• Bytecode is interpreted line by line.

JIT:

• Converts frequently used bytecode into native machine code.
• Stores compiled code for reuse.

This reduces repeated interpretation.

Benefits

• Faster execution
• Improved performance
• Runtime optimization

Important Interview Point:

Without JIT, Java would be much slower because interpretation alone is slower than native execution.

**8. What is a ClassLoader?

ClassLoader is a JVM subsystem that loads .class files into memory.

Types of ClassLoaders

1. Bootstrap ClassLoader

Loads core Java classes like:

java.lang.*

2. Extension ClassLoader

Loads extension libraries.

3. Application ClassLoader

Loads application classes from classpath.

Class Loading Process

1. Loading
2. Linking
3. Initialization

Important Interview Point:

Java uses dynamic class loading, meaning classes are loaded only when required.

***9. Explain public static void main(String args[]).

This is the entry point of a Java application.

public static void main(String args[])

Explanation of Each Keyword

public

Accessible from anywhere.
JVM must access it.

static

Can be called without creating an object.

void

Returns nothing.

main

Special method name recognized by JVM.

String args[]

Stores command-line arguments.

Example

class Test {
    public static void main(String args[]) {
        System.out.println("Hello Java");
    }
}

Important Interview Point:

JVM starts program execution from the main() method.

***10. Why is the main method static in Java?

The main() method is static because JVM calls it directly without creating an object.

Reason

If main() were non-static:

• JVM would first need to create an object.
• Object creation itself may depend on code execution.

To avoid this dependency, Java keeps main() static.

Example

public static void main(String args[])

JVM can directly call:

ClassName.main();

Important Interview Point:

Static methods belong to the class, not objects.

**11. Can the main method be overloaded?

Yes, the main() method can be overloaded.

Example

class Test {

    public static void main(String[] args) {
        System.out.println("Original main");
    }

    public static void main(int a) {
        System.out.println(a);
    }
}

Important Point

JVM always calls:

public static void main(String[] args)

Other overloaded versions are called manually.

Interview Trap

Overloading is allowed.
Overriding static methods is not true runtime polymorphism.

**12. What happens if the main method is not static?

If main() is not static, the program compiles but JVM cannot execute it properly.

Example

public void main(String[] args)

Runtime Error

Error: Main method is not static

Reason

JVM calls main() without creating an object.

Non-static methods require object creation.

Important Interview Point:

main() must always be:

public static void main(String[] args)

*13. What are packages in Java?

Packages are used to organize related classes and interfaces.

They help avoid naming conflicts and improve code management.

Types of Packages

1. Built-in Packages

Provided by Java.

Examples:

java.lang
java.util
java.io

2. User-Defined Packages

Created by developers.

Example

package mypackage;

public class Test {
    public void display() {
        System.out.println("Hello");
    }
}

Advantages

• Better organization
• Avoid class name conflicts
• Access protection
• Reusability

Important Interview Point:

java.lang package is imported automatically by Java.

*14. Advantages of Packages in Java

Packages in Java are used to organize related classes and interfaces into a structured namespace.

Advantages of Packages

1. Avoids Naming Conflicts

Two classes can have the same name if they belong to different packages.

Example

java.util.Date
java.sql.Date

2. Better Code Organization

Packages help organize large projects into modules.

Example:

com.company.service
com.company.model
com.company.controller

3. Provides Access Protection

Packages work with access modifiers like:

• protected
• default

to control visibility.

4. Improves Code Reusability

Reusable classes can be grouped into packages and imported where needed.

5. Easier Maintenance

Structured code is easier to:

• debug
• test
• maintain

6. Supports Modular Development

Different teams can work on separate packages independently.

Important Interview Point:

Java follows a hierarchical package structure using dot notation.

Example:

java.util.Scanner

Data Types & Variables

***15. Difference between primitive and non-primitive data types

Primitive Data Types

Primitive types store actual values directly.

Types

byte, short, int, long,
float, double,
char, boolean

Example

int x = 10;

Non-Primitive Data Types

Non-primitive types store references to objects.

Examples

• String
• Array
• Class
• Interface

Example

String name = "Java";

Difference Table

Important Interview Point:

String is non-primitive in Java even though it behaves like a basic type.

***16. Difference between instance variable, local variable, and class variable

1. Instance Variable

Declared inside class but outside methods.

Each object gets its own copy.

Example

class Test {
    int x = 10;
}

Features

• Belongs to object
• Stored in heap memory
• Has default values

2. Local Variable

Declared inside methods or blocks.

Example

void show() {
    int a = 5;
}

Features

• Scope limited to method/block
• No default value
• Stored in stack memory

3. Class Variable (Static Variable)

Declared using static.

Shared among all objects.

Example

class Test {
    static int count = 0;
}

Features

• Single copy shared by all objects
• Memory allocated once

Difference Table

Important Interview Point:

Static variables are initialized only once during class loading.

***17. What are static variables?

Static variables are class-level variables shared among all objects of a class.

They are declared using the static keyword.

Example

class Employee {

    static String company = "Google";

    int id;
}

All objects share the same company variable.

Features of Static Variables

• Belong to class, not object
• Memory allocated once
• Shared across all instances
• Accessed using class name

Example

Employee.company

Use Cases

• Counters
• Constants
• Shared configuration values

Important Interview Point:

Changing a static variable affects all objects.

**18. Default values of variables in Java

Java assigns default values only to:

• instance variables
• static variables

Local variables do NOT get default values.

Default Values Table

Example

class Test {
    int x;
    boolean flag;

    public static void main(String[] args) {
        Test t = new Test();

        System.out.println(t.x);
        System.out.println(t.flag);
    }
}

Output:

0
false

Important Interview Point:

Using an uninitialized local variable causes a compile-time error.

**19. What is type casting?

Type casting means converting one data type into another.

Types of Type Casting

1. Widening Casting (Implicit)

Small type → Large type

Automatically done by Java.

Example

int a = 10;
double b = a;

2. Narrowing Casting (Explicit)

Large type → Small type

Must be done manually.

Example

double x = 10.5;
int y = (int)x;

Important Interview Point:

Narrowing may cause:

• data loss
• precision loss

*20. Explain widening and narrowing conversion

Widening Conversion

Converting smaller data type into larger data type.

Example

int a = 100;
long b = a;

Features

• Automatic
• Safe conversion
• No data loss

Widening Order

byte → short → int → long → float → double

Narrowing Conversion

Converting larger data type into smaller data type.

Example

double x = 10.9;
int y = (int)x;

Output:

10

Features

• Manual conversion required
• Possible data loss

Difference Table

Important Interview Point:

Interviewers often ask:

“Why is narrowing unsafe?”

Because data may be truncated or overflow may occur.

*21. What are wrapper classes?

Wrapper classes convert primitive data types into objects.

Each primitive type has a corresponding wrapper class.

Primitive to Wrapper Mapping

Example

int x = 10;

Integer obj = Integer.valueOf(x);

Why Wrapper Classes Exist

Java collections work only with objects.

Example:

ArrayList<Integer>

Important Interview Point:

Wrapper classes are immutable in Java.

**22. Why do we need wrapper classes?

Wrapper classes are needed because many Java APIs and collections work only with objects, not primitive types.

Reasons for Using Wrapper Classes

1. Collections Framework Requires Objects

Example

ArrayList<Integer> list = new ArrayList<>();

Primitive types like int cannot be directly stored.

2. Utility Methods

Wrapper classes provide useful methods.

Example

Integer.parseInt("100")

3. Supports Null Values

Primitive types cannot store null.

Wrapper objects can.

4. Required in Generics

Generics work only with objects.

Example

List<Double>

5. Object-Oriented Features

Primitive types are not objects.

Wrapper classes allow:

• method calls
• object behavior

Important Interview Point:

Autoboxing automatically converts primitive types into wrapper objects.

*23. What is autoboxing and unboxing?

Autoboxing

Automatic conversion of primitive type into wrapper object.

Example

int x = 10;

Integer obj = x;

Java internally does:

Integer.valueOf(x)

Unboxing

Automatic conversion of wrapper object into primitive type.

Example

Integer obj = 20;

int x = obj;

Java internally does:

obj.intValue()

Example Program

class Test {
    public static void main(String[] args) {

        Integer a = 100; // Autoboxing

        int b = a;       // Unboxing

        System.out.println(b);
    }
}

Advantages

• Cleaner code
• Simplifies collection usage
• Reduces manual conversions

Important Interview Point:

Autoboxing may create extra objects and impact performance in large loops.

Operators & Control Statements

int a = 10;
int b = 10;

System.out.println(a == b);

true

String s1 = new String("Java");
String s2 = new String("Java");

System.out.println(s1 == s2);

false

java.lang.Object

String s1 = new String("Java");
String s2 = new String("Java");

System.out.println(s1.equals(s2));

true

int x = -8;

System.out.println(x >> 1);

int x = -8;

System.out.println(x >>> 1);

Conditional Operator

condition ? expression1 : expression2;

int a = 10;
int b = 20;

int max = (a > b) ? a : b;

System.out.println(max);

20

if(a > b) {
    max = a;
} else {
    max = b;
}

for(int i = 1; i <= 5; i++) {

    if(i == 3) {
        break;
    }

    System.out.println(i);
}

1
2

for(int i = 1; i <= 5; i++) {

    if(i == 3) {
        continue;
    }

    System.out.println(i);
}

1
2
4
5

while(condition) {
    // code
}

int i = 1;

while(i <= 3) {
    System.out.println(i);
    i++;
}

do {
    // code
} while(condition);

int i = 1;

do {
    System.out.println(i);
    i++;
} while(i <= 3);

while(true) {
    System.out.println("Infinite Loop");
}

for(;;) {
    System.out.println("Infinite Loop");
}

initialization;
condition;
update;

Classes & Objects

Object-Oriented Programming System

class Car {

    String color;

    void start() {
        System.out.println("Car Started");
    }
}

class Student {

    int id;
    String name;

    void display() {
        System.out.println(name);
    }
}

Student s1 = new Student();

Data Hiding

class Employee {

    private int salary;

    public void setSalary(int salary) {
        this.salary = salary;
    }

    public int getSalary() {
        return salary;
    }
}

Access Modifiers

Code Reusability

class Child extends Parent

class Animal {

    void eat() {
        System.out.println("Eating");
    }
}

class Dog extends Animal {

    void bark() {
        System.out.println("Barking");
    }
}

IS-A Relationship

Dog IS-A Animal

One name, many forms

Method Overloading

Method Overriding

class Animal {

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

class Dog extends Animal {

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

Dynamic Method Dispatch

abstract class Shape {

    abstract void draw();
}

What an object does

How it does it

class Test {

    void add(int a, int b) {}

    void add(int a, int b, int c) {}
}

class Animal {

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

class Dog extends Animal {

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

class Student {

    Student() {
        System.out.println("Constructor Called");
    }
}

Student s = new Student();

class Test {
}

class Test {

    Test() {
        System.out.println("Hello");
    }
}

class Student {

    int id;

    Student(int id) {
        this.id = id;
    }
}

class Student {

    Student() {}

    Student(int id) {}

    Student(int id, String name) {}
}

class Student {

    int id;

    Student(int id) {
        this.id = id;
    }

    Student(Student s) {
        this.id = s.id;
    }
}

Student s1 = new Student(101);

Student s2 = new Student(s1);

this.id = id;

this.display();

this(10);

class Student {

    int id;

    Student(int id) {
        this.id = id;
    }
}

super.x;

super.display();

super();

class Animal {

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

class Dog extends Animal {

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

super()

class Parent {

    Parent() {
        System.out.println("Parent Constructor");
    }
}

class Child extends Parent {

    Child() {
        super();
    }
}

Method Overriding

class Animal {

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

class Dog extends Animal {

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

Animal a = new Dog();

a.sound();

Bark

Dynamic Method Dispatch

Method Overloading

class MathOperation {

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

    int add(int a, int b, int c) {
        return a + b + c;
    }
}

Static Polymorphism

Strings in Java

***48. What is String Pool in Java?

String Pool is a special memory area inside the heap where Java stores string literals.

It is also called:

String Constant Pool (SCP)

Why String Pool Exists

To optimize memory usage by reusing string objects.

Example

String s1 = "Java";
String s2 = "Java";

Both s1 and s2 point to the same object in the String Pool.

Memory Behavior

String s1 = "Java";
String s2 = new String("Java");

Here:

• "Java" literal goes to String Pool
• new String("Java") creates a new object in heap memory

Advantages of String Pool

• Saves memory
• Improves performance
• Avoids duplicate objects

Important Interview Point:

String literals are stored in the pool automatically, but objects created using new are stored separately in heap memory.

***49. Difference between String, StringBuffer, and StringBuilder

All three are used to handle text in Java, but they differ in mutability and thread safety.

1. String

String objects are immutable.

Any modification creates a new object.

Example

String s = "Java";

s.concat(" Programming");

Original string remains unchanged.

2. StringBuffer

StringBuffer is mutable and thread-safe.

Example

StringBuffer sb = new StringBuffer("Java");

sb.append(" Programming");

3. StringBuilder

StringBuilder is mutable but not thread-safe.

Faster than StringBuffer.

Example

StringBuilder sb = new StringBuilder("Java");

sb.append(" Programming");

Difference Table

When to Use

Important Interview Point:

StringBuilder is preferred in most modern applications because it is faster than StringBuffer.

***50. Why are Strings immutable in Java?

String objects cannot be changed after creation.

Example

String s = "Java";

s.concat(" World");

A new object is created instead of modifying the original string.

Reasons Why Strings are Immutable

1. Security

Strings are widely used in:

• database URLs
• file paths
• network connections

Immutability prevents accidental modification.

2. String Pool Optimization

Immutable strings can be safely shared in the String Pool.

3. Thread Safety

Immutable objects are naturally thread-safe.

4. HashCode Caching

Strings are used as keys in:

HashMap

Immutability ensures hashcode remains consistent.

Important Interview Point:

If strings were mutable, String Pool sharing would become unsafe.

**51. Difference between creating String using literal and new keyword

Using String Literal

Example

String s1 = "Java";

Behavior

• Stored in String Pool
• Reuses existing object if value already exists

Using new Keyword

Example

String s2 = new String("Java");

Behavior

• Creates new object in heap memory
• Always creates a separate object

Difference Table

Example

String a = "Java";
String b = "Java";

System.out.println(a == b);

Output:

true

Because both references point to same pooled object.

Important Interview Point:

Using literals is more memory efficient than using new String().

**52. Why is StringBuffer mutable?

StringBuffer is mutable to allow efficient modification of strings without creating new objects repeatedly.

Example

StringBuffer sb = new StringBuffer("Java");

sb.append(" Programming");

The same object gets modified.

Why Mutability is Important

If strings were modified using immutable String:

• multiple objects would be created
• memory usage would increase
• performance would decrease

Advantages of Mutable StringBuffer

• Better performance
• Lower memory consumption
• Efficient concatenation

Internal Working

StringBuffer maintains a resizable character array internally.

Important Interview Point:

StringBuffer methods are synchronized, making it thread-safe.

*53. How can you reverse a string in Java?

There are multiple ways to reverse a string.

Method 1: Using StringBuilder

Example

String str = "Java";

String reversed = new StringBuilder(str)
                        .reverse()
                        .toString();

System.out.println(reversed);

Output:

avaJ

Method 2: Using Loop

Example

String str = "Java";

String rev = "";

for(int i = str.length() - 1; i >= 0; i--) {
    rev += str.charAt(i);
}

System.out.println(rev);

Method 3: Using Character Array

Example

char[] arr = str.toCharArray();

Reverse manually using swapping.

Best Approach

StringBuilder.reverse()

because it is optimized and easy to read.

Important Interview Point:

Using + inside loops is inefficient because it creates multiple String objects.

*54. Why is char array preferred for passwords over String?

char[] is preferred for passwords because it provides better security than String.

Problem with String Passwords

Strings are immutable.

Once created:

• they stay in memory until garbage collected
• cannot be modified manually

This increases security risk.

Example

String password = "admin123";

Password may remain in memory for a long time.

Advantage of char[]

Character arrays are mutable.

Password data can be cleared immediately after use.

Example

char[] password = {'a','d','m','i','n'};

After usage:

Arrays.fill(password, ' ');

Memory gets cleared.

Difference Table

Important Interview Point:

Security-sensitive applications prefer char[] because passwords can be erased manually from memory.

Arrays

***55. What is an array?

An array is a collection of similar data types stored in contiguous memory locations.

Arrays are used to store multiple values using a single variable name.

Features of Arrays

• Fixed size
• Stores homogeneous data
• Fast access using index
• Index starts from 0

Syntax

datatype[] arrayName;

Example

int[] numbers = {10, 20, 30, 40};

Accessing Array Elements

System.out.println(numbers[0]);

Output:

10

Memory Representation

Index :  0   1   2   3
Value : 10  20  30  40

Important Interview Point:

Arrays in Java are objects stored in heap memory.

***56. Difference between array and ArrayList

Both arrays and ArrayList are used to store collections of data, but they differ in flexibility and functionality.

Array

An array has fixed size.

Example

int[] arr = new int[5];

ArrayList

ArrayList is a resizable collection class from:

java.util

Example

ArrayList<Integer> list = new ArrayList<>();

Difference Table

Example

list.add(10);
list.remove(0);

When to Use

Important Interview Point:

ArrayList internally uses arrays.

**57. Why does array indexing start from 0?

Array indexing starts from 0 because of memory address calculation efficiency.

Internal Formula

Address Calculation

Address = Base Address + (Index × Size of Element)

Example

int[] arr = {10, 20, 30};

If:

• base address = 100
• size of int = 4 bytes

Then:

arr[0] = 100 + (0 × 4) = 100
arr[1] = 100 + (1 × 4) = 104

Advantages of Zero-Based Indexing

• Faster calculations
• Simpler memory access
• Efficient implementation

Important Interview Point:

Most programming languages use zero-based indexing for performance optimization.

**58. Types of arrays in Java

Java supports multiple types of arrays.

1. Single-Dimensional Array

Stores data in one row.

Example

int[] arr = {10, 20, 30};

2. Multidimensional Array

Array of arrays.

Example

int[][] matrix = {
    {1, 2},
    {3, 4}
};

3. Jagged Array

Rows contain different column sizes.

Example

int[][] arr = {
    {1, 2},
    {3, 4, 5},
    {6}
};

Classification Based on Data Type

Primitive Arrays

int[] arr;
double[] marks;

Object Arrays

String[] names;
Student[] students;

Important Interview Point:

In Java, multidimensional arrays are internally implemented as arrays of arrays.

*59. What is a jagged array?

A jagged array is a multidimensional array where each row can have different lengths.

It is also called:

Ragged Array

Example

int[][] arr = new int[3][];

arr[0] = new int[2];
arr[1] = new int[4];
arr[2] = new int[1];

Memory Representation

Row 0 → 2 columns
Row 1 → 4 columns
Row 2 → 1 column

Advantages

• Efficient memory usage
• Flexible row sizes

Use Cases

• Matrix representations
• Dynamic table structures

Important Interview Point:

Java does not store multidimensional arrays as continuous memory blocks like C/C++.

*60. Difference between int[] arr and int arr[]

Both declarations are valid and create integer arrays.

Method 1

int[] arr;

Preferred Java style.

Method 2

int arr[];

Older C/C++ style syntax.

Difference

Example

int[] a = new int[5];

int b[] = new int[5];

Both are equivalent.

Important Interview Point:

Most Java coding standards recommend:

int[] arr;

because it clearly associates array notation with the data type.

*61. Advantages and disadvantages of arrays

Advantages of Arrays

1. Fast Access

Elements can be accessed using index in:

O(1)

time complexity.

2. Easy Traversal

Arrays are simple to iterate using loops.

3. Memory Efficient

Stores elements in contiguous memory locations.

4. Supports Multiple Data Storage

Can store large amounts of similar data.

5. Better Performance

Faster than many dynamic collections.

Disadvantages of Arrays

1. Fixed Size

Size cannot be changed after creation.

2. Homogeneous Data Only

Stores same data type elements.

3. Insertion/Deletion is Costly

Requires shifting elements.

4. Memory Wastage

Unused allocated memory remains reserved.

5. No Built-in Methods

Unlike collections, arrays provide limited functionality.

Difference Summary

Important Interview Point:

Arrays are preferred when:

• size is fixed
• high performance is required
• direct index access is important

***62. What is exception handling?

Exception handling is a mechanism in Java used to handle runtime errors so that the normal flow of the program can continue.

What is an Exception?

An exception is an unwanted event that occurs during program execution.

Examples:

• division by zero
• file not found
• invalid array index
• null object access

Purpose of Exception Handling

• Prevent program termination
• Handle errors gracefully
• Maintain normal application flow

Keywords Used

• try
• catch
• finally
• throw
• throws

Example

class Test {

    public static void main(String[] args) {

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

        System.out.println("Program continues");
    }
}

Output

Cannot divide by zero
Program continues

Important Interview Point:

Exception handling improves program reliability and user experience.

***63. Difference between checked and unchecked exceptions

Exceptions in Java are divided into:

1. Checked Exceptions
2. Unchecked Exceptions

Checked Exceptions

Checked exceptions are checked at compile time.

The compiler forces handling using:

• try-catch
• throws

Examples

• IOException
• SQLException
• FileNotFoundException

Example

FileReader file = new FileReader("test.txt");

Compiler requires exception handling.

Unchecked Exceptions

Unchecked exceptions occur at runtime.

Compiler does not force handling.

Examples

• NullPointerException
• ArithmeticException
• ArrayIndexOutOfBoundsException

Example

int x = 10 / 0;

Difference Table

Important Interview Point:

All unchecked exceptions are subclasses of:

RuntimeException

***64. Difference between Error and Exception

Both Error and Exception are subclasses of:

Throwable

But they represent different problems.

Exception

Exceptions are conditions that applications can handle.

Examples

• IOException
• NullPointerException

Error

Errors are serious system-level problems that applications usually cannot recover from.

Examples

• OutOfMemoryError
• StackOverflowError

Difference Table

Important Interview Point:

Errors usually indicate JVM or system failure and should not normally be caught.

***65. What is try-catch-finally?

These blocks are used for exception handling.

try Block

Contains code that may cause an exception.

catch Block

Handles the exception generated in the try block.

finally Block

Executes regardless of whether exception occurs or not.

Usually used for:

• closing files
• releasing resources
• database cleanup

Example

try {

    int x = 10 / 0;

}
catch(ArithmeticException e) {

    System.out.println("Exception handled");

}
finally {

    System.out.println("Finally block executed");
}

Output

Exception handled
Finally block executed

Important Interview Point:

finally block is mostly used for resource cleanup.

**66. Can finally block be skipped?

Normally, the finally block always executes.

However, it may be skipped in some special situations.

Cases Where finally May Not Execute

1. JVM Shutdown

System.exit(0);

2. System Crash

• Power failure
• JVM crash

Example

try {
    System.exit(0);
}
finally {
    System.out.println("Finally");
}

Output:

(No output)

Important Interview Point:

Except for abnormal JVM termination, finally almost always executes.

**67. Difference between throw and throws

Both are used in exception handling but serve different purposes.

throw Keyword

Used to explicitly throw an exception.

Example

throw new ArithmeticException("Invalid");

throws Keyword

Used in method declaration to indicate possible exceptions.

Example

void readFile() throws IOException

Difference Table

Important Interview Point:

throw is used by programmers, while throws informs the compiler and caller about exceptions.

**68. What is exception propagation?

Exception propagation means passing an exception from one method to another until it is handled.

Flow

If a method does not handle an exception:

• JVM passes it to the calling method
• continues until handled

Example

class Test {

    void method1() {
        method2();
    }

    void method2() {
        int x = 10 / 0;
    }

    public static void main(String[] args) {

        try {
            new Test().method1();
        }
        catch(Exception e) {
            System.out.println("Handled");
        }
    }
}

Output

Handled

Important Interview Point:

Unchecked exceptions propagate automatically in Java.

*69. What is NullPointerException?

NullPointerException occurs when we try to use an object reference that points to null.

Example

String s = null;

System.out.println(s.length());

Runtime Error

NullPointerException

Common Causes

• Calling method on null object
• Accessing field of null object
• Using null arrays

How to Avoid

• Null checks
• Proper object initialization
• Using Optional (Java 8+)

Example

if(s != null) {
    System.out.println(s.length());
}

Important Interview Point:

NullPointerException is one of the most common runtime exceptions in Java interviews and real projects.

*70. What happens if exception is not handled?

If an exception is not handled:

1. JVM stops normal execution
2. JVM creates exception object
3. Stack trace is printed
4. Program terminates abnormally

Example

class Test {

    public static void main(String[] args) {

        int x = 10 / 0;

        System.out.println("Hello");
    }
}

Output

Exception in thread "main" java.lang.ArithmeticException: / by zero

Hello will not print.

JVM Behavior

JVM searches for matching catch block:

• current method
• caller method
• propagation chain

If not found:

Program terminates

Important Interview Point:

Unchecked exceptions may compile successfully but can crash the application at runtime if not handled properly.

Collections Basics

Collections

Iterable
   |
Collection
   ├── List
   ├── Set
   └── Queue

Map (separate hierarchy)

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