There is nothing more frustrating than attempting to do a teeny little code change in the back-end and discovering your teeny little code change actually requires changes in 50 different classes all accross the board because someone failed to utilize an interface when they wrote the original code.

Interfaces are your friend. It's good to use them, really.

One thing they do quite well is hide the implementation from the calling classes. Why is that good? Well, when you want to change the implementation you don't have to change the calling classes.. Saves time, saves work, saves QA resources, code is more readable, more versatile and easier to maintain.

Perfect example of when you really should use an interface...

ArrayList (java.util package).. it's a nifty class.. handy, useful, used a lot and it implements the List interface (same package). Imagine you wrote a class at one point that retrieves some data from the database and returns it in the form of an ArrayList. Like so..

public ArrayList getStuff(int id) {
   ArrayList rval = new ArrayList();
   // magical code that gets the stuff
   return rval;
}

Simple, easy, dependable.. but there is a better way! Have you guessed yet? That's right.. an interface!

public List getStuff(int id) {
   List rval = new ArrayList()
   // magical code that gets the stuff
   return rval;
}

What was accomplished here? If at some point you decide you want to use, say, a LinkedList instead of an ArrayList because it happens to be more efficient for the particular purpose you use the results for, the only place you need to change the code is in this little method. Neat, no?

How do you know when a class implements an interface you could use? Javadocs!

Interfaces have many other benefits, but this is the particular one that I somehow wanted to write about today.. no reason, really..