15-100 Lecture 10 (Wednesday, September 21, 2005)

Quick Quiz

  // Write the specification for a class, Quiz
  class Quiz {

    /*
     * Assume that, magically, and without you writing it, this class contains
     * the following method:
     *
     *  public static int promptUserForInt(String prompt);
     */

    // Within the main method, please do the following:
    public static void main (String[] args) {
      // Use promptUserForInt(String prompt) to get each of a numerator 
      // and a denominator from the user
      int numerator = promptUserForInt("numerator: ");
      int denominator = promptUserForInt("denominator: ");

      // Convert the numbers to a fraction using fractionToDouble()
      double fraction = doubleToFraction(numerator, denominator);

      // Print out the number
      System.out.println (fraction);
    }
  

A Quick review of the "if statement"

Last class, we discussed the "if statment". Complete with an "else" clause, it has the following form:

  if (predicate) {
    // the code here executes if the predicate is true
  } else {
    // the code here executes if the predicate is false
  }
  

The "predicate" is a boolean expression. In other words, it is something that evaluates to true or false. Consider the example below:

  if (bodyTemp > 98.6) {
    System.out.println ("You have a fever.");
  } else {
    System.out.println ("Normal body tempurature.");
  }
  

Please also recall that the "else" clause is optional. For example, consider the example below:

  if (availableCredit < purchasePrice) {
    System.out.println ("Sorry. You've exceeded your available credit.");
    return;
  }

  availableCrdit -= purchasePrice;
  makePurchase(purchasePrice);
  

The "while" loop

It is often times useful to repeat an operation until certain criteria are met. We see this in the real world every day. As long as you can see dirt, keep vacuming. While the roast is below safe tempurature, keep cooking.

We also see this in computer programs. For example, we might continue to read from a file as long as we haven't gotten to the end. Or, we might process user input so long as they don't select "Q" for quit.

Java has a langauge feature for exactly this -- the "while" loop. It is one of Java's three loop constructs. It is, perhaps, the most fundamental loop -- and the first that we'll study. Its syntax is strikingly similar to that of the "if" statement:

  while (predicate) {
    // This body is "gated" by the predicate above. 
    // After it completes, control "loops" back to the evaluation 
    // of the predicate
  }
  

Let's consider the example below. It will continue until the user enters a blank line:

  String userInput;

  System.out.print ("Enter line: ");
  while ((userInput = br.readLine().equals("")) {
    System.out.println ("You entered: " + userInput);

    System.out.print ("Enter line: ");
  }
  

Please also consider the following example, which prints number 1, 2, 3, 4, ..., 10.

  int number=1;
  while (number <= 10) {

    System.out.println (number);
  
    number++; // number = number +1;
  }

  // For reference, notice number is 11 after the loop. 
  // (11 > 10) broke the loop, so it stopped after reaching 11, but
  // before re-entering the loop
  System.out.println (number); 
  

The "do...while" loop

The "while loop" is a "precondition" loop. It checks a predicate before entering the loop the first time, and before entering each time thereafter.

Java has a similar loop, called the "do while" loop. It resembles the "while loop", except it checks the predicate after completing the body of the loop. As a result, the loop is guaranteed to run at least once.

Let's reconsider the userinput example from above -- this time as a do-while loop:

  String userInput;

  do {
    boolean continue = true;

    System.out.print ("Enter line: ");
    userInput = br.readLine());

    if (userInput.equals("")) {
      continue = false;
    } else {
      System.out.println ("You entered: " + userInput);
    }
  } while (continue);
  

== vs. .equals()

Let's take a quick look at one of the new details from the code above

  if (userInput.equals("")) {
  

Please notice the funny way that we compared two strings, userInput and "". We'll talk more about this later. But, for right now, the important thing is that you should not compare Strings with the ==-operator. It will not produce reliable results. Instead, you should use the syntax you see below:

  string1.equals(string2)
  

equals() is a method, somewhat like those we have been writing. But, unlike our methods, it isn't "static" -- it actually part of the String. What we are actually doing here is asking "string1" to determine if it is equal to "string2".

Again, we'll discuss the reason for this very soon. For right now, just keep this in mind: Use .equals(), not ==, to determine if two strings are equivalent.