Notes on Exam 1: Java Fundamentals

% ji Average
The average grade is: NaN

    if (count == 0) {
      out.println("I need values to average.");
      out.println("Usage:");
      out.println("  java Average val1 val2 ... valn");
    } // if (count == 0)

% ji Average
I need values to average.
Usage:
  java Average val1 val2 ... valn

% ji Average 1 2 three
Skipping 'three'
  [Values must be numbers in 'digit form']
The average grade is: 1.5

% ji Average zero 1 100
Skipping 'zero'
  [Values must be numbers in 'digit form']
The average grade is: 100.0

% ji Average 5 one 2 ten
Skipping 'one'
  [Values must be numbers in 'digit form']
Skipping 'ten'
  [Values must be numbers in 'digit form']
The average grade is: 5.0
ji Average one two 5
Skipping 'one'
  [Values must be numbers in 'digit form']
The average grade is: 5.0

        i = i + 1;

% ji Average one two 5
Skipping 'one'
  [Values must be numbers in 'digit form']
Skipping 'two'
  [Values must be numbers in 'digit form']
The average grade is: 5.0
% ji Average one 2 three 4
ji Average one 2 three 4 
Skipping 'one'
  [Values must be numbers in 'digit form']
Skipping 'three'
  [Values must be numbers in 'digit form']
The average grade is: 3.0

import SimpleOutput;

/**
 * Compute the average of a list of numbers entered on the command
 * line.  For example, to compute the average of a, b, and c, you
 * would write
 *   % java Average a b c
 *
 * This is a modified version of the program found on the Web at
 * http://www.math.grin.edu/~rebelsky/Courses/CS152/99F/Examples/Exam1/Average.java
 * All modifications are listed below.
 *
 * @author Carla Caffeinated
 * @author Carl Caffeinated
 * @author Samuel A. Rebelsky
 * @version 1.0 of September 1999
 */
public class Average {
  public static void main(String[] args) {
    // The following line was modified by Sam Rebelsky on
    // Friday, September 24, 1999 as part of answer A.1.
    double sum = 0;	// The sum of all the values entered.
    int count = 0;	// The number of values entered.
    SimpleOutput out = new SimpleOutput();
    
    // Step through the values, adding each in turn.  Skip those
    // that aren't valid.
    for (int i = 0; i < args.length; i = i+1) {
      try {
        // The following line was modified by Sam Rebelsky on
        // Friday, September 24, 1999 as part of answer A.1.
        sum = sum + (new Double(args[i]).doubleValue());
        count = count + 1;
        // The next few lines were added by Sam Rebelsky on
        // Friday, 24 September 1999, as part of an attempt to
        // understand difficulties in the program.
      }
      catch (NumberFormatException nfe) {
        // The next two statements were added by Sam Rebelsky on
        // Friday, 24 September 1999 to give the user more
        // information on values that are skipped.
        out.println("Skipping '" + args[i] + "'");
        out.println("  [Values must be numbers in 'digit form']");
        // The code that was here was removed by Sam Rebelsky on
        // Friday, 24 September 1999 to correct a logical error.
      }
    } // for
  
    // Print the average (assuming that it can be computed).
    // Except as mentioned below, the following lines were 
    // added by Sam Rebelsky on 24 September 1999 in response
    // to problem A.2.
    if (count != 0) {
      // Original line
      out.println("The average grade is: " + (sum/count));
    }
    // You can't compute an average of 0 values.  Tell the user.
    else {
      out.println("I need values to average.");
      out.println("Usage:");
      out.println("  java Average val1 val2 ... valn");
    } // No values entered
    // End of additions  from 24 September 1999
  } // main(String[])
} // class Average

/**
 * A simple, <Q>write-once</Q> representation of books.  Once the
 * author, title, and chapters are in place, they cannot be easily
 * changed (except by directly accessing the fields).
 * Note that rather than supporting a
 *   setChapter(int n, String * chapterName)
 * method, which some clients might misuse by setting the 5th chapter
 * but not the prior chapters, we have decided to limit clients to
 * adding chapters to the end of the book.  This lets client build but
 * not change the table of contents.
 *
 * The maximum number of chapters is 20.  This is a bad design.  It
 * would be better to allow the consturctor to take the number of
 * potential chapters as a parember.
 *
 * @author Carl Caffeinated
 * @author Carla Ceffeinated
 * @author Samuel A. Rebelsky
 * @version 1.0 of 24 September 1999
 */
