A common programming philosophy is to declare variables with a type that
makes the least assumptions. This allows flexibility
to make changes in the underlying type if this latter becomes necessary.
For example, the most obvious way to declare
ArrayList x = new ArrayList(); // OK
x only uses the methods defined in the
List interface, it would be better to do the
List x = new ArrayList(); // More flexible
This guarantees that
x doesn't use any methods
that aren't in the
List interface. The advantage
of this is that later the underlying implementation can be changed.
List x = new LinkedList(); // Changed underlying class
Because the performance characteristics of ArrayList and LinkedList are so different, it is probably not all that likely to make such a drastic change. You can also write your own data structure or use one of many externally defined List data structures which implement the List interface.
LinkedList both implement the same
methods and can be manipulated by the methods in the
Collections class, but the performance of
different operations may be very different, eg, insertion
in the middle of an
LinkedList is more efficient,
but accessing a random element is more efficient using
ArrayList. If it becomes necessary to
change the underyling class for performance reasons,
it is easy to do if variables are declared by their interfaces
for the Collections classes).