Core Java Interview Questions

🧾 What Is the Default toString() Implementation in Java?

In Java, every class inherits the toString() method from the Object class.
If we don’t override this method in our own class, the default implementation provided by Object is used.

By default, the toString() method returns a string that includes:

<ClassName>@<Hexadecimal representation of the object’s memory address>

This means:

• The class name of the object.

• Followed by the @ symbol.

• And finally, a hexadecimal value representing the object’s memory reference (derived from its hash code).

🧠 Example

class Car {}

public class ToStringExample {
    public static void main(String[] args) {
        Car car = new Car();
        System.out.println(car.toString());
    }
}

Output:

Car@5e91993f

Here,

• Car → is the class name.

• @ → separates the name and hash.

• 5e91993f → is the hexadecimal form of the object’s hash code.

✍️ Overriding toString()

If you override the toString() method, you can provide a custom, human-readable description of your object:

class Car {
    String model = "Honda";
    int year = 2024;

    @Override
    public String toString() {
        return "Car [model=" + model + ", year=" + year + "]";
    }
}

public class Main {
    public static void main(String[] args) {
        Car car = new Car();
        System.out.println(car);
    }
}

Output:

Car [model=Honda, year=2024]

✅ In short:
The default toString() method returns the class name, followed by @, and the hexadecimal hash code of the object’s memory reference.
When overridden, it can display custom object details, making debugging and logging more meaningful.

⚖️ equals() Method vs. == Operator in Java

This is one of the most commonly asked interview questions in Java — and understanding the difference between == and equals() is crucial when comparing objects.

💡 The == Operator

• The == operator is used to compare references (memory locations) of two objects.

• It checks whether both variables point to the same object in memory.

• Hence, it performs a shallow comparison.

🧠 Example

class User {
    int id;
    String name;

    User(int id, String name) {
        this.id = id;
        this.name = name;
    }
}

public class EqualsVsDoubleEquals {
    public static void main(String[] args) {
        User u1 = new User(1, "John");
        User u2 = new User(1, "John");

        System.out.println(u1 == u2); // false
    }
}

✅ Explanation:
Even though both objects contain the same data, u1 and u2 occupy different memory locations, so == returns false.

💡 The equals() Method

• The equals() method is defined in the Object class, so every Java class inherits it.

• By default, its implementation in Object also performs a reference comparison (same as ==).

• Therefore, if you don’t override it, u1.equals(u2) will also return false in the above example.

To perform a deep comparison (compare contents, not references), you must override equals() in your class.

✍️ Overriding equals()

@Override
public boolean equals(Object obj) {
    if (this == obj) return true;
    if (obj == null || getClass() != obj.getClass()) return false;
    User user = (User) obj;
    return id == user.id && name.equals(user.name);
}

Now, comparing two objects with the same data will return true.

🧩 Special Cases — Strings, Wrappers, and Enums

There are exceptions where equals() is already overridden in the standard library classes to perform content-based (deep) comparison:

✅ Example with String

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

System.out.println(s1 == s2);       // false (different objects)
System.out.println(s1.equals(s2));  // true (content is same)

✅ Example with Wrapper Types

Integer i1 = new Integer(123);
Integer i2 = new Integer(123);

System.out.println(i1 == i2);       // false (different objects)
System.out.println(i1.equals(i2));  // true (compares values)

✅ Example with Enums

enum Day { MONDAY, TUESDAY }

System.out.println(Day.MONDAY == Day.MONDAY);       // true
System.out.println(Day.MONDAY.equals(Day.MONDAY));  // true

Enums are unique instances, so both comparisons return true.

🧠 Summary

try {
    int result = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println("Exception caught");
} finally {
    System.out.println("Finally block executed");
}

Exception caught
Finally block executed

try (FileReader reader = new FileReader("data.txt")) {
    // use file
} catch (IOException e) {
    e.printStackTrace();
}
// No need for finally block — resource auto-closed

@Override
protected void finalize() throws Throwable {
    System.out.println("Finalize method called before GC");
}

List employeeIds = new ArrayList();
employeeIds.add(101);
employeeIds.add("John"); // ❌ No compile-time error!

Integer id = (Integer) employeeIds.get(1); // Runtime error: ClassCastException

List<Integer> employeeIds = new ArrayList<>();
employeeIds.add(101);
employeeIds.add("John"); // ❌ Compile-time error

List<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");

for (String name : names) {
    System.out.println(name.toUpperCase());
}

List<Integer> ids = new ArrayList<>();
ids.add(10);

// After type erasure, JVM sees it as:
List ids = new ArrayList(); // Generic info removed