A Review

First, let's review mental execution and develop some useful visualizations:

• Consider this program

  
  public class SillyProgram {
  
      public static void main (String[] argv)
      {
  	int x = 1;
  	int y;
  	x = x + 1;
  	y = x*x;
  	System.out.println (y);
      }
  
  }
      

• When you see such a program, you should say ...
  • Execution starts with the first line in main.
  • Here, an int variable x is declared and assigned the value 1.
  • Then, the int variable y is declared, but not assigned a value ... etc.

• Thus, execution proceeds sequentially in order of the appearance of statements.

So far, so good. Next, let's look at:

public class ForLoopExample {

    public static void main (String[] argv)
    {
	int x = 0;
	for (int i=1; i<=10; i++) {
	    x = x + i;
	}
	System.out.println (x);
    }

}
    

There are four levels at which to "read" or understand a for-loop:

• First, at the highest level, a for-loop is merely a block of code that repeats a number of times:

  

• At the next level, you should say to yourself, "for i starting at 1 up through 10 ...(something)"

  

• At the third level, you can try and understand what the loop is trying to do:

  

• Finally, at the most detailed level, you trace through the loop, watching how every affected variable changes its value.
         ⇒ Here, only x and i change.

  
                                   i             x
    0.  Before loop starts                       0
    1.  End of 1st iteration       1             1
    2.  2nd                        2             3
    3.  3rd                        3             6
    4.  4th                        4             10
    5.  5th                        5             15
    6.  6th                        6             21
    7.  7th                        7             28
    8.  8th                        8             36
    9.  9th                        9             45
    10. last iteration            10             55
      

Now let's look at a conditional:

• First, at the outermost level, notice that exactly one of three blocks will execute:

  

• For this data, the execution turns out to be:

  

  1. First, the Boolean expression (x < y) is evaluated.
            ⇒ This fails and goes to the else, which has an if.
  2. Then, (x > y) is evaluated
            ⇒ This turns out to be true, and so, one enters the block inside.
  3. It so happens that the first statement inside is an if.
            ⇒ The complex conditino turns out to be true.
  4. Then, (c == 'a') is evaluated.
            ⇒ Which turns out to be false.
  5. The else block is entered. This itself has an if inside.
            ⇒ The condition (c == 'b') turns out to be true.

• Now, consider what happens after the println executes:

  

  6. The innermost if has no corresponding else
            ⇒ Execution continues after the if-block (just past the closing brace).
            ⇒ There's nothing there, so we come out of the else corresponding to (c == 'a').
  7. There's nothing there, so we're done with the if-block with the complex condition.
            ⇒ This means we jump past the corresponding else.
  8. There is nothing to execute here, so we are done with the if-else with the complex condition.
            ⇒ We jump out of the code block corresponding to (x > y).
  9. Finally, we jump past the outermost if-elseif-else block.