Contents - Cultural View

Interface (Java) 140
Interface (Java)
An interface in the Java programming language is an abstract type that is used to specify an interface (in the generic
sense of the term) that classes must implement. Interfaces are declared using the interface keyword, and may only
contain method signatures and constant declarations (variable declarations that are declared to be both static and
final). An interface may never contain method definitions.
As interfaces are implicitly abstract, they cannot be directly instantiated except when instantiated by a class that
implements the said interface. The class must implement all of the methods described in the interface, or be an
abstract class. Object references in Java may be specified to be of an interface type; in which 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 (other than
java.lang.Object, the root class of the Java type system) must have exactly one base class; multiple inheritance of
classes is not allowed. Furthermore, a Java class may implement, and an interface may extend, any number of
interfaces; however an interface may not implement an interface.
Overview
Interfaces are used to encode similarities which 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 (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. In a more practical
example, a sorting algorithm may expect an object of type Comparable. Thus, it knows that the object's type can
somehow be sorted, but it is irrelevant what the type of the object is. The call whistler.whistle() will call the
implemented method whistle of object whistler no matter what class it has, provided it implements Whistler.
For example:
interface Bounceable
{
void setBounce(); // Note the semicolon:
implementations are allowed.
}
Usage
Defining an interface
// Interface methods are public and abstract.
// Think of them as prototypes only; no
Interfaces are defined with the following syntax (compare to Java's class definition):
[visibility] interface InterfaceName [extends other interfaces] {
}
constant declarations
member type declarations
abstract method declarations