Defining an Interface

Imagine a drawing program where many different shapes need to be painted onto a screen. The drawing code wants to say, simply, stroke this shape with a pen. It does not care whether the shape is a circle, a polygon, or a piece of text. What it needs is a guarantee that every shape it receives knows how to be stroked. Java gives you a construct for writing down that guarantee without writing any of the drawing logic itself. That construct is called an interface.

This article focuses on one question: what does an interface actually contain, and what rules govern the things placed inside it? As you read, keep one idea in mind. The interface describes a promise, and a class is the thing that keeps it.

The word interface is a reserved word in Java. The language reserves it for a specific purpose, so you cannot use it as an ordinary name. The interface lists method headers without giving their bodies, which leaves a gap. Something has to fill that gap, and in this article the gap is filled by a class: the class that implements the interface.

Read the example from the outside in. The keyword interface opens the definition. Inside the braces sits one declaration, stroke, which accepts one Graphics parameter. Notice the semicolon at the end. The declaration has no body, and that is deliberate. The body belongs to whichever class eventually implements Strokeable.

Before reading the rule, make your own prediction. Suppose a class declares that it implements Strokeable, but the class leaves out any code for the stroke method. Think about what the interface promises and what the class has agreed to.

The class header is the line that names the interface the class is promising to satisfy. The reserved word implements carries that promise. The class body then holds the required method together with whatever else the class needs. The source shows the general form of this arrangement, with the body abbreviated and the three dots standing for other members the class may also contain.

Because the class carries the promise, every object created from it carries the promise too. The source defines it this way: an object implements an interface if it belongs to a class that implements that interface. That is why any object of type Line implements Strokeable, and why a Line object carries the stroke() method.

The source contrasts two limits directly. A class is limited to extending one other class, but it has no stated limit on how many interfaces it implements. A header can therefore combine one extends clause with a list of implements names. The source gives the header FilledCircle extends Circle implements Strokeable, Fillable as a valid example. Here FilledCircle inherits from Circle and promises to satisfy both Strokeable and Fillable.

The source is explicit that writing the methods is not enough by itself. A class has to meet two separate conditions. The first is the implements clause in the class header, which states the promise. The second is the method implementations, which means the class defines every instance method the interface declares. Each condition does a different job. Omitting either one means the class does not meet the interface's requirements.

The source recommends walking forward from the interface declaration. Ask whether each declared method has a matching implementation, and whether each constant is being used rather than redefined. The place where that comparison first fails is usually the place to look. Everything after that point may look wrong only because the early mismatch carried forward.

An interface can hold two kinds of members. Method declarations describe behavior that implementing classes must supply. Variable declarations describe fixed values that implementing classes receive. The method branch carries an obligation: every implementing class must provide a body for each method. The variable branch carries a gift: every implementing class can use the variable without declaring it again.

The three declarations above act as constants in everyday terms: each name is tied to one fixed number. The interface works as a container with a method branch and a variable branch. Keeping these two effects separate in your mind is the key to reading interfaces correctly.

Modifiers in an interface follow fixed rules. Every method declared in an interface must be public and abstract, and the source states this explicitly. Variables in an interface are public, static, and final. Because these are the only options available in each case, Java does not require you to write the modifiers. Writing or omitting them changes how the text reads, not what the interface requires.