Class 15: Arrays and Sequences

Held Monday, September 20, 1999

Overview

Today, we will consider Java's built-in array type, which lets you build simple indexed collections of objects. We will compare arrays to Scheme's lists and vectors and then use arrays to build a better version of the MailMessage class.

Notes

• I've graded assignment 1.
  • Some Notes on that assignment are now ready. I'd encourage you to read them.
  • We'll spend a little bit of time talking about commenting styles.
• A set of notes on assignment 2 are also ready.
• Are there any questions on exam 1?
• Some time in the next few weeks, I'll be getting the copy-edited version of the manuscript for Experiments in Java. This will be my last opportunity to make updates.
  • Send me comments.
  • Let me know if you'd like to be listed explicitly in the acknowledgements section.
• Don't forget: get groups and intended subprojects to me by Wednesday.

Contents

• Interfaces, Concluded
  • Abstract Classes
• Collections
  • Scheme: Lists and Vectors
• Arrays
• The Command Line
• Your MailMessage Class, Revisited

Handouts

• Notes on assignment 1
• Notes on assignment 2

Summary

• Interfaces, concluded
• Arrays in Java
  • Related Scheme types: lists and vectors
  • Command-line parameters
• Short lab: Command-line parameters
• Using arrays in our MailMessage class.
• Due: Lab J6
• Assignment: Read Lab G1 for Wednesday.

Interfaces, Concluded

• Summary: Interfaces provide a way for you to gather methods (but not fields or constructors) without the corresponding implementation.
  • Different implementations can then exist for the same methods.
• Consider the following interface for complex numbers:

  
  /**
   * Complex numbers.  Created as an interface because there are
   * different ways to implement them.
   *
   * @author Samuel A. Rebelsky
   * @version 1.0 of September 1999
   */
  public interface Complex {
    /** Set the value to a + bi. */
    public void setValue(double a, double b);
    /** Get the real part. */
    public double getReal();
    /** Get the imaginary part. */
    public double getImaginary();
  } // interface Complex
  
  
  

• One way to implement complex numbers would be to list the two parts (that is, the real and imaginary parts).
• Of course, it is also possible to implement complex numbers using an angle and a radius. The particular implementation is left as an exercise.
• Here's the first class.

  
  import Complex;
  import Drawable;
  import java.awt.Graphics;
  
  /**
   * An implementation of complex numbers.  See the corresponding
   * interface for more details.  
   *
   * Each complex number is represented with its real part and its
   * imaginary part.
   *
   * @author Samuel A. Rebelsky
   * @version 1.0 of September 1999
   */
  public class StandardComplex 
    implements Complex, Drawable
  {
    // +--------+--------------------------------------------------
    // | Fields |
    // +--------+
  
    /** The real part of the number. */
    public double realPart;
    /** The imaginary part of the nubmer. */
    public double imaginaryPart;
  
    // +--------------+--------------------------------------------
    // | Constructors |
    // +--------------+
  
    /**
     * Build the complex number 0.0 + 0.0i.
     */
    public StandardComplex() {
      this.realPart = 0.0;
      this.imaginaryPart = 0.0;
    } // StandardComplex()
  
    // +---------+------------------------------------------------- 
    // | Methods |
    // +---------+
  
    /** Draw the complex number as a vector. */
    public void draw(Graphics pen) {
      // Not yet implemented.
    } // draw(Graphics)
  
    /** Set the value to a + bi. */
    public void setValue(double a, double b) {
      this.realPart = a;
      this.imaginaryPart = b;
    } // setValue(double,double)
  
    /** Get the real part. */
    public double getReal() {
      return this.realPart;
    } // getReal()
  
    /** Get the imaginary part. */
    public double getImaginary() {
      return this.imaginaryPart;
    } // getImaginary()
  } // class StandardComplex
  
  
  
  

• As this example shows, one nice aspect of interfaces is that a class can implement more than one interface (while it can only inherit from one subclass).
• The StandardComplex class also implements Drawable

  
  import java.awt.Graphics;
  
  /**
   * Things that can draw themselves on the screen.
   *
   * @author Samuel A. Rebelsky
   * @version 1.0 of September 1999
   */
  public interface Drawable {
    /** Draw the object using a graphics pen. */
    public void draw(Graphics pen);
  } // interface Drawable
  
  
  

• Unfortunately, Java places some fairly severe limits on interfaces
  • No static methods
  • No fields
  • No constructors
  • No inheritance (obviously)

Abstract Classes

• As a compromise, Java also supports abstract classes which can provide fields, static methods, constructors, and inheritance.
• You don't need to provide bodies for any methods. The subclasses must then fill them in. (You must indicate that these methods are abstract.)
• However, you can only inherit from one abstract class.
• You cannot make static methods abstract.

Collections

