Re: Default Interfaces: possible Java extension?

A commonly held principle for good programming is that we should
minimize dependencies on details of the implementation. One way to do
that in Java is with statements like:

     List<String> names = new ArrayList<String>();
vs
     ArrayList<String> names = new ArrayList<String>();

where the variable we use to hold the object has a type which only
allows (absent casts or reflection) use of the general contract for
List's without any visibility into the details of ArrayList's
implementation.

Here's a thought I've had for a small extension to Java that would
take this a little further. In the first example above, even though
we don't worry about the implementation after we get our list, we did
have to explicitly pick one kind of list. So...

Add a new optional element in the definition of an interface which
defines a class that does the default implementation of the
interface. E.g.,

     interface List<T> default ArrayList<T> { ...}

An interface which has a default may be used in a constructor as:

    List<String> name = new List<String>();

When this happens, the default class for the interface is substituted
at compilation time. If there is no default, or it is not accessible
then this is a compile time error.

This should be fully upwardly compatible, invalidating no existing
code. I don't think it would be hard to implement (e.g., a special
static field in the interface's class file) and it allows more
isolation of code from implementation. It also allows a programmer to
document a preferred implementation.

It always seems a bit odd when I'm writing code when I have to import
ArrayList and use that class just the one time. It seems like code
could be a bit cleaner using this extension.

Are there other ways to do this? A factory method requires knowing
the class the factory resides in and I can't really think of other
patterns that address this. E.g., one could add
newSet(), newList() and newMap() methods to Collections but that's not
especially elegant to my eye since there's no special language
relation between the List interface and the Collections class.