Published January 12, 2024 by

Java interview Questions

  1. 1. What is the difference between == and .equals() in Java?

    • Answer:
      • == is used to compare primitive data types, or to check if two objects reference the same memory location.
      • .equals() is a method used to compare the content or values of two objects.
    String str1 = new String("Hello");
String str2 = new String("Hello");

// Using ==
boolean isEqualUsingDoubleEqual = (str1 == str2); // false

// Using .equals()
boolean isEqualUsingEquals = str1.equals(str2); // true

    2. Explain the concept of OOP in Java.

    • Answer:
      • Object-Oriented Programming (OOP) is a programming paradigm based on the concept of "objects," which can contain data in the form of fields (attributes) and code in the form of procedures (methods).
      • Four main principles of OOP in Java are encapsulation, inheritance, polymorphism, and abstraction.

    3. What is the difference between abstract class and interface in Java?

    • Answer:
      • An abstract class can have both abstract (methods without a body) and concrete methods, while an interface can only have abstract methods.
      • A class can extend only one abstract class, but it can implement multiple interfaces.
      • Abstract classes can have constructor methods, while interfaces cannot.

    4. Explain the concept of multithreading in Java.

    • Answer:
      • Multithreading is a concurrent execution of two or more threads. A thread is a lightweight process, and multithreading is a popular technique to improve the performance of your application.
      • In Java, you can create a thread by extending the Thread class or implementing the Runnable interface.
    // Extending Thread class
class MyThread extends Thread {
    public void run() {
        // Code to be executed in the thread
    }
}

// Implementing Runnable interface
class MyRunnable implements Runnable {
    public void run() {
        // Code to be executed in the thread
    }
}

    5. What is the purpose of the finally block in exception handling?

    • Answer:
      • The finally block is used to provide a block of code that will be executed no matter whether an exception is thrown or not.
      • It is typically used for cleanup operations like closing resources (files, database connections) to ensure they are released, regardless of whether an exception occurs or not.
    try {
    // Code that may throw an exception
} catch (Exception e) {
    // Handle the exception
} finally {
    // Code that will always be executed
}

    6. Explain the concept of garbage collection in Java.

    • Answer:
      • Garbage collection is the process by which Java automatically reclaims memory that is no longer in use by the program.
      • Java has a garbage collector that runs in the background to identify and collect objects that are no longer reachable by the program.

    7. What is the static keyword in Java?

    • Answer:
      • The static keyword in Java is used to create class-level variables and methods.
      • static variables belong to the class rather than instances of the class, and there is only one copy of the static variable that is shared by all instances of the class.
      • static methods can be called on the class itself, rather than on an instance of the class.

    8. How does Java support multiple inheritance?

    • Answer:
      • Java supports multiple inheritance through interfaces. A class can implement multiple interfaces, thus achieving a form of multiple inheritance.
    interface A {
    void methodA();
}

interface B {
    void methodB();
}

class MyClass implements A, B {
    public void methodA() {
        // Implementation of methodA
    }

    public void methodB() {
        // Implementation of methodB
    }
}


9. Explain the difference between ArrayList and LinkedList in Java.

  • Answer:
    • ArrayList and LinkedList are both implementations of the List interface in Java.
    • ArrayList uses a dynamic array to store elements, allowing fast random access. LinkedList uses a doubly-linked list, providing fast insertion and deletion operations.
    • Accessing elements in ArrayList is faster, while insertion and deletion operations are faster in LinkedList.

10. What is the super keyword used for in Java?

  • Answer:
    • The super keyword in Java is a reference variable used to refer to the immediate parent class object.
    • It is used to invoke the parent class methods, access parent class fields, and invoke the parent class constructor.
class Parent {
    void display() {
        System.out.println("Parent class method");
    }
}

class Child extends Parent {
    void display() {
        // Invoke parent class method
        super.display();
        System.out.println("Child class method");
    }
}

11. Explain the concept of method overloading and method overriding.

  • Answer:

    • Method Overloading:

      • Method overloading is the ability to define multiple methods in the same class with the same name but different parameters.
      • Overloaded methods must have a different number or type of parameters.

    • Method Overriding:

      • Method overriding occurs when a subclass provides a specific implementation for a method that is already defined in its superclass.
      • The overridden method in the subclass must have the same signature (name, return type, and parameters) as the method in the superclass.

