Class 10: Conditionals

Held Friday, September 10, 1999

Overview

Today, we will move from high-level consideration of classes and objects to more detailed consideration of the imperative internals of objects. In particular, we will consider the basic conditional statements of Java, which let your methods choose between alternatives.

Notes

• Some of you have asked whether or not you have to do the post-laboratory problems. You should not do the post-lab problems! You have too much to do already.
• Are there any questions on assignment 1?
• At this point, you should be fairly close to finishing J3.
  • Do not use today's class time for that lab.
  • If you're having difficulty with the lab, please see me asap.
• Check out yesterday's outline: I've added notes on our discussion of the project.
• Some partially-working examples are also available.
• I neglected to mention one key issue in inheritance: you can't inherit constructors.
• For the next few days, we'll move away from object-oriented issues and consider some more familiar parts of Java: conditionals, loops, and arrays.
• Mr. Stone will be visiting class all next week as part of my third-year review.

Contents

• Boolean Values
• Control Structures with Booleans
  • Simple Conditionals
  • Other Conditionals
• Conditionals Lab
  • untitled

Handouts

• Lab J4: Conditionals
• Assignment 2: inheritance and polymorphism
  • Due next Friday

Summary

• Boolean values and operators
• Conditional control structures that use boolean values
  • if
  • switch
• Lab: conditionals
• Assigned: assignment 2: inheritance and polymorphism

Boolean Values

• In working with Java, we've encountered three kinds of types
  • Primitive numeric types (int and its ilk)
  • Built-in object types (String)
  • User-defined object types (Point)
• 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.
• 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)
• You can typically compare any two objects with the equals method. (It does need to be defined for most classes.)
• It is also possible to define new boolean methods. For example, consider ``Is this point within 1 unit of the origin?'' We might code this as follows:

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

• 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.

Simple Conditionals

• 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 executes the statements only when the test holds.
  • The test must return a boolean (truth) value.
  • The test must be surrounded by parentheses.
• 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 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.
• Java does not provide a special facility for nesting if statements. (Some other languages do.)

Other Conditionals

• Often, you need to do more than select between two values, one true and one false.
• While it is possible to do this with a sequence of if statements, such a solution is neither readable nor efficient.
• As an alternative, Java provides the switch statement (like the case statement in Pascal).
• It takes the form

  switch (integer-valued-expression) {
    case value1:
      stuff-to-do;
      break;
    case value2:
      stuff-to-do;
      break;
    ...
    default:
      stuff-to-do;
      break;
  }
  

• If you leave out a break, execution will continue into the next case.
• You can switch on expressions whose type is byte, short, int, long, or char.
• The break statement has other uses, which you'll see later.

Conditionals Lab

Do sections J4.2 and J4.4 of lab J4: conditionals.

What are some other ways we might use conditionals with the Point class?

What are some other ways in which you might expect to use conditionals?