Java Interview Questions

Unlike interpreted languages, Java follows a two-step execution process.

1. The Java compiler (javac) compiles the .java source file into bytecode (.class file).

2. The Java Virtual Machine (JVM) executes the bytecode.

This architecture allows Java programs to run on different operating systems without changing the source code.

public class Test {
    public static void main(String[] args) {
        int x = 10;
        System.out.println(x);
    }
}

Output
10

These three components are essential for developing and running Java applications.

• JDK (Java Development Kit) provides everything needed to develop Java applications, including the compiler (javac), JRE, and development tools.

• JRE (Java Runtime Environment) provides the libraries and runtime environment required to run Java applications.

• JVM (Java Virtual Machine) is responsible for executing Java bytecode and converting it into machine-specific instructions.

In simple terms:

• JDK is used to develop Java programs.

• JRE is used to run Java programs.

• JVM is the engine that actually executes the bytecode.

A variable is a named memory location used to store data.

Java is a statically typed language, meaning every variable must have a declared data type before it can be used.

Common primitive data types include:

• byte

• short

• int

• long

• float

• double

• char

• boolean

Reference types include:

• String

• Arrays

• Classes

• Interfaces

• Objects

int age = 24;
double salary = 45000.75;
char grade = 'A';
boolean active = true;

System.out.println(age);

Output
24

Java data types are divided into two categories.

Primitive data types store actual values directly in memory. They are predefined by the language and include types such as int, double, and boolean.

Reference data types store the memory address (reference) of an object rather than the object itself. Examples include String, arrays, custom classes, and collections.

Primitive types are lightweight and generally faster, while reference types allow developers to work with complex data structures and objects.

Operators perform operations on variables and values.

Java provides several categories of operators:

• Arithmetic Operators

• Relational Operators

• Logical Operators

• Assignment Operators

• Unary Operators

• Bitwise Operators

• Ternary Operator

These operators are used in calculations, comparisons, decision-making, and data manipulation.

Conditional statements allow a program to execute different blocks of code based on specified conditions.

Java provides:

• if

• if-else

• else-if

• switch

These statements are widely used in authentication, validation, business rules, and decision-making logic.

int age = 20;

if(age >= 18){
    System.out.println("Eligible");
}else{
    System.out.println("Not Eligible");
}

Output
Eligible

Loops execute a block of code repeatedly until a specified condition is met.

Java supports:

• for

• while

• do-while

• Enhanced for-each

Loops reduce code duplication and are commonly used for iterating through arrays, collections, and processing large datasets.

for(int i = 1; i <= 5; i++){
    System.out.println(i);
}

Output 
1
2
3
4
5

A method is a reusable block of code that performs a specific task.

Methods improve:

• Code reusability

• Readability

• Maintainability

• Testing

• Modularity

A method can accept parameters, perform operations, and return a result.

Using methods avoids writing the same logic multiple times and makes programs easier to understand and maintain.

public class Main {

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

    public static void main(String[] args){

        System.out.println(add(10,20));

    }

}

Output 
30

Object-Oriented Programming (OOP) is a programming paradigm that organizes software using objects and classes instead of just functions.

Java is considered a pure object-oriented language (except for primitive data types) because most code is written by creating objects that represent real-world entities.

The four pillars of OOP are:

• Encapsulation

• Inheritance

• Polymorphism

• Abstraction

Using OOP makes applications easier to maintain, extend, and reuse because related data and behavior are grouped together.

class Student {

    String name;

    void study() {
        System.out.println(name + " is studying");
    }

}

public class Main {

    public static void main(String[] args) {

        Student s = new Student();

        s.name = "Peter";

        s.study();

    }

}

Output 
Peter is studying

A class is a blueprint that defines the properties (fields) and behaviors (methods) of an object.

An object is an actual instance of a class that occupies memory and can access the class's fields and methods.

Think of a class as the design of a car and an object as the actual car built from that design.

class Car {

    String brand = "BMW";

}

public class Main {

    public static void main(String[] args) {

        Car car = new Car();

        System.out.println(car.brand);

    }

}

Output
BMW

Encapsulation is the process of hiding an object's internal data and allowing controlled access through public methods.

Instead of making variables directly accessible, they are declared as private, and developers provide getter and setter methods to read or modify them.

This prevents unauthorized changes and ensures that business rules are enforced before data is updated.

Inheritance allows one class to acquire the properties and methods of another class.

The class being inherited is called the parent (superclass), and the class inheriting from it is called the child (subclass).

This promotes code reuse because common functionality is written once in the parent class and automatically becomes available in child classes.

Polymorphism means "many forms." It allows the same method name to perform different behaviors depending on the object.

Java supports two types of polymorphism:

• Compile-time polymorphism (Method Overloading)

• Runtime polymorphism (Method Overriding)

Polymorphism makes applications flexible because the same interface can work with different implementations.

Abstraction is the process of hiding implementation details and exposing only the essential functionality to the user.

Java provides abstraction through:

• Abstract Classes

• Interfaces

Abstraction reduces complexity by allowing developers to focus on what an object does rather than how it does it.

It is especially useful when designing large systems where multiple classes share common behavior but have different implementations.

Method overloading occurs when multiple methods in the same class have the same name but different parameter lists. The compiler determines which method to call based on the arguments provided, making it an example of compile-time polymorphism.

Method overriding occurs when a subclass provides its own implementation of a method already defined in its parent class. The decision about which method to execute is made at runtime based on the actual object, making it an example of runtime polymorphism.

Use overloading when similar operations need to accept different inputs. Use overriding when a child class needs specialized behavior while preserving the same method signature.

Method overloading occurs when multiple methods in the same class have the same name but different parameter lists. The compiler determines which method to call based on the arguments provided, making it an example of compile-time polymorphism.

Method overriding occurs when a subclass provides its own implementation of a method already defined in its parent class. The decision about which method to execute is made at runtime based on the actual object, making it an example of runtime polymorphism.

Use overloading when similar operations need to accept different inputs. Use overriding when a child class needs specialized behavior while preserving the same method signature.

A constructor is a special method that is automatically called when an object is created.

Its primary purpose is to initialize object fields or perform setup tasks.

Characteristics of constructors:

• Constructor name must match the class name.

• Constructors do not have a return type.

• They are called automatically when using the new keyword.

• Constructors can be overloaded.

class Student {

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

}

public class Main {

    public static void main(String[] args) {

        Student s = new Student();

    }

}

Output 
Constructor Called