Why Re-implement Interface

[Tony]

In Java API, we see such code:
public class ArrayList
extends AbstractList
implements List, RandomAccess, Cloneable, Serializable

My question is, why Sub-class still declare to re-implement the same
inteface, since Super-class already implements it?

 

[Mike Schilling]

In Java API, we see such code:
public class ArrayList
extends AbstractList
implements List, RandomAccess, Cloneable, Serializable

My question is, why Sub-class still declare to re-implement the same
inteface, since Super-class already implements it?

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.)

 

[Lew]

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

This is not a Java issue. It's an API issue.

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.

Apparently the API designers didn't want that, so they implemented ArrayList
as a subclass of AbstractList.

 

[Mike Schilling]

This is not a Java issue. It's an API issue.


Apparently the API designers didn't want that, so they implemented
ArrayList as a subclass of AbstractList.

My point is that in Java there's no way to inherit from a class without
making that fact as visible as the class is.

 

[Roedy Green]

My question is, why Sub-class still declare to re-implement the same
inteface, since Super-class already implements it?

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.