As you've
already learned, objects define their interaction with the outside world
through the methods that they expose. Methods form the object's interface
with the outside world; the buttons on the front of your television set, for
example, are the interface between you and the electrical wiring on the other
side of its plastic casing. You press the "power" button to turn the
television on and off.
In its most
common form, an interface is a group of related methods with empty bodies. A
bicycle's behavior, if specified as an interface, might appear as follows:
interface Bicycle {
void
changeCadence(int newValue); // wheel
revolutions per minute
void changeGear(int newValue);
void
speedUp(int increment);
void
applyBrakes(int decrement);
}
To
implement this interface, the name of your class would change (to a particular
brand of bicycle, for example, such as ACMEBicycle), and you'd use the implements keyword in the class
declaration:
class ACMEBicycle implements Bicycle {
//
remainder of this class implemented as before
}
Implementing
an interface allows a class to become more formal about the behavior it
promises to provide. Interfaces form a contract between the class and the
outside world, and this contract is enforced at build time by the compiler. If
your class claims to implement an interface, all methods defined by that
interface must appear in its source code before the class will successfully
compile.
Note:
To
actually compile the ACMEBicycle class, you'll need to add the public keyword to the beginning of the
implemented interface methods. You'll learn the reasons for this later in the
lessons on Classes
and Objects and Interfaces
and Inheritance.
No comments:
Post a Comment