It's useful as documentation.

In fact, in my ideal version of Java, it would be possible to declare that
the fact that ArrayList inherits from AbstractList is an implementation
detail invisible to its clients.   That is, while it's good for client code
to contain

   List<String> l = new ArrayList<String>();

it should never contain

   AbstractList<String>l = new ArrayList<String>();

The maintainer should be completely free to re-implement ArrayList in some
other fashion, if he feels like it, with no fear of breaking client code.
Currently, that's not the case.  (Strictly speaking, this would probably
also require making ArrayList final, since subclasses are often sensitive to
implementation issues.  See http://en.wikipedia.org/wiki/Fragile_base_class 
for a brief description of this problem.)

I do that just to make it clear my new class can be used wherever that
interface is required. It makes it very clear. You don't have to chase
the inheritance tree to discover that fact.  It also makes sure nobody
"unimplements" the interface on the base class without me finding out
next time I compile.

In other words I consider implementing that interface an inherent part
of my class's abilities, not something it inherits
accidentally/incidentally.