Why interfaces?

Question

I have difficulties in understanding why would I use an interface if I wanted to communicate between two (or more) classes.
Because the interface is by definition abstract, every class implementing the interface has to accept all of its methods (if not declaring itself abstract as well). I only mention this because I understand it, to get to what I don't:
Why would I want to communicate between classes with an interface, if I can do it without? Each class only shares the name of a method in an interface, nothing more. (Is this so?)
If I wanted to execute a series of commands (a method) from another class by calling a method implemented from an interface, how could I do this through an interface? It seems I cannot, while I thought this was the reason to implement interfaces in the first place.
Please clear my scrambled thoughts.

Answer 1

Hi bec!
I have exactly the same problem understanding the
interface concept. I still don't get it from
DanPerkins' code example; if you remove the interface
definition, and the implements bit out of each of the
classes, the code still works. So what's the added
value of the interface. Also, code to turn the tv on
is not the same as to turn on the stereo, so there
isn't any code reuse either. Confused.You use interfaces to keep your classes from having intimate knowledge of each other. Say you're writing code to operate a register/scanner at a grocery store. Everytime your store gets a new kind of item in inventory, you don't want to have to update your class to handle the new item.
class Register {
  double scan( Banana b ) {
    return b.getPrice();
  double scan( Rice r ) {
    return r.getPrice();
  // etc., etc.
}This approach means that Register is tied at the hip to every food item class in the store. Isn't it much nicer to write Register this way:
interface BuyableItem {
  double getPrice();
class Banana implements BuyableItem {
  double getPrice() {
    return this.getWeight() * this.getUnitPrice();
class Rice implements BuyableItem {
  double getPrice() {
    return this.getCost();
class Register {
  // Handle the item generically.
  //  This way if there's special logic to finding
  //  the price, like it's on special this week, or
  //  it's an item that gets priced by the pound,
  //  the Register class doesn't care.  That implementation
  //  is left to the BuyableItem.
  double scan( BuyableItem item ) {
    return item.getPrice();
public static void main( String[] args ) {
  // Refer to each food by interface
  BuyableItem banana = new Banana();
  BuyableItem rice = new Rice();
  Register reg = new Register();
  double totalCost = 0;
  totalCost += reg.scan( banana );
  totalCost += reg.scan( rice );
  System.out.println( "Total cost is: " + totalCost );
}Interfaces become important when you maintain your code for a while and suddenly discover that you have to add support for a new object.