Class 09: Subclassing, Inheritance, and Polymorphism

Held Thursday, September 9, 1999

Overview

Today we will begin to disucss the architecture of our email system. That consideration will lead us to consider three key aspects of object-oriented programming: inheritance, polymorphism, and interfaces.

Notes

• Are there any questions on assignment 1?
• For tomorrow, read lab J4.

Contents

• Project Components
  • A Mailbox Class
  • Using the Mailbox Class
• What is object-oriented programming?
• Inheritance
  • Extending our Mailbox
• Polymorphism

Handouts

Summary

• Project discussion: project components
  • The design of a Mailbox class
• Some notes on object-oriented design
• Two key features: inheritance and polymorphism

Project Components

This discussion of the project was added after class and is based on comments from in class.

• As we begin to build our mail client, we need to think about the various classes and objects that will make up its components.
• Our client will need to talk to two kinds of servers:
  • A ``mail storage server'' holds users' mail messages.
  • A ``outgoing mail server'' accepts new messages (which it may convey to the local mail storage server or send out on the Internet).
• Since both of those servers are already in place, we simply need to design objects that can talk to them.
  • A Mailbox talks to the mail storage server.
  • A Sender talks to the outgoing mail server.
• By designing such objects, we simplify the rest of our program: nothing else needs to know how to communicate with servers; other objects need only use the ``server objects''.
• Often, we'll want to move the messages into different Folders.
  • We need a main folder, which we might call the inbox.
  • We'll need a special trash folder.
  • Users might create others.
• Before displaying messages in a folder, one might want to use a Sorter to organize them or a Filter to select only some,
• We will create user interfaces for all of these parts.
  • A textual user interface might serve as a substitute for dreams or pine.
  • A graphical user interface will serve as the replacement for everything else.
• We still need to decide what objects belong to each interface.
• We will use a Composer to compose new messages.
• We may want an AddressBook class (which may somehow communicate with the address book on the server).
• We may want a FaceBook class so that we can display peoples' pictures when we receive messages from them.
• I'm sure we'll come up with others.

A Mailbox Class

• For today, we'll consider the simplest possible design of the Mailbox class. What methods should that class provide?
• We've decided that it makes sense to provide an account and a password when we first create a Mailbox. That way, we get the mailbox for a particular person. We also handle the question of how to get the password and account to the class.

  public Mailbox(String account, String password) { ... }
  

• We've decided to allow the client to get lists of messages from the server. These lists will include sender, subject, date, and message-id for each message. (Later, we may decide on more.)

  public MessageInfoList listMessages() { ... }
  

• Once the client has a list of messages, it needs to be able to get individual messages.

  public MailMessage getMessage(String messageID) { ... }
  

• The client may also delete messages.

  public void deleteMessage(String messageID) { ... }
  

• Finally, we realized that it's important to check for errors. (What if we tried to create the mailbox with an illegal account or password?)

  public void isValid() { ... }
  

  • Next Wednesday, we'll find a more elegant wway to do this.
• Putting it all together ...

  
  import MailMessage;
  import MessageInfoList;
  
  /**
   * A simple implementation of mailboxes (one that doesn't really work).
   * Created as an example for CSC152 99F.
   *
   * @author Samuel A. Rebelsky
   * @author The students of CSC152 99F
   * @version 1.0 of September 1999
   */
  public class Mailbox {
    // +--------------+--------------------------------------------
    // | Constructors |
    // +--------------+
  
    /** 
     * Create a new mailbox for a particular user.  Requires the
     * account and password for obvious reasons.
     */
    public Mailbox(String account, String password) {
      // ...
    } // Mailbox(String, String)
  
    // +---------+-------------------------------------------------
    // | Methods |
    // +---------+
  
    /** List all the messages in the mailbox. */
    public MessageInfoList listMessages() {
      return new MessageInfoList(); // STUB
    } // listMessages()
  
    /** Get one message. */
    public MailMessage getMessage(String messageID) {
      return new MailMessage(); // STUB
    } // getMessage(String)
  
    /** Delete a message. */
    public void deleteMessage(String messageID) {
      return; // STUB
    } // deleteMessage(String)
  
    /** Check if the mailbox is valid. */
    public boolean isValid() {
      return true; // STUB
    } // isValid()
  } // class Mailbox
  
  
  
  

• While there are other features we might add, we'll leave those until later.

Using the Mailbox Class