public class Book {

  // +--------+--------------------------------------------------
  // | Fields |
  // +--------+

  /** The title of work. */
  protected String title;

  /** The author of the book. */
  protected String author;

  /**
   * The number of chapters currently stored in the work.
   * Note that this is always 1 higher than the index of
   * the highest-numbered chapter in the chapters array.
   */
  protected int numChapters;

  /**
   * The chapters of the book (or, more precisely, the names of
   * the chapters of the book.
   */
  protected String[] chapters;

  // +--------------+--------------------------------------------
  // | Constructors |
  // +--------------+

  /** Create a new book that supports up to twenty chapters. */
  public Book() {
    this.chapters = new String[20];
    this.numChapters = 0;
  } // Book()

  /** Create a new book that supports up to numChapters chapters. */
  public Book(int numChapters) {
    this.chapters = new String[numChapters];
    this.numChapters = 0;
  } // Book(int)

  /**
   * Create a new book with a specified author and title and up
   * to twenty chapters.
   */
  public Book(String author, String title) {
    this.author = author;
    this.title = title;
    this.chapters = new String[20];
    this.numChapters = 0;
  } // Book(String,String)

  // +-----------+-----------------------------------------------
  // | Accessors |
  // +-----------+

  /** Get the author of the book. */
  public String getAuthor() {
    return this.author;
  }  // getAuthor()

  /**
   * Get the title of chapter chapterNum.
   *
   * @exception Exception
   *   If there is no such chapter.
   */
  public String getChapter(int chapterNum)
    throws Exception
  {
    // Move from "human" indexing (starting at 1) to Java
    // indexing (starting at 0).
    chapterNum=chapterNum - 1;
    // Verify that the chapter number is valid.
    // a. It must be <= numChapters-1.  See above for more info.
    if (chapterNum >= numChapters) {
     throw new Exception();
    } // if it's too large
    // b. It must be >= 0 since the array indices start with 0.
    if (chapterNum < 0) {
      throw new Exception();
    } // if it's too small
    // c. The chapter must be there.  This test is not strictly
    // necessary, as we've carefully worked to ensure that the
    // chapters between 0 and numChapter-1 (Java numbering) are
    // all defined.  However, we may later change that decision
    // and it seems safest to be prepared for all situations.
    if (chapters[chapterNum] == null) {
      throw new Exception();
    }
    // That's it, just return the correct element.
    return chapters[chapterNum];
  } // getChapter(int)

  /** Determine the number of chapters in the book. */
  public int getNumChapters() {
    return this.numChapters;
  } // getNumChapters()

  /** Get the title of the book. */
  public String getTitle() {
    return this.title;
  } // getTitle()

  /** Convert the book to a string in preparation for printing. */
  public String toString()
  {
    // Add the author and title.  The title is in quotes.
    // Coding note: in Java, \" is how you get a quote in the
    // middle of a string.
    String stuff = "\"" + this.title + "\" by " + this.author + "\n";
    // Step through the chapters, adding each as you go.  Since
    // most people start their numbering at 1 rather than 0, we
    // add 1 to the index into the chapters array.
    for (int i = 0; i < numChapters; ++i) {
      if (chapters[i] != null) {
        stuff = stuff + "  " + (i+1) + ": " + chapters[i] + "\n";
      } // if the chapter is not null
    } // for
    // That's it, we're done.
    return stuff;
  }  // toString()


  // +-----------+-----------------------------------------------
  // | Modifiers |
  // +-----------+

  /**
   * Add a new chapter to the end of the table of contents.
   * See introductory notes for the rationale behind this.
   *
   * @exception Exception
   *   If there's not room for another chapter.
   */
  public void addChapter(String chapterName)
    throws Exception
  {
    // If there is not room for another chapter, throw an exception.
    if (numChapters >= chapters.length) {
      throw new Exception();
    }
    // Add the chapter.
    //   Coding note: Since we start indexing the array at 0, the
    //   number of chapters is 1 higher than the largest index used
    //   so far.  Hence, we can use it as the index of the first free
    //   element.
    chapters[numChapters] = chapterName;
    // Move on to the next chapter.
    numChapters = numChapters + 1;
  } // addChapter(String)

} // class Book