Difference between revisions of "Control Structures"

Revision as of 15:58, 6 March 2007

Control Structures are blocks of code that force the computer to make a decision. Sometimes you will want your program to perform different tasks depending on certain boolean conditions. For example if you were writing a game you would probably find it very useful to be able to know when the user has won the game so that you could show a high scores page.

Without control structures programs would begin at the first line and excecute every line of code in order, giving the same output every time. Imagine how boring Tetris would be if there was only one piece! Control structures allow you to change the order of execution, jumping from one section of code to another as needed.

The If-Statement

A First Example

In this example the user is asked for a number and the program tells the user if the number is even. Pay careful attention to lines 05 to 08.

00 public static void main(String[] args)
01 {
02     int number;
03     number = Integer.parseInt(JOptionPane.showInputDialog(null,"Enter a number"));
04
05     if(number%2 == 0)
06     {
07         System.out.println("The number is even");
08     }//if
09
10 }//main

The keyword if is used to tell the computer to make a decision based on a condition. If the condition returns a value of true then the lines of code contained inside the body is executed. If the condition returns false the code inside the body is skipped entirely.

In this example the condition is number%2 == 0. You can always identify the condition of an if-statement by looking at what is contained in the parentheses after the word if. The condition must always return either true or false. Any other values (such as a number, string, or character) will result in an error when you try to compile your program.

The body of the if-statement is everything contained within the curled braces. In this case the body contains one line: System.out.println("The number is even");.

Together the keyword if, the condition, and the body form what is called an if block or if statement.

Anatomy of the If-Statement

As described in the previous example an if-statement is made up of several parts:

• the keyword if
• the condition
• the body

The general form for the if-statement is:

if (condition)    //"if" and condition on same line, condition is contained inside parentheses
{
    body          //all statements that should be executed if and only if the condition returns a value of true
}//if

Normally the body is contained inside braces (the {...} characters). However, if the body is only one statement these braces may be omitted. Thus:

if(condition)
{
    System.out.println("The condition was true");
}

and

if(condition)
    System.out.println("The condition was true");

are the same. If the body has more than one statement it is very important to put braces around it. It's often a good practice to always put braces around the body, even if it is only one line.

The If-Else Statement

Sometimes it is not sufficient to simply tell the computer "If such-and-such condition is true do this". Somtimes you will want to say "If such-and-such is true do this, otherwise do that". A simple way of doing this would be to have a separate if-statement that will return the opposite value of the first:

if (number%2 == 0)
{
    System.out.println("The number is even");
}//if

if (number%2 !=0)
{
    System.out.println("The number is odd");
}//if

While this approach works, it is needlessly complicated; there is a better way of doing the same task, but with less work. The keyword else can be used to tell the computer do execute a different body of code if the condition of an if-statement returns false. We can rewrite the code from above to take advantage of this keyword like this:

if (number%2 == 0)
{
    System.out.println("The number is even");
}//if

else
{
    System.out.println("The number is odd");
}//else

If we step through this last example the computer will evaluate the condition number%2 == 0 and check the result. If the result is true the body of the if-statement will be executed, just like in the previous examples. If the result is false then the body of the else-statement is executed.

The keyword else and the corresponding body form what is called an else-block or else-statement. It is very important to note that an else-block is always associated with an if-block, and each if-block can only ever be associated with zero or one else-blocks.

Together the keywords if, else, the condition, and the two bodies form a code-block known as an if-else block or if-else statement.

Anatomy of the If-Else Statement

The if-else statement is made up of the following parts:

• the keyword if
• the condition
• the body of the if-statement
• the keyword else
• the body of the else-statement

The general form of an if-else statement is:

if (condition)
{
    code to execute if condition == true
}

else
{
    code to execute if condition == false
}

Conditions

Logical and Relative Operators

What happens if you have a statement the requires several conditions to be true before it will be executed? You could nest if statements, but this is messy are certainly not good practice. This is where logical operators come in. The snippet of code below is 100% valid, but is overly complicated.

if (x == 1)
{
  if (y == 1)
  {
    System.out.println("X is 1 and Y is 1");
  }
}

The next version will yield the same result. Also, it shows how logical operators can clean up code.

if (x == 1 && y == 1)
{
  System.out.println("X is 1 and Y is 1");
}

There are three logical operators used for conditional statements. They are AND, OR, and NOT. The AND is represented in code as &&. The OR is represented as ||. Lastly, the NOT is represented as !. The purpose of these operators is to combine the boolean values of all the conditions and come up with a single boolean value. In the code above, if the X condition is true and the Y condition is true, then the whole statement is true. Truth tables can help explain how the logical operators work.

AND Truth Table

X     Y      Result
true  true   true
true  false  false
false true   false
false false  false



OR Truth Table

X     Y      Result
true  true   true
true  false  true
false true   true
false false  false



NOT Truth Table

X     Result
true  false
false true

NOT operators work slightly different than AND's and OR's. NOT's work with a single condition statement, rather than two statements. If the boolean result of statement X is true, then a NOT will change the statement to false. Likewise, NOTing a false statement will make it true. Also note that the NOT operator is put in front of a condition statement. Some examples below show how this is done.

