if...else Double-Selection Statement

The if single-selection statement performs an indicated action only when the condition is true; otherwise, the action is skipped. The if...else double-selection statement allows the programmer to specify an action to perform when the condition is true and a different action when the condition is false. For example, the pseudocode statement

      If student's grade is greater than or equal to 60
            Print "Passed"
      Else
            Print "Failed"

prints "Passed" if the student's grade is greater than or equal to 60, but prints "Failed" if it is less than 60. In either case, after printing occurs, the next pseudocode statement in sequence is "performed."

The preceding If...Else pseudocode statement can be written in Java as

 if ( grade >= 60 )
 System.out.println( "Passed" );
 else
 System.out.println( "Failed" );

Note that the body of the else is also indented. Whatever indentation convention you choose should be applied consistently throughout your programs. It is difficult to read programs that do not obey uniform spacing conventions.

Good Programming Practice 4.1

Indent both body statements of an if...else statement.

Good Programming Practice 4.2

If there are several levels of indentation, each level should be indented the same additional amount of space.

Figure 4.3 illustrates the flow of control in the if...else statement. Once again, the symbols in the UML activity diagram (besides the initial state, transition arrows and final state) represent action states and decisions. We continue to emphasize this action/decision model of computing. Imagine again a deep bin containing as many empty if...else statements as might be needed to build any Java program. Your job is to assemble these if...else statements (by stacking and nesting) with any other control statements required by the algorithm. You fill in the action states and decision symbols with action expressions and guard conditions appropriate to the algorithm you are developing.

Figure 4.3. if...else double-selection statement UML activity diagram.

 

Conditional Operator (?:)

Java provides the conditional operator (?:) that can be used in place of an if...else statement. This is Java's only ternary operatorthis means that it takes three operands. Together, the operands and the ?: symbol form a conditional expression. The first operand (to the left of the ?) is a boolean expression (i.e., a condition that evaluates to a boolean valuetrue or false), the second operand (between the ? and :) is the value of the conditional expression if the boolean expression is TRue and the third operand (to the right of the :) is the value of the conditional expression if the boolean expression evaluates to false. For example, the statement

 System.out.println( studentGrade >= 60 ? "Passed" : "Failed" );

prints the value of println's conditional-expression argument. The conditional expression in this statement evaluates to the string "Passed" if the boolean expression studentGrade >= 60 is true and evaluates to the string "Failed" if the boolean expression is false. Thus, this statement with the conditional operator performs essentially the same function as the if...else statement shown earlier in this section. The precedence of the conditional operator is low, so the entire conditional expression is normally placed in parentheses. We will see that conditional expressions can be used in some situations where if...else statements cannot.

Good Programming Practice 4.3

Conditional expressions are more difficult to read than if...else statements and should be used to replace only simple if...else statements that choose between two values.

Nested if...else Statements

A program can test multiple cases by placing if...else statements inside other if...else statements to create nested if...else statements. For example, the following pseudocode represents a nested if...else that prints A for exam grades greater than or equal to 90, B for grades in the range 80 to 89, C for grades in the range 70 to 79, D for grades in the range 60 to 69 and F for all other grades:

      If student's grade is greater than or equal to 90
            Print "A"
      else
            If student's grade is greater than or equal to 80
                  Print "B"
            else
                  If student's grade is greater than or equal to 70
                        Print "C"
                  else
                        If student's grade is greater than or equal to 60
                              Print "D"
                        else
                              Print "F"

This pseudocode may be written in Java as

 if ( studentGrade >= 90 )
 System.out.println( "A" );
 else
 if ( studentGrade >= 80 )
 System.out.println( "B" );
 else
 if ( studentGrade >= 70 )
 System.out.println( "C" );
 else
 if ( studentGrade >= 60 )
 System.out.println( "D" );
 else
 System.out.println( "F" );

If studentGrade is greater than or equal to 90, the first four conditions will be true, but only the statement in the if-part of the first if...else statement will execute. After that statement executes, the else-part of the "outermost" if...else statement is skipped. Most Java programmers prefer to write the preceding if...else statement as

 if ( studentGrade >= 90 )
 System.out.println( "A" );
 else if ( studentGrade >= 80 )
 System.out.println( "B" );
 else if ( studentGrade >= 70 )
 System.out.println( "C" );
 else if ( studentGrade >= 60 )
 System.out.println( "D" );
 else
 System.out.println( "F" );

The two forms are identical except for the spacing and indentation, which the compiler ignores. The latter form is popular because it avoids deep indentation of the code to the right. Such indentation often leaves little room on a line of code, forcing lines to be split and decreasing program readability.

Dangling-else Problem

The Java compiler always associates an else with the immediately preceding if unless told to do otherwise by the placement of braces ({ and }). This behavior can lead to what is referred to as the dangling-else problem. For example,

 if ( x > 5 )
 if ( y > 5 )
 System.out.println( "x and y are > 5" );
 else
 System.out.println( "x is <= 5" );

appears to indicate that if x is greater than 5, the nested if statement determines whether y is also greater than 5. If so, the string "x and y are > 5" is output. Otherwise, it appears that if x is not greater than 5, the else part of the if...else outputs the string "x is <= 5".

Beware! This nested if...else statement does not execute as it appears. The compiler actually interprets the statement as

 if ( x > 5 )
 if ( y > 5 )
 System.out.println( "x and y are > 5" );
 else
 System.out.println( "x is <= 5" );

in which the body of the first if is a nested if...else. The outer if statement tests whether x is greater than 5. If so, execution continues by testing whether y is also greater than 5. If the second condition is true, the proper string"x and y are > 5"is displayed. However, if the second condition is false, the string "x is <= 5" is displayed, even though we know that x is greater than 5.

To force the nested if...else statement to execute as it was originally intended, we must write it as follows:

 if ( x > 5 )
 {
 if ( y > 5 )
 System.out.println( "x and y are > 5" );
 }
 else
 System.out.println( "x is <= 5" );

The braces ({}) indicate to the compiler that the second if statement is in the body of the first if and that the else is associated with the first if. Exercise 4.27 and Exercise 4.28 investigate the dangling-else problem further.

Blocks

The if statement normally expects only one statement in its body. To include several statements in the body of an if (or the body of an else for an if...else statement), enclose the statements in braces ({ and }). A set of statements contained within a pair of braces is called a block. A block can be placed anywhere in a program that a single statement can be placed.

The following example includes a block in the else-part of an if...else statement:

 if ( grade >= 60 )
 System.out.println( "Passed" );
 else
 {
 System.out.println( "Failed" );
 System.out.println( "You must take this course again." );
 }

In this case, if grade is less than 60, the program executes both statements in the body of the else and prints

 Failed.
 You must take this course again.

Note the braces surrounding the two statements in the else clause. These braces are important. Without the braces, the statement

 System.out.println( "You must take this course again." );

would be outside the body of the else-part of the if...else statement and would execute regardless of whether the grade was less than 60.

Syntax errors (e.g., when one brace in a block is left out of the program) are caught by the compiler. A logic error (e.g., when both braces in a block are left out of the program) has its effect at execution time. A fatal logic error causes a program to fail and terminate prematurely. A nonfatal logic error allows a program to continue executing, but causes the program to produce incorrect results.

Common Programming Error 4.1

Forgetting one or both of the braces that delimit a block can lead to syntax errors or logic errors in a program.

Good Programming Practice 4.4

Always using braces in an if...else (or other) statement helps prevent their accidental omission, especially when adding statements to the if-part or the else-part at a later time. To avoid omitting one or both of the braces, some programmers type the beginning and ending braces of blocks before typing the individual statements within the braces.

Just as a block can be placed anywhere a single statement can be placed, it is also possible to have an empty statement. Recall from Section 2.8 that the empty statement is represented by placing a semicolon (;) where a statement would normally be.

Common Programming Error 4.2

Placing a semicolon after the condition in an if or if...else statement leads to a logic error in single-selection if statements and a syntax error in double-selection if...else statements (when the if-part contains an actual body statement).