• When writing programs, we often need to refer to groups or collections of things in such a way that we can easily extract an element of the group.
  • Surprisingly, there is no common term in the computer science lexicon for ``data structure used to collect things''
• Eventually, you will build your own data types for particular kinds of collections and groups.
• But you will also take advantage of some built-in and library types that Java provides.
  • The built-in array (similar to the Vector in Scheme).
  • Library classes Hashtable and Vector

Scheme: Lists and Vectors

• In Scheme, you saw two primitive kinds of collections: lists and vectors.
  • How are they similar?
  • How are they different?
• Note that there is significant controversy on the use of the term ``vector'' to name the second data type.

Arrays

• Java provides a structure called the array that makes it easy to create particular kinds of collections.
• Arrays are fixed-sized collections of elements that you can index by number.
  • When you create an array, you must specify its length in advance.
  • Array indices range from 0 to length-1.
  • Arrays are somewhat homogeneous: all the elements are of the same type (or a subclass of the same type).
• You can declare arrays of a particular size with

  type[] name = new type[size];
  

  • For example, to create a collection of five numbers named stuff, you would write

    double[] stuff = new double(5);
    

• You can also fill in arrays when you create them. To do this, you would write

  type[] name = { val1, val2, ..., valn };
  

  • For example, to create an array with the values 3, 2, 6, and 5, I would write

    int[] stuff = {3, 2, 6, 5};
    

• You can refer to a particular element of an array with name[index]
• For example, I could element 3 of the stuff with stuff[3]
• You can also use variables (or even expressions) as indices. For example, if i held the value 3, then we could get element 3 of the stuff with stuff[i]
• You can always determine the number of elements in an array with name.length
• Once we have values in arrays, it's "easy" to do general computations with them. Here is a method that sums the values in an array.

  public double sum(double[] stuff) {
    double total = 0;	// The total of the numbers in stuff
    int i;		// A counter variable for stepping through
           // the array
    // Step through the array, adding each subsequent value
    for(i = 0; i < stuff.length; i = i + 1) {
      total = total + stuff[i];
    }
    // Return the total value
    return total;
  } // sum
  

The Command Line

• ``Hey!'', you may have just noted, ``that String[] args that I always write is an array of strings''.
  • ``But where does the array come from?''
• It seems that the designers of Java were at least partially rooted in the Unix world. As you've noted, most Unix commands can be followed by their own parameters.
• In Java, these parameters are passed to main as an array of strings.
• Here's a simple program to print out all the parameters, one at a time.

  
  import SimpleOutput;
  
  /**
   * Print out the parameters.  Used as an example of arrays, loops,
   * and paramter lists in Java.
   */
  public class PrintParams {
    public static void main(String[] args) {
      SimpleOutput out = new SimpleOutput();
      // Print out the number of parameters. 
      if (args.length == 0) 
        out.println("There are no parameters.");
      else if (args.length == 1)
        out.println("There is one parameter.");
      else
        out.println("There are " + args.length + " parameters.");
      for (int i = 0; i < args.length; ++i) {
        out.println(i + ": " + args[i]);
      }
    } // main(String[])
  } // class PrintParams
  
  
  

• You might try the following

  % /home/rebelsky/bin/ji PrintParams
  % /home/rebelsky/bin/ji PrintParams Hello
  % /home/rebelsky/bin/ji PrintParams Hello World
  % /home/rebelsky/bin/ji PrintParams "Hello World"
  % /home/rebelsky/bin/ji PrintParams 'Hello World'
  % /home/rebelsky/bin/ji PrintParams Hello-World
  % set foo = salad
  % /home/rebelsky/bin/ji PrintParams $foo bar
  % /home/rebelsky/bin/ji PrintParams "$foo bar"
  % /home/rebelsky/bin/ji PrintParams '$foo bar'
  % /home/rebelsky/bin/ji PrintParams ls
  % /home/rebelsky/bin/ji PrintParams `ls`
  

• Many of the special things that you see happening have to do with how the Unix shell interprets the three kinds of quotes and then passes things along to Java.

Your MailMessage Class, Revisited

• I may ask some of you to take the board (and even lead discussion) during this part of class.
• Let us consider how arrays might help us as we build an improved version of the MailMessage class.
• Instead of starting with the fields and working from there, let's consider the methods we might expect a MailMessage to provide.
• Here are some that I'd like to see ...
  • setXXX and getXXX where XXX includes: Date, Subject, Sender, and ReplyTo.
    • An alternative is something like a setField(String fieldName, String fieldVal) method.
  • addRecipient(String name, String email)
  • addCarbonCopy(String name, String email)
  • addBlindCarbonCopy(String name, String email)
  • removeRecipient(String name)
  • ...
• What does this suggest about the fields?
• How might we implement the add/delete methods?