int i = 1;

if (!(i > 0)) // i > 0 is true, but the ! reverses so the result is false
...

if (!i > 0) // Illegal statement - ! can ONLY be used for boolean value. i is an integer.
...

if (!true == !true) // !true is false, and false == false, so the result is true
...

Relational operators are nothing new. You have seen and been using them but probably did not realize it. Relational operators are part of what makes up a conditional statement. They will determine whether a condition will be true or false. Below is a list of the different relational operators.

Operator  True if...
  >       Left operand is greater than right operand
  >=      Left operand is greater than or equal to right operand

  <       Left operand is less than right operand
  <=      Left operand is less than or equal to right operand

  ==      Left operand is equal to right operand
  !=      Left operand is not equal to right operand

The operands are the numbers that are being compared. Integers are the only operands you should be comparing. You can compare different types of operands but it is not recommended. Here are some simple examples how relational operators can be used.

int x = 0;
int y = 1;

if (x >= 0 && y == 1)
  System.out.println("This statement is true");

if (x == 10 || !(y == 10))
  System.out.println("This statement is also true");

if ((x == 0 && y != 0) || (y <= -1))
  System.out.println("Once again, this statement is true");

If you can understand why all the statements above will print out a message, then you have a firm grasp on logical and relational operators. Make sure you know them well since you will use them on a regular basis.

Comparing Strings

Strings are a very large subject so we will only touch the basics about comparing strings in this section. The first way to compare strings is by using the relational operators. The most common approach is to use the == to see if two strings are equal. Here is an example on how strings can be compared.

String str1 = "hello";
String str2 = "hello";

if (str1 == str2)
  System.out.println("The strings are equal");
else
  System.out.println("The strings are not equal");

The example above will print out "The strings are equal". It seems simple enough. However, when using the == to compare strings, it will compare by reference instead of by value. Another example will help demonstrate what this means.

String str1 = "hello";
String str2 = "he";
String str3 = "llo";
str2 = str2 + str3; // The value is now "hello".

if (str1 == str2)
  System.out.println("The strings are equal");
else
  System.out.println("The strings are not equal");

What will be the output of the code above? If you said "The strings are equal" because "hello" is equal to "hello" even though they are concatenated together, you are wrong. We will avoid explaining the details for now. All you need to know is that the values of the strings are NOT being compared. This will vary between every programming language. In C# you may compare by values or by references, while in Java you can compare references only.

There is a safer way to compare strings. The Java String API contains dozens of useful methods, but we will only look at one. The "equals" method is a great way to compare the values between two strings. Here is the same code as above using the "equals" method for comparison.

String str1 = "hello";
String str2 = "he";
String str3 = "llo";
str2 = str2 + str3; // The value is now "hello".

if (str1.equals(str2))
  System.out.println("The strings are equal");
else
  System.out.println("The strings are not equal");

This time the program will print out "The strings are equal". The "equals" method takes the value of "str1" and compares it to the value of "str2". Since the value of both are "hello", they are considered equal, and true will be the result of the condition.

Note that the "equals" method is case sensitive. Therefore, "HELLO" and "hello" are not considered to be equal. However, the Java String API has an "equalsIgnoreCase" method which would consider the above strings to be equal.

That concludes our introduction for comparing strings. Just be aware that there are other ways to compare strings, but most of them are beyond the scope of this class.

Nesting

If-Else Ladders

A Second Example

The following program asks the user for two sports scores and tells the user which team won or if the game was a draw. The key components to pay attention to are lines 07 to 14.

00 public static void main(String[] args)
01 {
02    int scoreA, scoreB;
03    
04    scoreA = Integer.parseInt(JOptionPane.showInputDialog(null,"Enter Team A's score"));
05    scoreB = Integer.parseInt(JOptionPane.showInputDialog(null,"Enter Team B's score"));
06
07    if(scoreA > scoreB)
08    {
09        System.out.println("Team A won");
10    }//if
11
12    else if(scoreA < scoreB)
13    {
14        System.out.println("Team B won");
15    }//else if
16
17    else
18    {
19        System.out.println("The game was a draw");
20    }//else
21 }//main

Review Questions and Exercises

The solutions to these excercises can be found here

1. Name the 3 different logical operators. What are the benefits of using logical operators?

2. What is the proper way in Java to compare strings? Why?

3. Look at the code below. Clean it up so it uses the proper logical operators and proper use of if-else's.

if (x == 1)
{
  if (y == 1)
  {
    if (!!!!true)
    {
      System.out.println("X and Y are 1!");
    }
  }
}
if (x == 2)
{
  System.out.println("X is 2!");
}
if (x < 1)
{
  System.out.println("X is under 1 or over 2!");
}
if (x > 2)
{
  System.out.println("X is under 1 or over 2!");
}

4. Is the result of the following statement true or false?

String s1 = "test";
String s2 = "TEST";
String s3 = "test";

if (!(!(s1.equals(s2) && s1.equals(s3)) || s2.equals(s3)))
  System.out.println("The result is true");
else
  System.out.println("The result is false");

Template loop detected: Template loop detected: