Interface (Java)

An interface in the Java programming language is an abstract type that is used to specify a behavior that classes must implement. They are similar to protocols. Interfaces are declared using the interface keyword, and may only contain method signature and constant declarations. All methods of an Interface do not contain implementation as of all versions below Java 8. Starting with Java 8, default and static methods may have implementation in the interface definition. Then, in Java 9, private and private static methods were added. At present, a Java interface can have up to six different types.
Interfaces cannot be instantiated, but rather are implemented. A class that implements an interface must implement all of the non-default methods described in the interface, or be an abstract class. Object references in Java may be specified to be of an interface type; in each case, they must either be null, or be bound to an object that implements the interface.
One benefit of using interfaces is that they simulate multiple inheritance. All classes in Java must have exactly one base class, the only exception being ; multiple inheritance of classes is not allowed. However, an interface may inherit multiple interfaces and a class may implement multiple interfaces.


Interfaces are used to encode similarities which the classes of various types share, but do not necessarily constitute a class relationship. For instance, a human and a parrot can both whistle; however, it would not make sense to represent Humans and Parrots as subclasses of a Whistler class. Rather they would most likely be subclasses of an Animal class, but both would implement the Whistler interface.
Another use of interfaces is being able to use an object without knowing its type of class, but rather only that it implements a certain interface. For instance, if one were annoyed by a whistling noise, one may not know whether it is a human or a parrot, because all that could be determined is that a whistler is whistling. The call whistler.whistle will call the implemented method whistle of object whistler no matter what class it has, provided it implements Whistler. In a more practical example, a sorting algorithm may expect an object of type. Thus, without knowing the specific type, it knows that objects of that type can somehow be sorted.
For example:

interface Bounceable

An interface:

Defining an interface

Interfaces are defined with the following syntax :
interface InterfaceName
Example: public interface Interface1 extends Interface2;
The body of the interface contains abstract methods, but since all methods in an interface are, by definition, abstract, the abstract keyword is not required. Since the interface specifies a set of exposed behaviors, all methods are implicitly public.
Thus, a simple interface may be

public interface Predator

The member type declarations in an interface are implicitly static, final and public, but otherwise they can be any type of class or interface.'''

Implementing interfaces in a class

The syntax for implementing an interface uses this formula:
... implements InterfaceName...
Classes may implement an interface. For example:

public class Lion implements Predator

If a class implements an interface and does not implement all its methods, it must be marked as abstract. If a class is abstract, one of its subclasses is expected to implement its unimplemented methods, though if any of the abstract class' subclasses do not implement all interface methods, the subclass itself must be marked again as abstract.
Classes can implement multiple interfaces:

public class Frog implements Predator, Prey

Interfaces can share common class methods:

class Animal implements LikesFood, LikesWater

However a given class cannot implement the same or a similar interface multiple times:

class Animal implements Shares, Shares...
// Error: repeated interface

Interfaces are commonly used in the Java language for callbacks, as Java does not allow multiple inheritance of classes, nor does it allow the passing of methods as arguments. Therefore, in order to pass a method as a parameter to a target method, current practice is to define and pass a reference to an interface as a means of supplying the signature and address of the parameter method to the target method rather than defining multiple variants of the target method to accommodate each possible calling class.


Interfaces can extend several other interfaces, using the same formula as described below. For example,

public interface VenomousPredator extends Predator, Venomous

is legal and defines a subinterface. It allows multiple inheritance, unlike classes. Predator and Venomous may possibly define or inherit methods with the same signature, say kill. When a class implements VenomousPredator it will implement both methods simultaneously.


Some common Java interfaces are: