Class 22: Interfaces and Polymorphism

Held: Tuesday, March 1, 2005

Summary: Today we learn how Java's interfaces allow us to separate the general capabilities of our classes from the particular implementations we choose.

Related Pages:

• EBoard.
• Sample Code.

Notes:

• I've made a few changes to the exam, primarily in response to questions from students.

Overview:

• Representing Operations.
• Your first operation: Surround.
• Simplifying things with Java Interfaces.

Representing Operations

• What might we want to do with a chunk of text other than get its contents (which we presumably then display)?
• Here are some ideas:
  • Surround it with some symbol (such as "*")
  • Center it within a particular horizontal area
  • Combine it horizontally with another piece of text
  • Combine it vertically with another piece of text
  • Indent it from the left margin
  • Truncate it
  • Replace portions of it
  • ...
• Traditionally, we would represent these operations as functions
• However, in object-oriented design, it may make more sense to represent them as objects
• For example, for surround, given a chunk of text, we build something that contains the chunk and the lines that surround it.
  • We might call such a class SurroundedText
  • Note that SurroundedText might provide much the same operations as SimpleTextChunk

Interfaces

• Because SurroundedText and SimpleTextChunk have the same operations, we should be able to use them in similar situations.
• In Java, to make it clear that they have the same operations, we design an interface that lists the common operations.
• An interface is much like a class, except
  • Interfaces lack fields and constructors
  • Methods in interfaces lack implementations
  • Interfaces use the keyword interface rather than class
• For example,

  public interface NameOfInterface
  {
  } // interface NameOfInterface
  

• When a class provides all the methods listed in an interface, we say it implements the interface, and we add a note to the class head.

  putlic class ImplementingClass
    implements NameOfInterface
  {
  } // class ImplementingClass
  

• Interfaces give us the easiest form of polymorphism:
  • You can write methods that take interfaces as parameters.
  • You can call those methods with object in any class that implements the interface
• Similar issues apply to variables and fields
  • You can declare variables and fields whose type is an interface
  • You can assign objects in any class that implements the interface to those variables and fields
• We'll build a general TextChunk interface, update both SimpleTextChunk and SurroundedText to use it, and see what happens.