Control Structures

1. What "Control Structures" are, and Why we need them!

1.1. Recalling How a Java Program Runs
1.2. What Control Structures Provide

2. Conditional Control Structures

2.1. The if Structure
- 2.1.1. if/elseif/else Variants
- 2.1.2. The General Structures
2.2. The switch Structure

3. Looping Control Structures
- 3.1. The while Loop
- 3.2. The for Loop
4. Nesting Control Structures

What "Control Structures" are, and Why we need them!

What we'll be covering here is an essential part of any programming language.
They are called control structures, and they allows us to manipulate if, and how many times, a chunk-o-code is executed.
Without them, a program would always do the same thing!
Java has 5 control structures. We'll only cover 4 (the 5^th is a minor variation of one of the others).
2 of the control structures allow a programmer to specify if a piece of code should be executed. These are called conditional structures.
2 of the control structures allow a programmer to specify how many times a piece of code should be executed. These are called looping structures.
The structures we'll be covering appear almost identical in many programming languages.
The one's well be covering appear (almost) identically in C, C++, C#, MATLAB, and even more programming languages.

Recalling How a Java Program Runs

Although we haven't formally covered Classes and Methods (yet, that's coming next!), remember from the Java Basics discussion that a Java program/Applet is always broken up into classes, which are further dividied into methods.
All code that actually does something appears in methods.
A method is simply a named collection of statements, and when the method is executed, the statements are executed, one by one, in the order they appear.

The general form is...

      methodName {

         statement1;
         statement2;
         statement3;
             .
             .
             .
      }

When this method is run, statement1 is executed first, followed by statement2, then statement3, and so on.

What Control Structures Provide

Often, we want to execute some collection of statements conditionally, that is, only if some condition is true.

That is, often we want to do something like this...

         IF CONDITION such-and-such IS TRUE THEN, AND ONLY THEN, DO THE FOLLOWING...
         {
               statement1;
               statement2;
                  ...
         }

Other times, we want to execute some collection of statements repeatedly, that is, over and over.

That is, we sometimes want/need to do the following...

         DO THE FOLLOWING EXACTLY 10 TIMES...
         {
               statement1;
               statement2;
                  ...
         }

Or perhaps...

         KEEP DOING THE FOLLOWING FOR AS LONG AS CONDITION such-and-such IS TRUE...
         {
               statement1;
               statement2;
                  ...
         }

Control structures provide us these abilities, and are necessary for programming.

Conditional Control Structures

Java has 2 conditional control structures: if and switch.

The `if` Structure

The if structure is what allows us to execute a collection of statements conditionally, that is, if and only if some condition is true.

Its most basic form is the following:

         statements-before;

         if ( condition ) {
               statements;
               ...
         }

         statements-after;

Syntax: The text in red is fixed. That is to say, it is a necessary part of any use of the if structure. You simply must include the word "if" followed by a condition in parentheses.
Semantics: How does Java execute this code? When Java reaches the line
```
         if ( condition ) {
```
it will evaluate whatever condition is. If it evaluates to true, then, and only then, will Java start executing the body of the if structure (the stuff between the two squiggly brackets), and once finished, will proceed executing the statement after the if structure. If condition evaluates to false, then the body of the if structure is skipped entirely, and Java continues executing with the statement appearing after the if structure.
A concrete example... (covered in class)
Note that the squiggly brackets denote the body of the if structure (what is executed if the condition evaluates to true).
As mentioned above, there are many variants of the if structure, but they always include that first "if ( condition ) {".

`if`/`elseif`/`else` Variants

if + else

Frequently we want to do one thing if a condition is true, and another if the condition is false.

The if structure allows us to easily accomodate this by using an (optional) else clause...

         if ( condition ) {
               statementsA;
         } else {
               statementsB;
         }

In this form, if condition evaluates to true, then statementsA is executed (just as before).
However, if condition does not evaluate to true, then statementsB is executed.
That is, one of the two sets of statements, either the if-body or the else-body, is always executed.
A concrete example... (covered in class)

if + else if

Just as we can extend the basic if structure to include an else clause, we can extend it to include an else-if clause...

         if ( conditionA ) {
               statementsA;
         } else if ( conditionB ) {
               statementsB;
         }

With the above, Java will first check conditionA. If it evaluates to true, then statementsA is executed, and that is all. Otherwise, if conditionA evaluates to false, then conditionB is checked and if that condition evaluates to true, then statementsB is executed. Otherwise, no statements are executed.

This else-if is really just short-hand for the following...

         if ( conditionA ) {
               statementsA;
         } else {
               if ( conditionB ) {
                     statementsB;
               }
         }

In fact, we can have as many else-if clauses as we'd like in an if structure

         if ( conditionA ) {
               statementsA;
         } else if ( conditionB ) {
               statementsB;
         } else if ( conditionC ) {
               statementsC;
         } else if ( conditionD ) {
               statementsD;
         }

It's important to remember that in the above structures, at most one set of statements is ever executed!
That is, supposing conditionA and conditionC were both true, only the first of the two (conditionA) is executed.
If none of the conditions above evaluate to true, then nothing will be executed.

if + else if + else

As mentioned above, with only else if's, it's possible that none of the bodies may execute.
Sometime's it's nice to have a "catch-all" case, in the situation where all of the conditions evaluate to false.

We do this using the else clause...

         if ( conditionA ) {
               statementsA;
         } else if ( conditionB ) {
               statementsB;
         } else if ( conditionC ) {
               statementsC;
         } else if ( conditionD ) {
               statementsD;
         } else {
               else-statements;
         }

In the above, if all of the conditions evaluate to false, and only in this case, the else body will execute.

The General Structure

In general, all if structures could be described as follows...

         if ( conditionA ) {
               statementsA;
         }  else if ( conditionB ) {
               statementsB;
         } else {
               statementsC;
         }

The red stuff is always necessary to use an if
The blue and green stuff are both optional
The blue stuff can be repeated multiple times (there can be many else-if clauses)
The green stuff can appear at most once (there can only be at most one else clause)

The `swtich` Structure

Java provides another conditional structure, which is really short-hand for a common use of the if structure.
Frequently, we want to do different things based on the value of a single variable.
Example: Suppose we have a variable called monthNum which contains a number 1 through 12, corresponding to a month, and we want to display the corresponding month's name.

Using if, we would have something like the following...

         if ( monthNum == 1 )
            output.setText("January");
         else if (monthNum == 2)
            output.setText("February");
         else if (monthNum == 3)
            output.setText("March");
         else if (monthNum == 4)
            output.setText("April");
         else if (monthNum == 5)
            output.setText("May");
         else if (monthNum == 6)
            output.setText("June");
         else if (monthNum == 7)
            output.setText("July");
         else if (monthNum == 8)
            output.setText("August");
         else if (monthNum == 9)
            output.setText("September");
         else if (monthNum == 10)
            output.setText("October");
         else if (monthNum == 11)
            output.setText("November");
         else if (monthNum == 12)
            output.setText("December");
         else
            output.setText("Smarch!  Just kidding, bad monthNum");

Java provides the switch structure for just such a case, where we can greatly reduce the amount of stuff we, the tired programmer, has to type.

Example:

         switch( monthNum ) {
            case 1:
               output.setText("January");
               break;
            case 2:
               output.setText("February");
               break;
            case 3:
               output.setText("March");
               break;
            case 4:
               output.setText("April");
               break;
            case 5:
               output.setText("May");
               break;
            case 6:
               output.setText("June");
               break;
            case 7:
               output.setText("July");
               break;
            case 8:
               output.setText("August");
               break;
            case 9:
               output.setText("September");
               break;
            case 10:
               output.setText("October");
               break;
            case 11:
               output.setText("November");
               break;
            case 12:
               output.setText("December");
               break;
            default:
               output.setText("Smarch!  Just kidding, bad monthNum");
         }

The general form of a swtich structure is the following:

         switch ( expression ) {
            case valueA:
               statementsA;
               break;
            case valueB:
               statementsB;
               break;
            case valueC:
               statementsC;
               break;
               .
               .
               .
            default:
               default-statements;
         }

