Methods: 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.

In-Class Exercise 1: Add println's at places numbered 6-9 above. Make these print the numbers 6, 7, 8, and 9. Then, add println's just after the conditions corresponding to 1, 2, and 3 (to print these numbers). Did the output correspond to the flow of execution?

Parameterless methods

public class ReturnExercise {

    public static void main (String[] argv)
    {
	printXsAndYs (3, 4);
	printXsAndYs (4, 1);
	printXsAndYs (-1, 1);
	printXsAndYs (4, -1);
    }

    static void printXsAndYs (int m, int n)
    {
	System.out.print ("start ");
	if (m < 0) {
	    // 1.
	    return;
	}
	else if (m > 10) {
	    // 2.
	    return;
	}
	for (int i=0; i<m; i++) {
	    System.out.print ("X");
	    printYs (n - i);
	}
	System.out.println (" end.");
    }

    static void printYs (int k)
    {
	if (k < 0) {
	    // 3.
	    return;
	}
	else if (k > 10) {
	    // 4.
	    return;
	}
	for (int i=0; i<k; i++) {
	    System.out.print ("Y");
	}
    }

}
    

    int p = 3;
    int q = incr( incr(p) + incr(2) );
    int r = incr( incr(q) / p );
    

    int p = 3;
    int q = factorial (factorial(p)) * factorial(p-3) + factorial (-3);