Why do we use Interface?

Purposes of Interfaces

• create loosely coupled software
• support design by contract (an implementor must provide the entire interface)
• allow for pluggable software
• allow different objects to interact easily
• hide implementation details of classes from each other
• facilitate reuse of software

Analogy 1: Much like the US space shuttle, Russian Soyuz spacecraft and Chinese Shenzhou 5 can all dock to the International Space Station, because they implement the same docking interface. (This is the just an example – I don’t know if it’s true in real life however let’s suspend our disbelief for the sake of an example)
Analogy 2: Like you can plug various computer monitors into your home computer. You can plug a wall-size TV into it, an old CRT (the thick kind), a 20″ flat screen, or a braille machine for the blind to “see” by touch. There’s compatibility among these various/different devices and your computer because they all agree on interface standards.

http://stackoverflow.com/questions/2026054/why-do-we-use-interface-is-it-only-for-standardization

When should one use interfaces?

In languages such as Java and C# interfaces provide a means for a class to be have in a polymorphic manner. That is to say a class can satisfy more than one contract – it can behave as multiple different types, a class of one type can be substituted for another. In other languages this can also be provided by multiple inheritance, but there are various disadvantages to this approach. However, having a class behave as more than one type is not the most common motivation for using interfaces.

By programming to interfaces instead of classes you can also decouple your program from specific implementations. This makes it much easier to substitute one class implementation for another. This is particularly useful when writing unit tests where you may wish to swap some heavyweight class implementation with a lightweight mock object. If your program only expects an interface type, and both the heavyweight object and mock object implement said interface, then they are very easy to substitute.

Also, consider a simple Java example where I say have a program that displays pages of data on the screen. Initially I want it to get the data from a database or XML files. If I write my program so that it uses interfaces I can define an interface like so:

public interface PageDatasource { public List getPages(); }

And use it like so:

PageDatasource datasource = // insert concrete PageDatasource implementation here List pages = datasource.getPages(); display(pages);

I can then write separate database and XML implementations that adhere to this interface:

public class DatabasePageDatasource implements PageDatasource { public List getPages() { // Database specific code } } public class XmlPageDatasource implements PageDatasource { public List getPages() { // XML specific code } }

Because I used an interface I can now use either implementation – Database or XML – interchangeably without having to change the parts of my program that ask for the page data. The XML and Database implementations likely do completely different things but all my program cares about is that the object supplying the page data implements the PageDatasource interface.

http://stackoverflow.com/questions/1686174/when-should-one-use-interfaces