Question

Possible Duplicate:
Java.util.HashMap — why HashMap extends AbstractMap and implement Map?

In java to implement HashMap<K,V> we need to implement Map<K,V>.

However when I debugged more in java classes it seems that…. java defines HashMap class as following.

public class HashMap<K,V>
extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable

At the same time i saw public abstract class AbstractMap<K,V> implements Map<K,V> it also implements the interface Map<K,V>.

If abstract class implements the interface then, what is the reason behind implementing Map<K,V> at HashMap class level?

As per my understanding HashMap class have all the methods inherited from AbstractMap which can be overridden by HashMap as per the requirement.

Answer 1

I believe the reasoning behind this is an abstract class in Java need not declare/implement all the methods in the interface.
Thus

public interface MyInterface{
  void a();
  void b();
  void c();
}

the following abstract implementation of the interface is valid.

public abstract class AbstractClass implements MyInterface {
  public void a() {}
  public void c() {}
  public void d() {}
}

Thus I believe in order to be explicit about HashMap implementing the methods not implemented by the abstract class it is shown to implement the interface Map whereas it is completely optional to do so because any implementation of the abstract class needs to implement all the methods either in the abstract class or the derived base class..
Thus in the above example a valid implementation to the abstract class is

public class MyClass extends Abstract{
      public void a() {}
      public void c() {}
      public void b() {}  //if you dont implement this, compile error
      public void d() {}
    }

which you can rewrite as follows too:

public class MyClass extends Abstract implements MyInterface {
      public void a() {}
      public void c() {}
      public void b() {}
      public void d() {}
    }