Interface (Java)
An interface in the
static
and final
). All methods of an Interface do not contain implementation (method bodies) as of all versions below Java 8. Starting with Java 8, default
[1]: 99 and static
[1]: 7 methods may have implementation in the interface
definition.[2]private
and private static
methods were added. At present, a Java interface can have up to six different types.
Interfaces cannot be
One benefit of using interfaces is that they simulate
java.lang.Object
(the root class of the Java type system); multiple inheritanceOverview
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 Human
s and Parrot
s as subclasses of a Whistler
class. Rather they most likely be subclasses of an Animal
class (likely with intermediate classes), 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 Comparable
. Thus, without knowing the specific type, it knows that objects of that type can somehow be sorted.
For example:
interface Bounceable {
double pi = 3.1415;
void setBounce(); // Note the semicolon
// Interface methods are public, abstract and never final.
// Think of them as prototypes only; no implementations are allowed.
}
An interface:
- declares only method headers and public constants.
- cannot be instantiated.
- can be implemented by a class.[1]: 75
- cannot extend a class.
- can extend several other interfaces.[1]: 87
Usage
Defining an interface
Interfaces are defined with the following syntax (compare to
[visibility] interface InterfaceName [extends other interfaces] { constant declarations abstract method declarations static method declarations }
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 {
boolean chasePrey(Prey p);
void eatPrey(Prey p);
}
The member type declarations in an interface are implicitly static, final and public, but otherwise they can be any type of class or interface.[3]
Implementing interfaces in a class
The syntax for implementing an interface uses this formula:
... implements InterfaceName[, another interface, another, ...] ...
public class Lion 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)
}
}
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
abstract
.
Classes can implement multiple interfaces:
public class Frog implements Predator, Prey { ... }
Interfaces can share common class methods:
class Animal implements LikesFood, LikesWater {
boolean likes() { return true; }
}
However a given class cannot implement the same or a similar interface multiple times:
class Animal implements Shares<Boolean>, Shares<Integer> ...
// Error: repeated interface
Interfaces are commonly used in the Java language for
Subinterfaces
Interfaces can extend several other interfaces, using the same formula as described below. For example,
public interface VenomousPredator extends Predator, Venomous {
// Interface body
}
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(Prey p)
. When a class implements VenomousPredator
it will implement both methods simultaneously.
Examples
Some common
Comparable
has the methodcompareTo
, 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.Serializable
is amarker interface with no methods or fields - it has an empty body. It is used to indicate that a class can be serialized. Its Javadocdescribes how it should function, although nothing is programmatically enforced
See also
Citations
- ^ a b c d Bloch 2018.
- ^ "Default Methods". Archived from the original on 2017-05-23. Retrieved 2014-06-30.
- ^ "The Java Language Specification".
- JavaWorld. Retrieved 2020-07-14.
References
- Bloch, Joshua (2018). "Effective Java: Programming Language Guide" (third ed.). Addison-Wesley. ISBN 978-0134685991.