# Java Notes

# Class or Interface

## Declare variables as class or interface type?

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 `x` is

    ArrayList x = new ArrayList(); // OK

But if `x` only uses the methods defined in the `List` interface, it would be better to do the following.

    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.

## Why change the underlying class?

The two `List` classes, `ArrayList` and `LinkedList` both implement the same `List` interface 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 a `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 (`List`, `Map`, and `Set` for the Collections classes).