Class 14: Conditionals (1)

Held: Monday, 19 September 2005

Summary: Today we investigate conditional operations in Java.

Related Pages:

• Sample Code.
• EBoard.

Notes:

• Sorry about the confusion on the conditionals reading. The weekend got away from me. I'll be trying again this evening.
• Are there questions on homework 2?

Overview:

• Classes concluded.
• Boolean expressions in Java.
• Basic conditionals: the if statement.
• Recursive methods.

Concluding Classes

• Class fields and class methods: Add static.

Boolean Values

• In working with Java, we've encountered three kinds of types
  • Primitive numeric types (int, double, and the ilk)
  • Built-in object types (String)
  • User-defined object types (Point, ThreeWordPhrase)
• There are additional kinds of primitive values that we will use. The simplest of these is the boolean value.
• Booleans are truth values: they are either true or false. They can take on no other values.
  • In Scheme, anything that was not false was considered true.
  • In Java, you have only those two values.
• You can compute boolean values with Boolean expressions.
• You can compare two primitive numeric values with
  • x < y (less than)
  • x <= y (less than or equal to)
  • x == y (equal to; note there are two equals signs)
  • x != y (not equal to)
  • x >= y (greater than or equal to)
  • x > y (greater than)
• Note that these differ from Scheme in that they are infix (comes between) rather than prefix (comes before) operations.
• You can typically compare any two objects with the equals method. (It does need to be defined for most classes.)
• You can also compare many objects with the compareTo method.
• It is also possible to define new boolean methods. For example, consider Is this point within 1 unit of the origin?
  • We might code such a method as follows:

      /**
       * Determine if the current point is within one unit of the origin.
       */
      public boolean isNearOrigin() {
        return (this.getRadius() < 1.0);
      } // isNearOrigin()
    

• It is also possible to combine booleans with Boolean operators,
  • b1 && b2 (and)
  • b1 || b2 (or)
  • !b (not)
• For example, we might call a point bothersome if it is within half a unit from either axis. The Boolean operations help us define such a function.

    /**
     * Determine if the current point is bothersome.  That is, it is
     * within half a unit from either axis.
     */
    public boolean bothersome() {
      return (Math.abs(this.xcoordinate) < 0.5) ||
             (Math.abs(this.ycoordinate) < 0.5);
    } // bothersome()
  

Control Structures with Booleans

• As we'll soon see, there are many uses of Boolean values, particularly relative to control structures for programs.
  • Control structures influence the flow of control within the program; they select which operations are performed.
• The if or conditional statement is one of the simplest control structures.
• Java provides the two basic forms of the if statement.
• The simplest one:

  if (test) {
    statements;
  } // if
  

  • This statement executes the statements only when the test holds.
  • The test must return a boolean (truth) value.
  • The test must be surrounded by parentheses.
  • The braces are optional if you have only a single statement.
• This is a common structure in recipes. For example,
  • For fluffier pancakes, decrease the milk by 10%.
  • If above 5000 ft, decrease the oven temperature by 25 degrees F.
• It is also possible to suggest an alternate if the test does not hold.

  if (test) {
    statements;
  } // if text
  else {
    statements;
  } // not test
  

  This command selects between the two sequences of statements. It executes the first sequence of statements if the test evaluates to true and the second sequence if the test evalutes to false.
• Note that Java's if is slightly different from Scheme's.
  • Scheme's if selects between expressions and returns a value.
  • Java's ifselects between statements and does not return a value.
• Java did not provide a special facility for nesting if statements, such as Scheme's cond. Instead, use the following:

  if (test1) {
    stuff1
  }
  else if (test2) {
    stuff2
  }
  else if (test3) {
    stuff3
  }
  else if (testn) {
    stuffn
  }
  else {
    default-stuff
  }
  

Recursion

• Recursion in Java is just like recursion in most languages:
  • Test for the base condition.
  • If it holds, return the base value.
  • If not, recurse.
• Example: Greatest common divisor.