I think interfaces will be best explained by a practical example:
Say you need a list. What are the properties of a list? Well, you can add items to it, remove items, check if an item is already in a list, and so on. These are all properties you would expect of a list, so why not define functions or methods to provide this functionality from any list? E.g. (in some sort of pseudo-code):
and so on ...
This is the interface. Now, when you're programming an application that uses a list, instead of defining that you use this particular list you instead define that you're using a list:
Why would you want to do this? Why not just settle with any list and be done with it? Well, no all lists are implemented equally. In some lists you can maybe add items very fast, but it takes a long time to remove an item, or maybe some lists are very space-efficient but costs in execution, and so on.
If you had define to use a particular list and decide that you want to use another list, you would need to replace all occurrences of
AnotherParticularList. If, instead, you had defined them as
List, you would only need to change where you specify which list to use (i.e. instantiations).
Now, some astute colleague of yours maybe wonder "Why don't we just define a list as class and let all other lists inherit from it?" Sure, you could do that, but then you would only be able to define what functions or methods all lists should have, and not any actual functionality which all lists should inherit as each list will be implemented differently. Hence, you would have an abstract class with methods defined, but no functionality, and all subclasses would need to implement those methods. This is precisely what an interface is.
Another important point about using interfaces is when you design a set of library functions which others will use that require them to provide a particular object. The object is required to implement certain functions or methods which will be called within the library functions. If you had provided an abstract class for your API users to inherit, then it becomes difficult if the provided object also needs to inherit from another class (if the language doesn't allow multiple inheritance). If, instead, you only required the object to implement an interface then it's no longer a problem, since a class can always (at least in the languages I've heard of) implement multiple interfaces.