Abstract class vs Interface

Multiple inheritance:

• Java does not support multiple inheritance through classes to avoid the complexities and ambiguities that can arise from the diamond problem. The diamond problem occurs when a class inherits from two classes that have a common ancestor. Consider the following scenario:

  class A {
      void foo() {
          System.out.println("A");
      }
  }
  
  class B extends A {
      void foo() {
          System.out.println("B");
      }
  }
  
  class C extends A {
      void foo() {
          System.out.println("C");
      }
  }
  
  class D extends B, C { // This is not allowed in Java
  }

• If Java allowed multiple inheritance through classes, and D inherited from both B and C, there would be ambiguity in deciding which version of foo to inherit, as both B and C extend from A with their own implementation of foo. This situation leads to the diamond problem, where the compiler cannot determine the correct method to use, resulting in potential confusion and maintenance issues.

Can a Java class implements 2 interfaces that having same method?

• Yes, it's possible in Java. However, the class must provide an implementation for the method only once, as duplicate method signatures are not allowed. If a class implements two interfaces with the same method signature, it must provide a single implementation for that method.

Object class methods:

• toString(): Returns a string representation of the object. The default implementation returns a string consisting of the class name followed by the "@" character and the object's hashcode.
• equals(Object obj): Indicates whether some other object is "equal to" this one. The default implementation in the Object class compares memory addresses (object references), but it is often overridden in subclasses to compare the actual content.
• hashCode(): Returns a hash code value for the object. The default implementation returns the object's memory address in integer form. It's used in conjunction with the equals method for hash-based collections.
• getClass(): Returns the runtime class of the object. It is commonly used to get the class type of an object at runtime.
• clone(): Creates and returns a copy of the object. To use clone(), a class must implement the Cloneable interface, and its clone method should be overridden.
• notify(), notifyAll(), wait(): These methods are used for inter-thread communication and synchronization. They are related to the Java threading mechanism and are used in conjunction with the synchronized keyword.
• finalize(): Called by the garbage collector before an object is reclaimed. This method can be overridden to perform cleanup operations before an object is garbage collected.

Why do we must override hashCode together with equals?

• Consistency with equals, if two objects are equal then their hash codes must be the same
• Contract for hashCode: The contract for hashCode is that equal objects must have the same hash code. If you override equals without overriding hashCode, you might violate this contract, leading to unexpected behavior when using hash-based collections
• Performance in Hash-Based Collections: Many hash-based data structures, like HashMap and HashSet, use hash codes to distribute objects across buckets. If hashCode is not overridden, objects that are considered equal by your equals implementation might end up in different buckets, leading to inefficient behavior and potential performance issues.
• Example

public class Person {
     private String name;
     private int age;

     @Override
     public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Person person = (Person) obj;
        return age == person.age && Objects.equals(name, person.name);
     }

     // Without overriding hashCode, inconsistent behavior may occur in hash-based collections
     // @Override
     // public int hashCode() {
     //     return Objects.hash(name, age);
     // }
}

public class Main {
   public static void main(String[] args) {
      Person person1 = new Person("John", 25);
      Person person2 = new Person("John", 25);

      System.out.println(person1.equals(person2));  // true

      // Without overriding hashCode, hash-based collections may behave unexpectedly
      // Inconsistent behavior when used as keys in HashMap or elements in HashSet
      // HashMap<Person, String> map = new HashMap<>();
      // map.put(person1, "Value1");
      // map.put(person2, "Value2");
      // System.out.println(map.size());  // Inconsistent behavior: prints 2 or 1 depending on hashCode
   }
} 

What are differences between String s = "abc" and String s = new String("abc")?

• String s = "abc":
  • Creates a string literal "abc" in the string pool.
  • If the string "abc" does not exist in the pool, a new entry is added. Otherwise, the existing reference is reused.
  • The variable s holds a reference to the string literal in the string pool.
• String s = new String("abc"):
  • Creates a new String object in the heap memory using the constructor that takes a String parameter.
  • Regardless of whether the string "abc" already exists in the pool, a new String object is created.
  • The variable s holds a reference to the newly created String object in the heap.

 // Using string literal
 String s1 = "abc";
 String s2 = "abc";
 
 // Using new String()
 String s3 = new String("abc");
 String s4 = new String("abc");
 
 // Checking references
 System.out.println(s1 == s2);  // true (both reference the same string literal in the pool)
 System.out.println(s1 == s3);  // false (different references: literal vs. new String)
 System.out.println(s3 == s4);  // false (different references: two new String objects)

Checked Exception vs Unchecked Exception:

ArrayList vs LinkedList:

ArrayList vs Vector:

• ArrayList and Vector share same properties except when handling concurrency. ArrayList is not synchronized while Vector is synchronized and thread-safe.

HashSet vs LinkedHashSet vs TreeSet:

HashMap vs HashTable: