Repetition Structure

This week we continue with the 3rd control structure of programming, namely Repetition Structure.

Repetition structure is used to make certain portions of the program code run repeatedly, to achieve certain logic that you want. There are 3 Java statements to do repetition, while(), for() and do-while(). Refer to your lab 4 or the textbook for the syntax.

The characteristics for these loops are:

while() loop:

• this is a pre-test loop, meaning the condition is tested before going into the loop.
• for a counter-controlled loop, need to specify the starting value for the counter (int i = 0;), the continuation condition (while(i<5)) and the increment (i++;). The starting value is to be specified before the loop, and the increment is to be within the loop.
• for a sentinel-controlled loop, need to ensure that the value to be checked/compared against the sentinel value is being changed within the loop, either by some calculations, or by requesting input from the user.

for() loop:

• a for() loop works exactly the same as a counter-controlled while() loop by collecting all the 3 necessary statements and putting them together in the for() statement.
• a for() loop is particularly useful when we are dealing with arrays.

do-while() loop:

• a do-while() loop is a post-test loop, meaning the statements within the loop is ran first before the condition is checked/tested if the loop is to be repeated.
• the only difference between do-while() loop and while() loop is that statements are ran at least once for a do-while() loop, and statements may not be ran at all for a while() loop.
• for the while() statement in a do-while() loop, you need to put a semi-colon (;) at the end of the statement.
  

That's about the important things that you should take note.

More selection structure

Another selection structure which achieves multiple branching is the switch() structure. This structure is a multiple if() and the broadest use it to create a menu structure for a program.

switch(integer variable)
{
  case C1: //Write statements to do if variable == C1
           break;

  case C2: //Write statements to do if variable == C2
           break;

  default: //Write statements to do if variable is other values
}

Things to note for a switch() structure:

• it can only evaluate an integer value (including char)
  
• values for the cases are exact values and it does not allow range of values (e.g. C1 > 20)
• all cases should have a break statement to prevent statements from falling through
  

Selection structure

The Selection structure is primarily achieved by using the if() condition (flowchart attached below).


The if() condition allows branching of program codes based on a condition. The general structure looks like this:

if(condition)
{
  // Write statements to do if condition is true
}
else
{
  // Write statements to do if condition is false
}

We can also nest (put) if() conditions within another if() conditions to form complex logic for our programs. Do take care of the curly brackets, and always use tabs to indent the statements properly to aid debugging.

Things to note about if() conditions:

• an if() can have one and only one else or not at all
• a else must come with a if()
• if() conditions are independent of each other
  

Comparing Strings

As mentioned in the previous post, relational operators are meant for comparing variables declared in the primitive data types, and not strings. Since strings are objects of the String class, we need to use methods to perform the comparison.

We introduced 3 methods for comparing strings.

• compareTo() - This method compares 2 strings and returns an integer value. If the 2 strings are exactly the same (including the case), a 0 will be returned. Else, the method will return the difference between the 2 strings. Using the return value, we can use it to help us sort strings. Refer to Lab 3 for an example, which I will also elaborate in class.
• equals() - This method also compares 2 strings but returns only the boolean values TRUE (when the strings are exactly the same) or FALSE (when the strings are not the same).
• equalsIgnoreCase() - This method does the same thing as equals() but ignores the case.

We will be using these methods in Lab 3 and I hope it becomes clearer to you how the method works, when you get to use them in real programs.

As usual, leave comments if you have questions.

Comparing Numbers

In Java, we use relational operators (==, !=, >, <, >=, <=) to help us compare numbers, which are represented by variables of the 8 primitive data types. Take note that we cannot compare a string with a number; we can only compare (use the relational operators) variables declared in the primitive data types.

The common error that students always make when writing relational operators is to mixed up the double equal sign (==) which is to check if 2 values are the same, with the single equal sign (=) which is to assign a value to a variable.

Control Structures in Java

Control structures are the basic building blocks of any programming language, and hence is not specific to only Java.

There are 3 basic control structures for Java:

• Sequential - This means that all Java statements are executed line-by-line, one after another. This is already inherent within the language itself as you write the codes.
• Selection - This control structure instructs the computer to make a selection (or branching) of the portion of the program based on a decision, made by doing a comparison. There are 2 selection structures in Java, the if() and switch() structures.
• Repetition - This structure instructs the computer to perform a repetition of a block of code, and there various methods to terminate the repetition. There are 3 repetition structures, the for() loop, the while() loop and the do-while() loop.

A complete computer program often needs to make use of a combination of these control structures. Do make a note of these structures as we will go through them in detail in the coming weeks.