Syntax: The stuff in red is mandatory for using a switch structure. The green "default:" clause (and it's body, "default-statements;") is optional. There must, however, be at least one "case" block, each of which are of the following form:
```
            case value:
               statements;
               break;
      
```
Semantics: When execution reaches the line
```
         switch ( expression ) {
```
Java will evaluate expression and determine its value. Suppose the value it evaluates to is X. IF there is a "case" block of the form
```
            case X:
               statements;
               break;
```
then execution will "jump to" the corresponding set of statements;. Once execution of statements; finished, and the break; statement is reached, execution will continue after the end of the switch structure. If, however, there is no "case" block with the appropriate value X, then one of two things will happen: if there is no default: block, then none of the statements will be executed, and Java will continue execution after the end of the switch structure. Otherwise, the statements within the "default" block will be executed, and once they are finished execution will continue after the end of the switch statement.
The default: clause, if present, must be at the end.
The expression must evaluate to an integer value (i.e. something of type byte, short, int, or char).

Looping Control Structures

For when you want to do somethin over and over and over and over and over and over and over again, Java provides two looping structures (actually 3, but we're ignoring the 3^rd one... it's a simple variation of the while loop).
The first loop structure, the while-loop, allows us to execute a piece of code repeatedly, for as long as some condition is true.
The second loop structure, the for-loop, is short-hand for a common pattern that occurs when using while loops. It's ideally suited for executing a piece of code repeatedly when you know how many times you want to repeat the execution before the loop.

The `while` Loop

As stated above, a while loop is used to repeatedly execute a set of statements for as long as some condition evaluates to true.

The format is the following:

         statements-before;

         while ( condition ) {
               statements;
               ...
         }

         statements-after;

Syntax: The text in red is fixed. That is to say, it is a necessary part of any use of the while loop. You simply must include the word "while" followed by a condition in parentheses.
Semantics: How does Java execute this code? When Java reaches the line
```
         while ( condition ) {
```
It will evaluate whatever condition is. If it evaluates to false, then the body of the while loop is skipped entirely and Java continues executing after the while loop. If condition evaluates to true, however, then Java will execute the body of the loop and, once finished, return to the line
```
         while ( condition ) {
```
and continue. That is, it will check condition again, and if true, execute the body again. Otherwise, it will "exit the while loop".

The `for` Loop

Often we want to loop some number of times, where we know the number of times we want to loop.
That is, recall the example from the first day of class, where we wanted to display the number 0 to N

We first achieved this with the following while loop:

         int numToDisplay = 0;

         while (numToDisplay < clickCount) {
               output.append(numToDisplay + " ");

               numToDisplay = numToDisplay + 1;
         }

The general pattern that arrises often is this...

         pre-statement;

         while (condition) {
               body-statements;

               post-statement;
         }

To allow us programmers to write less code, we have the for loop for just this scenario:

            for ( pre-statement ; condition ; post-statement ) {
                  body-statements;
            }

Using a for loop, we could shorten our example above to the following...

            for ( int numToDisplay = 0 ; numToDisplay < clickCount ; numToDisplay = numToDisplay + 1 ) {
                  output.append(numToDisplay + " ");
            }

Nesting Control Structures

The above control structures can be nested. That is, they can appear wihin one another.
There are no restrictions on how they may be nested.
As an example, consider the following completely arbitrary task...
We want to write a program that allows the user to enter a number N, and then choose to display either the sum of the first N numbers (1 + 2 + ... + N), or to display the product of the first N numbers (1 * 2 * ... * N).
We could accomplish this using either of the following two approaches

Approach One: we break based on what the user wants first...

         int answer;

         // break based on what the user wants...
         if ( wantsDisplayed == "sum" ) {

               // compute the sum
               answer = 0;
               for (int i = 0; i < N; i++) {
                  answer = answer + i;
               }

         } else {

               // compute the product
               answer = 1;
               for (int i = 0; i < N; i++) {
                  answer = answer * i;
               }
         }

Approach Two: the loop is "outer" and we break on the body of the loop...

         // initialize answer appropriately
         int answer = 0;
         if (wantsDisplayed == "product") {
            answer = 1;
         }

         // compute the answer
         for (int i = 0; i < N; i++) {

            if (wantsDisplayed == "sum")
                  answer = answer + i;
            else
                  answer = answer * i;

         }

Control Structures

Controlling the execution of your code