{{Short description|Concept in the Java computer programming language}} An '''interface''' in the Java programming language is an abstract type that is used to declare a behavior that classes must implement. They are similar to protocols. Interfaces are declared using the <code>interface</code> keyword, and may only contain method signature and constant declarations (variable declarations that are declared to be both <code>static</code> and <code>final</code>). All methods of an Interface do not contain implementation (method bodies) as of all versions below Java 8. Starting with Java 8, <code>default</code>{{sfn|Bloch|2018}}{{rp|99}} and <code>static</code>{{sfn|Bloch|2018}}{{rp|7}} methods may have implementation in the <code>interface</code> definition.<ref>{{cite web|url=http://docs.oracle.com/javase/tutorial/java/IandI/defaultmethods.html|title=Default Methods|access-date=2014-06-30|archive-url=https://web.archive.org/web/20170523042436/http://docs.oracle.com/javase/tutorial/java/IandI/defaultmethods.html|archive-date=2017-05-23|url-status=dead}}</ref> Then, in Java 9, <code>private</code> and <code>private static</code> methods were added. At present,{{when|date=March 2025}} a Java interface can have up to six different types.{{Clarify|date=March 2025}} Such interfaces exist in C#.
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 {{Javadoc:SE|package=java.lang|java/lang|Object}} (the root class of the Java type system); multiple inheritance of classes is not allowed. However, an interface may inherit multiple interfaces and a class may implement multiple interfaces.
== Overview == 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 <code>Human</code>s and <code>Parrot</code>s as subclasses of a <code>Whistler</code> class. Rather they most likely be subclasses of an <code>Animal</code> class (likely with intermediate classes), but both would implement the <code>Whistler</code> 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 <code>whistler.whistle()</code> will call the implemented method <code>whistle</code> of object <code>whistler</code> no matter what class it has, provided it implements <code>Whistler</code>. In a more practical example, a sorting algorithm may expect an object of type {{Javadoc:SE|java/lang|Comparable}}. Thus, without knowing the specific type, it knows that objects of that type can somehow be sorted.
For example: <syntaxhighlight lang="Java"> interface Bounceable { double pi = 3.1415;
// Note the semicolon // Interface methods are public, abstract and never final. // They are usually meant as prototypes, but default implementations are allowed void setBounce(); } </syntaxhighlight>
An interface: * declares only method headers and public constants. * cannot be instantiated. * can be implemented by a class.{{sfn|Bloch|2018}}{{rp|75}} * cannot extend a class. * can extend several other interfaces.{{sfn|Bloch|2018}}{{rp|87}}
==Usage==
===Defining an interface=== Interfaces are defined with the following syntax (compare to Java's class definition):
[''visibility''] interface '''''InterfaceName''''' [extends ''other interfaces''] { ''constant declarations'' ''abstract method declarations'' '' static method declarations'' }
Example: <syntaxhighlight lang="Java"> public interface Interface1 extends Interface2, Interface3, Interface4; </syntaxhighlight>
The body of the interface contains abstract methods, but since all methods in an interface are, by definition, abstract, the <code>abstract</code> keyword is not required. Since the interface specifies a set of exposed behaviors, all methods are implicitly <code>public</code>.
Thus, a simple interface may be <syntaxhighlight lang="java"> public interface Predator { boolean chasePrey(Prey p); void eatPrey(Prey p); } </syntaxhighlight>
The member type declarations in an interface are implicitly static, final and public, but otherwise they can be any type of class or interface.<ref>{{cite web|url=http://java.sun.com/docs/books/jls/third_edition/html/interfaces.html#9.5|title=The Java Language Specification}}</ref>
===Implementing interfaces in a class=== The syntax for implementing an interface uses this formula:
... implements ''InterfaceName''[, ''another interface'', ''another'', ...] ...
Classes may implement an interface. For example: <syntaxhighlight lang="java"> public class Lion extends Animal implements Predator { @Override public boolean chasePrey(Prey p) { // Programming to chase prey p (specifically for a lion) }
@Override public void eatPrey(Prey p) { // Programming to eat prey p (specifically for a lion) } } </syntaxhighlight> If a class implements an interface and does not implement all its methods, it must be marked as <code>abstract</code>. 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 <code>abstract</code>.
Classes can implement multiple interfaces: <syntaxhighlight lang="Java"> public class Frog extends Animal implements Predator, Prey { // ... } </syntaxhighlight>
Interfaces can share common class methods: <syntaxhighlight lang="Java"> abstract class Animal implements LikesFood, LikesWater { boolean likes() { return true; } } </syntaxhighlight>
However a given class cannot implement the same or a similar interface multiple times: <syntaxhighlight lang="Java"> // Error: repeated interface abstract class Animal implements Shares<Boolean>, Shares<Integer> ... { // ... } </syntaxhighlight>
Interfaces are commonly used in the Java language for callbacks,<ref>{{cite web |last1=Mitchell |first1=John D. |date=1996-06-01 |df=mdy |url=https://www.infoworld.com/article/2077462/java-tip-10--implement-callback-routines-in-java.html |title=Java Tip 10: Implement callback routines in Java |work=JavaWorld |access-date=2020-07-14}}</ref> as Java does not allow multiple inheritance of classes, nor does it allow the passing of methods (procedures) 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.
===Subinterfaces=== Interfaces can extend several other interfaces, using the same formula as described below. For example, <syntaxhighlight lang="java"> public interface VenomousPredator extends Predator, Venomous { // Interface body } </syntaxhighlight> is legal and defines a subinterface. It allows multiple inheritance, unlike classes. <code>Predator</code> and <code>Venomous</code> may possibly define or inherit methods with the same signature, say <code>kill(Prey p)</code>. When a class implements <code>VenomousPredator</code> it will implement both methods simultaneously.
==Examples== Some common Java interfaces are: * {{Javadoc:SE|java/lang|Comparable}} has the method {{Javadoc:SE|name=compareTo|java/lang|Comparable|compareTo(T)}}, which is used to describe two objects as equal, or to indicate one is greater than the other. Generics allow implementing classes to specify which class instances can be compared to them. * {{Javadoc:SE|java/io|Serializable}} is a marker interface with no methods or fields - it has an empty body. It is used to indicate that a class can be serialized. Its Javadoc describes how it should function, although nothing is programmatically enforced
==See also== * Interface (object-oriented programming) * Mixin * Trait (computer programming)
==Citations== {{reflist}}
==References== *{{cite book | title= "Effective Java: Programming Language Guide" |last=Bloch| first=Joshua| publisher=Addison-Wesley | edition=third | isbn=978-0134685991| year=2018}}
==External links== * [http://java.sun.com/docs/books/tutorial/java/concepts/interface.html What Is an Interface?]
Category:Java (programming language) Category:Interfaces Category:Articles with example Java code