12. What is the purpose of the transient keyword in Java?

  • Answer:
    • The transient keyword is used to indicate that a variable should not be serialized when the object containing it is serialized.
    • It is often used for variables that hold temporary or derived data, and there is no need to persist them during object serialization and deserialization.
import java.io.Serializable;

class MyClass implements Serializable {
    // This variable will not be serialized
    transient int transientVariable;

    // Other variables and methods
}

13. Explain the synchronized keyword in Java.

  • Answer:
    • The synchronized keyword is used in Java to control access to critical sections of code, preventing multiple threads from executing it simultaneously.
    • It can be applied to methods or blocks of code.
    • It ensures that only one thread can execute the synchronized method or block at a time, preventing data corruption in multithreaded environments.
class Example {
    // Synchronized method
    synchronized void synchronizedMethod() {
        // Code that needs to be synchronized
    }

    // Synchronized block
    void someMethod() {
        synchronized (this) {
            // Code that needs to be synchronized
        }
    }
}

14. What is the purpose of the finalize method in Java?

  • Answer:
    • The finalize method is called by the garbage collector before reclaiming the memory occupied by an object.
    • It allows an object to perform cleanup operations or release resources before it is garbage collected.
    • However, it's important to note that relying on finalize for resource cleanup is not recommended, and it's often better to use explicit resource management like try-with-resources or close methods.
class MyClass {
    protected void finalize() {
        // Cleanup operations before garbage collection
    }
}

15. What is the difference between HashMap and HashTable in Java?

  • Answer:
    • Both HashMap and HashTable are used to store key-value pairs.
    • HashMap is not synchronized and allows null keys and values. It is more efficient for most implementations.
    • HashTable is synchronized and does not allow null keys or values. It is considered legacy and is generally avoided in favor of HashMap.

16. What is the purpose of the this keyword in Java?

  • Answer:
    • The this keyword in Java is a reference variable referring to the current object.
    • It is used to distinguish instance variables from local variables when they have the same name, to invoke the current object's method, and to pass the current object as a parameter to other methods.
class MyClass {
    private int value;

    // Using 'this' to distinguish instance variable from parameter
    void setValue(int value) {
        this.value = value;
    }

    // Using 'this' to invoke the current object's method
    void display() {
        System.out.println("Value: " + this.value);
    }
}

17. Explain the StringBuilder class in Java and how it differs from StringBuffer.

  • Answer:
    • Both StringBuilder and StringBuffer are used to manipulate strings, but StringBuilder is not synchronized, making it more efficient in single-threaded environments.
    • StringBuilder should be preferred in cases where synchronization is not required. If synchronization is needed (e.g., in a multithreaded environment), StringBuffer can be used.
StringBuilder sb = new StringBuilder("Hello");
sb.append(" World"); // "Hello World"

18. What is the difference between throw and throws in Java?

  • Answer:
    • throw is used to explicitly throw an exception in a method.
    • throws is used in the method signature to declare the exceptions that the method might throw.
// Example using 'throw'
void exampleMethod() {
    if (someCondition) {
        throw new SomeException("Custom error message");
    }
}

// Example using 'throws' in method signature
void anotherMethod() throws SomeException {
    // Method code that might throw SomeException
}

19. Explain the principle of encapsulation in Java.

  • Answer:
    • Encapsulation is one of the four fundamental OOP principles.
    • It involves bundling the data (fields) and methods that operate on the data into a single unit called a class.
    • Access to the data is restricted to the methods defined within the class, providing control over how the data is accessed and modified.

20. What is the try-with-resources statement in Java?

  • Answer:
    • The try-with-resources statement is used to automatically close resources (like files, sockets, etc.) when they are no longer needed.
    • Resources declared within the parentheses of the try statement are automatically closed at the end of the block.
try (FileReader reader = new FileReader("example.txt");
     BufferedReader bufferedReader = new BufferedReader(reader)) {

    // Code that uses the resources

} catch (IOException e) {
    // Handle the exception
}

21. What is the Comparable interface in Java and how is it different from Comparator?

  • Answer:
    • The Comparable interface is used to define the natural ordering of objects. The compareTo method is implemented in the class of objects being compared.
    • The Comparator interface is used to define custom sorting logic for classes that may not have a natural ordering. The compare method is implemented in a separate class.
// Example using Comparable
class MyClass implements Comparable<MyClass> {
    private int value;

    @Override
    public int compareTo(MyClass other) {
        return Integer.compare(this.value, other.value);
    }
}

// Example using Comparator
class MyComparator implements Comparator<MyClass> {
    @Override
    public int compare(MyClass obj1, MyClass obj2) {
        return Integer.compare(obj1.getValue(), obj2.getValue());
    }
}

22. What is the purpose of the @Override annotation in Java?

  • Answer:
    • The @Override annotation is used to indicate that a method in a subclass is intended to override a method in its superclass.
    • It helps catch errors at compile-time if the annotated method does not actually override a method in the superclass.
class Parent {
    void display() {
        System.out.println("Parent class method");
    }
}

class Child extends Parent {
    @Override
    void display() {
        System.out.println("Child class method");
    }
}

23. How does the equals method differ from the hashCode method in Java?

  • Answer:
    • The equals method is used to compare the content or value equality of two objects.
    • The hashCode method is used to get a hash code value of an object, which is used in hash-based collections like HashMap.
    • It is recommended that if two objects are equal according to the equals method, their hash codes should be the same.

24. What is the difference between an abstract class and an interface in Java 8 and later versions?

  • Answer:
    • In Java 8 and later, interfaces can have default methods and static methods.
    • Abstract classes can have instance variables, constructors, and non-static methods with or without an implementation.
    • An interface can extend multiple other interfaces, but a class can extend only one abstract class.

25. Explain the concept of the volatile keyword in Java.

  • Answer:
    • The volatile keyword is used to indicate that a variable's value may be changed by multiple threads simultaneously.
    • It ensures that any thread reading the variable sees the most recent modification made by any other thread.
    • It is often used for flags or status variables that are shared among threads.
class SharedResource {
    private volatile boolean flag = false;

    public void setFlag() {
        flag = true;
    }

    public boolean getFlag() {
        return flag;
    }
}





1. Primitive Data Types:

Java has eight primitive data types:

  1. byte (8 bits): Represents a signed 8-bit integer. Range: -128 to 127.

    byte myByte = 10;

  2. short (16 bits): Represents a signed 16-bit integer. Range: -32,768 to 32,767.

    short myShort = 1000;

  3. int (32 bits): Represents a signed 32-bit integer. Range: -2^31 to 2^31 - 1.

    int myInt = 42;

  4. long (64 bits): Represents a signed 64-bit integer. Range: -2^63 to 2^63 - 1.

    long myLong = 123456789L;

  5. float (32 bits): Represents a 32-bit floating-point number.

    float myFloat = 3.14f;

  6. double (64 bits): Represents a 64-bit floating-point number.

    double myDouble = 3.14;

  7. char (16 bits): Represents a 16-bit Unicode character.

    char myChar = 'A';

  8. boolean: Represents a boolean value (true or false).

    boolean myBoolean = true;

2. Reference Data Types:

Reference data types include classes, interfaces, arrays, and enumerations. They are used to create complex and user-defined data types. Unlike primitive data types, these types do not hold the actual data but store the reference (memory address) to the location where the data is stored.

  1. String: Represents a sequence of characters.

    String myString = "Hello, Java!";

  2. Arrays: Containers that hold a fixed number of values of the same type.

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

  3. Classes and Objects: User-defined types that encapsulate data and behavior.

    class MyClass {
    int myValue;
}

MyClass myObject = new MyClass();
myObject.myValue = 42;

  4. Interfaces: Similar to classes but contain abstract methods that concrete classes must implement.

    interface MyInterface {
    void myMethod();
}

  5. Enums: A special data type that consists of a fixed set of constants.

    enum Days {SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY};
Days today = Days.MONDAY;