Chapter 9
Interfaces
9
Creating Interfaces
An interface is a contract.
Every class that implements the interface
must provide the interface’s defined
methods.
Each class implements the methods
however it sees fit.
A class can implement multiple
interfaces.
9
Declaring the Interface
Similar to a class declaration but uses the
interface keyword
The extends keyword can be used to
extend interfaces.
9
Interface Restrictions
Interfaces:
Cannot have member fields
Can define constants
Cannot have methods with
implementation; all methods in an
interface are implicitly abstract
Cannot be instantiated
Cannot define constructors
9
Implementing Multiple Interfaces:
The Debuggable Interface
Debugging is an important step in the
programming cycle.
One way to debug a program is to display
information about objects and variables
to ensure their validity.
9
Debugging an Interface
In the ball program, seeing information
about each of the objects as the
program runs is helpful.
Ball and Wall classes do not derive from
the same base class (Java does not
support multiple inheritance).
Ball and Wall can implement common
interfaces.
9
The Debuggable Interface
The Debuggable interface defines two
public methods:
displayStatus(String identifier);
displayError(String error);
The interface does not define how to
implement these methods.
Implementation details are left to the
classes.
9
Interfaces vs. Abstract Classes
Use an abstract base class if:
You are trying to create an is a
relationship:
A tree is a plant
A fly is an insect
You do not want to instantiate the base
class.
9
Interfaces vs. Abstract Classes
Use an interface if:
You are not trying to create an is a
relationship.
You are stating that your class has these
capabilities.
A Ball and a Wall have the capability of being
colorable and debuggable.
You need a way to handle multiple
inheritance.
9
Extending Interfaces
Interfaces can be extended just like
classes.
Allows the programmer to provide new
functionality without rewriting existing
code
Use the keyword extends: interface
DebugLogging extends Debuggable
9
Polymorphic Interfaces
Interfaces can be treated
polymorphically, as a type.
A method that accepts an object which
implements the Debuggable interface will
also accept any object which implements
any interface derived from the
Debuggable interface.