• Now that we've described the functionality of the class, we can start to use the class. (Someone else will be responsible for implementing the class.)
• Suppose we want to print out all someone's messages. What might our program look like?

  
  import Mailbox;
  import MailMessage;
  import MessageInfoList;
  import SimpleInput;
  import SimpleOutput;
  
  /**
   * A simple controlling class to print out the contents of a
   * user's mailbox.
   *
   * @author Samuel A. Rebelsky
   * @author The Students of CSC152 99S
   * @version 1.0 of September 1999
   */
  public class MailDumper {
    public static void main(String[] args) {
      // Prepare for input and output.
      SimpleInput eyes = new SimpleInput();
      SimpleOutput pen = new SimpleOutput();
      // Other necessary variables.
      String account;    // The user's account.
      String password;   // The user's password.
      Mailbox mail;      // The mailbox we create.
      MessageInfoList messages;
                         // A list of messages in that mailbox.
      MailMessage msg;   // One mail message.
  
      // 1. Get the account and password.  Note that we eventually
      // need to update this so that the password is not visible.
      pen.print("Account: "); 
      account = eyes.readString();
      pen.print("Password: "); 
      password = eyes.readString();
  
      // 2. Create the mailbox.
      mail = new Mailbox(account, password);
  
      // 3. Ensure that the mailbox was correctly created.  If not,
      // crash and burn, but in a friendly way.
      // ...
  
      // 4. Get the list of messages
      // ...
  
      // 5. For each message in that list
      // ...
         // a. Get the full message
         // ...
         // b. Print it out
         pen.println(msg.toString());
  
    } // main(String[] args)
  } // class MailDumper
  
  
  
  

What is object-oriented programming?

• What is object-oriented programming? You've begun to see some aspects.
  • Programming with objects and classes.
  • Objects join data and functionality
  • Objects hide much of their internal structure, thereby separating the ``interface'' from the ``implementation''
• But there are many other typical characteristics of object-oriented langauges.
• The two most important ones are inheritance and polymorphism.
  • You'll find different definitions for the two, but we'll work on some today.
• Both of these are intended to support reuse.

Inheritance

• Java, like most object-oriented languages, lets you subclass existing classes to refine their functionality for particular instances.
• For example, we might have a general DrawableObject class and refine that to particular drawable objects, such as Circle or Square.
• How do you indicate that one class is a subclass of another? With the extends keyword.

  public class Circle 
    extends DrawableObject {
    ...
  } // Circle
  

• A subclass inherits all the methods and fields of its superclass (with some restrictions due to protection mechanisms).
  • That is, it can use those methods and fields without explicitly defining or declaring them.
• A subclass may also override any of these methods by including its own definition.
  • That is, if a class defines any methods with the same name and argument types as the superclass, then that method is used instead.
• Inheritance is used in two ways. First, it's used to automatically provide some core functionality. In addition, it's used guarantee the functions an object will provide. Since an object inherits all of the ancestors methods, someone using the object knows that they will all be available.
• Java allows you to use a member of a subclass anywhere a member of a superclass is permitted. For example, it is perfectly valid to write:

  DrawableObject obj = new Circle();
  

• Similarly, if you write a function that uses a superclass, you can pass in a member of the subclass.

    public void drawWithStrangeColors(DrawableObject obj) {
      ...
    } // drawWithStrangeColors(DrawableObject)
    ...
      drawWithStrangeColors(new Circle());
  

• Java is much more restrictive on using members of superclasses in place of members of subclasses.
• Why do you think Java has these restrictions?
• Note that if you do not provide an extends clause, Java assumes that your object extends java.lang.Object.
• Java permits only single inheritance -- a particular class can only directly derive from one other class.
  • In the alternative, multiple inheritance -- a particular class can directly derive from more than one other class.
  • Single inheritance makes analysis and design much easier. Otherwise, there are potential problems with the same method name being defined in both parent classes.
  • Java provides interfaces to support many of the needs of multiple inheritance.

Extending our Mailbox

• We can use subclassing and inheritance as we try to build more usable and useful mailboxes. For example, we might want to select only messages meeting a certain pattern or only messages since a particular date.
• We'll call that a FilteredMailbox.

  
  import Mailbox;
  
  /**
   * An improved mailbox that knows how to filter messages.
   */
  public class FilteredMailbox
    extends Mailbox
  {
    /**
     * Build a new filtered mailbox using an account and password.
     */
    public FilteredMailbox(String account, String password) {
      super(account, password);
    } // FilteredMailbox(String, String)
  
  } // class FilteredMailbox
  
  
  

Polymorphism

Forthcoming.