Outline of Class 7: Control and Inheritance

Held: Wednesday, January 28, 1998

Administrivia

• Tomorrow at 4:15 in Science 2424 the department will be showing "The Proof", a film about the proof of Fermat's last theorem. This had been a major open problem in mathematics, and was only solved in the past few years.
• I was sorry to see so few (okay none) of you at the Haskell discussion group. Perhaps next week?
• Don't forget that assignment 1 is due now!
  • Turn it in with
    % elm -s "Homework 1" rebelsky < scriptfile
• Any questions on assignment 2?
• I'm hoping to have large labs ready for Friday and Monday, but we'll see how the rest of the week goes (I didn't use similar labs last term and this week is busy).

Control Structures

The while loop

• Often, you want to execute a series of statements as long as a condition holds.
• For this case, Java provides the while loop, which has the form

  while (test) 
  {
    statements;
  } // while
  

• In executing this loop, Java evaluates the test. If the test fails, the loop terminates. Otherwise, Java executes the statements and then goes back and tries the test again.
• Note that the statement can be empty.
• At times, you will want to have a loop in which the body is executed once before the test. While it is possible to do this by repeating code, it is easier to use a variant of the while loop called the do loop, and has the form
  

  do 
  {
    statements
  } while (test);
  

  • This is the only time you won't need to comment your ending brace.
• If you only want to execute one (or zero) statements, you don't need the braces. However, I consider it good programming practice to include them.
  • It doesn't change the execution speed of your program.
  • It makes it much easier to extend your program.
  • However, it does increase the length of your program.

The for loop

• At times, you want to execute a statement (or block of statements) a fixed number of times.
• For example, to calculate the factorial of N, we might want to multiply 1 by the numbers from one to N.
• Many programming languages provide a structure known as the for loop for situations like this.
• Java provides a more general of the for loop. It has the form

  for (initialization; test; increment)
  {
    statement;
  } // for
  

• In effect, this is equivalent to

  initialization;
  while (test) 
  {
    statement;
    increment;
  } // while (test)
  

• Any of the four parts of a for loop can be omitted (in which case it is ignored).
• We can then solve our initial factorial problem as follows

  int i;		// A counter variable
  int factorial;  // The factorial of N
  factorial = 1;
  for (i = 1; i <= N; i = i+1) 
  {
    factorial = factorial * i;
  } // for
  

• Most Java programmers increment their counter variables with the postincrement operator, var++.

Pre- and Post-increment

• In many ways, Java reflects the heritage of C.
• One place that this is particularly apparent is in the preincrement and postincrement (and pre- and post-decrement) operations.
• In C, ++ can be used before or after any variable (or reference to a memory location). The effect is to increment the variable by one (or an equivalent of one).
• Similarly, -- can be used to decrement the variable by one.
• In Java, you can use ++ and -- with integer variables (and their variants).
• If the ++ comes before the variable, the value of the expression is the new value of the variable.
• If the ++ comes after the variable, the value of the expression is the old value of the variable.

Exiting Loops Early

• At times, you need to exit your loops (or one repetition of a loop) early.
• For example, you might have noted an abnormal condition, or have reached termination.
• While it is always possible to provide for such early exits by intelligent use of conditionals, such conditionals can inhibit the readability of your code.
• Hence, Java provides methods for exiting loops.
• break exits the current loop (or switch).
• continue exits the current repetition of the loop (going back to the test, and, possibly, to another repetition of the loop).
• Since we often nest loops, Java also provides a mechanism for exiting nested loops. You can label a any of the loops or switches with label: statement and then use break label to break out of that statement. For example

  outer: 
  for (i = 0; i < N; ++i) 
  {
    inner: 
    for (j= 0; j < M; ++j) 
    {
      if (meetsCondition(i,j)) 
      {
        out.println(
          "Found what we were looking for at (" + 
          i + "," + j + ")"
        );
        break outer;
      } // if
    } // inner for loop
    // Here's where you go if you break out of the inner loop
  } // outer for loop
  // Here's where you go if you break out of the outer loop
  

• Similarly, continue can take a label, and returns to the next iteration of the labeled loop.

Inheritance

• Java, like most object-oriented languages, lets you subclass existing classes to refine their functionality for particular instances.
• For example, we might have a general DrawableObject class and refine that to particular drawable objects, such as Circle or Square.
• How do you indicate that one class is a subclass of another? With the extends keyword.

  public class Circle 
    extends DrawableObject 
  {
    ...
  } // Circle
  

• A subclass inherits all the methods and fields of its superclass (with some restrictions due to protection mechanisms).
  • That is, it can use those methods and fields without explicitly defining or declaring them.
• A subclass may also override any of these methods by including its own definition.
  • That is, if a class defines any methods with the same name and argument types as the superclass, then that method is used instead.
• Inheritance is used in two ways. First, it's used to automatically provide some core functionality. In addition, it's used guarantee the functions an object will provide. Since an object inherits all of the ancestors methods, someone using the object knows that they will all be available.
• Java allows you to use a member of a subclass anywhere a member of a superclass is permitted. For example, it is perfectly valid to write:

  DrawableObject obj = new Circle();
  

• Similarly, if you write a function that uses a superclass, you can pass in a member of the subclass.

  public void drawWithStrangeColors(DrawableObject obj) 
  {
  ...
  } // drawWithStrangeColors(DrawableObject)
  ...
  drawWithStrangeColors(new Circle());
  

• Java is much more restrictive on using members of superclasses in place of members of subclasses.
• Why do you think Java has these restrictions?
• Note that if you do not provide an extends clause, Java assumes that your object extends java.lang.Object.
• Java permits only single inheritance -- a particular class can only directly derive from one other class.
  • In the alternative, multiple inheritance -- a particular class can directly derive from more than one other class.
  • Single inheritance makes analysis and design much easier. Otherwise, there are potential problems with the same method name being defined in both parent classes.
  • Java provides interfaces to support many of the needs of multiple inheritance.