Interface inheritance is a mechanism in certain computer languages where specific functions are inherited by a class, and then that particular class must provide implementations for those functions in order to be complete. Interfaces only exist in certain object-oriented programming languages. They can be used to emulate multiple inheritance while not actually allowing a class to multiply inherit, because there are generally no limits to the number of interfaces a class can inherit from. In addition to unimplemented methods, interfaces can also include public constants.
In interface inheritance, the object that inherits method stubs and constants is considered to be a type of interface object. So, if a class X inherited from an interface Y, any instance of the class X would also be an instance of the class Y. This gets more complicated when a class's interface inheritance involves more than one separate interface. For every additional interface that is inherited, the resulting class can be legitimately used as an instance of each. If a class inherited from ten different interfaces, objects of that class could be used as an instance of eleven different objects, including itself.
Such complex inheritance is not often necessary. Interface inheritance is used to ensure that a class has a specific set of required behaviors, and these behaviors enable it to perform a variety of functions that it couldn't otherwise do. A common example of this is the ActionListener interface in Java, which requires a class to implement only one specific method. Successful implementation of this method allows a user to control buttons, menu items, or any other window object in the class if desired. Interface inheritance is a relatively simple way to add complex functionality to a class without worrying about most complicated inheritance issues.
One of the biggest advantages to using interface inheritance is that it allows specific objects to be used in a generic sense. Since a class that implements an interface is an instance of that interface, it can be used any place an instance of that interface is required. For example, if class A implements class C, and class B also implements class C, if a method takes as a parameter an instance of class C, either an instance of class A or an instance of class B would be an acceptable parameter to use. Interfaces cannot be instantiated on their own because they are not complete, so there would never be an object that was purely an instance of class C as a parameter.