C. Control Statements

1. the actions to execute and

2. the order in which these actions execute

is called an algorithm. Correctly specifying the order in which the actions execute is important.

Consider the “rise-and-shine algorithm” followed by one executive for getting out of bed and going to work: (1) Get out of bed; (2) take off pajamas; (3) take a shower; (4) get dressed; (5) eat breakfast; (6) carpool to work. This routine gets the executive to work well prepared to make critical decisions. Suppose that the same steps are performed in a slightly different order: (1) Get out of bed; (2) take off pajamas; (3) get dressed; (4) take a shower; (5) eat breakfast; (6) carpool to work. In this case, our executive shows up for work soaking wet. Specifying the order in which statements (actions) execute in a program is called program control. This appendix investigates program control using Java’s control statements.

Pseudocode does not execute on computers. Rather, it helps you “think out” a program before attempting to write it in a programming language, such as Java. Pseudocode normally describes only statements representing the actions that occur after you convert a program from pseudocode to Java and the program is run on a computer. Such actions might include input, output or calculations.

During the 1960s, it became clear that the indiscriminate use of transfers of control was the root of much difficulty experienced by software development groups. The blame was pointed at the goto statement (used in most programming languages of the time), which allows you to specify a transfer of control to one of a wide range of destinations in a program. The term structured programming became almost synonymous with “goto elimination.” [Note: Java does not have a goto statement; however, the word goto is reserved by Java and should not be used as an identifier in programs.]

Research had demonstrated that programs could be written without any goto statements. The challenge of the era for programmers was to shift their styles to “goto-less programming.” Not until the 1970s did most programmers start taking structured programming seriously. The results were impressive. The key to these successes was that structured programs were clearer, easier to debug and modify, and more likely to be bug free in the first place.

Researchers demonstrated that all programs could be written in terms of only three control structures—the sequence structure, the selection structure and the repetition structure. When we introduce Java’s control structure implementations, we’ll refer to them in the terminology of the Java Language Specification as “control statements.”

The if statement is a single-selection statement because it selects or ignores a single action (or, as we’ll soon see, a single group of actions). The if...else statement is called a double-selection statement because it selects between two different actions (or groups of actions). The switch statement is called a multiple-selection statement because it selects among many different actions (or groups of actions).

determines whether the condition “student’s grade is greater than or equal to 60” is true. If so, “Passed” is printed, and the next pseudocode statement in order is “performed.” If the condition is false, the Print statement is ignored, and the next pseudocode statement in order is performed.

The preceding pseudocode If statement easily may be converted to the Java statement

Click here to view code image

prints “Passed” if the student’s grade is greater than or equal to 60, but prints “Failed” if it’s 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

Click here to view code image

Click here to view code image

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 to the string "Failed" if it’s 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.

This pseudocode may be written in Java as

Click here to view code image

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 variable studentGrade is greater than or equal to 90, the first four conditions in the nested if...else statement 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. Many programmers prefer to write the preceding nested if...else statement as

Click here to view code image

The two forms are identical except for the spacing and indentation, which the compiler ignores. The latter form avoids deep indentation of the code to the right.

Click here to view code image

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

Click here to view code image

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

Click here to view code image

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 it to produce incorrect results.

When this while statement begins execution, the value of variable product is 3. Each iteration of the while statement multiplies product by 3, so product takes on the values 9, 27, 81 and 243 successively. When variable product becomes 243, the while-statement condition—product <= 100—becomes false. This terminates the repetition, so the final value of product is 243. At this point, program execution continues with the next statement after the while statement.

A class of ten students took a quiz. The grades (integers in the range 0 to 100) for this quiz are available to you. Determine the class average on the quiz.

The class average is equal to the sum of the grades divided by the number of students. The algorithm for solving this problem on a computer must input each grade, keep track of the total of all grades input, perform the averaging calculation and print the result.

Note the references in the algorithm of Fig. C.1 to a total and a counter. A total is a variable used to accumulate the sum of several values. A counter is a variable used to count—in this case, the grade counter indicates which of the 10 grades is about to be entered by the user. Variables used to store totals are normally initialized to zero before being used in a program.

Click here to view code image

Fig. C.1 | Pseudocode algorithm that uses counter-controlled repetition to solve the class-average problem.

Line 40 declares and initializes Scanner variable input, which is used to read values entered by the user. Lines 42–45 declare local variables total, gradeCounter, grade and average to be of type int. Variable grade stores the user input.

Click here to view code image

Fig. C.2 | GradeBook class that solves the class-average problem using counter-controlled repetition.

The declarations (in lines 42–45) appear in the body of method determineClassAverage. A local variable’s declaration must appear before the variable is used in that method. A local variable cannot be accessed outside the method in which it’s declared.

The assignments (in lines 48–49) initialize total to 0 and gradeCounter to 1. Line 52 indicates that the while statement should continue looping (also called iterating) as long as gradeCounter’s value is less than or equal to 10. While this condition remains true, the while statement repeatedly executes the statements between the braces that delimit its body (lines 54–57).

Line 54 displays the prompt "Enter grade: ". Line 55 reads the grade entered by the user and assigns it to variable grade. Then line 56 adds the new grade entered by the user to the total and assigns the result to total, which replaces its previous value.

Line 57 adds 1 to gradeCounter to indicate that the program has processed a grade and is ready to input the next grade from the user. Incrementing gradeCounter eventually causes it to exceed 10. Then the loop terminates, because its condition (line 52) becomes false.

When the loop terminates, line 61 performs the averaging calculation and assigns its result to the variable average. Line 64 uses System.out’s printf method to display the text "Total of all 10 grades is " followed by variable total’s value. Line 65 then uses printf to display the text "Class average is " followed by variable average’s value. After reaching line 66, method determineClassAverage returns control to the calling method (i.e., main in GradeBookTest of Fig. C.3).

Click here to view code image

Fig. C.3 | GradeBookTest class creates an object of class GradeBook (Fig. C.2) and invokes its determineClassAverage method.

Develop a class-averaging program that processes grades for an arbitrary number of students each time it’s run.

In the previous class-average example, the problem statement specified the number of students, so the number of grades (10) was known in advance. In this example, no indication is given of how many grades the user will enter during the program’s execution. The program must process an arbitrary number of grades. How can it determine when to stop reading grades from the user? How will it know when to calculate and print the class average?

One way to solve this problem is to use a special value called a sentinel value (also called a signal value, a dummy value or a flag value) to indicate “end of data entry.” The user enters grades until all legitimate grades have been entered. The user then types the sentinel value to indicate that no more grades will be entered. Sentinel-controlled repetition is often called indefinite repetition because the number of repetitions is not known before the loop begins executing.

Clearly, a sentinel value must be chosen that cannot be confused with an acceptable input value. Grades on a quiz are nonnegative integers, so –1 is an acceptable sentinel value for this problem. Thus, a run of the class-average program might process a stream of inputs such as 95, 96, 75, 74, 89 and —1. The program would then compute and print the class average for the grades 95, 96, 75, 74 and 89; since —1 is the sentinel value, it should not enter into the averaging calculation. The complete pseudocode for the class-average problem is shown in Fig. C.4.

Click here to view code image

Fig. C.4 | Class-average problem pseudocode algorithm with sentinel-controlled repetition.

Click here to view code image

Fig. C.5 | GradeBook class that solves the class-average problem using sentinel-controlled repetition.

In this example, we see that control statements may be stacked on top of one another (in sequence). The while statement (lines 57–65) is followed in sequence by an if...else statement (lines 69–80). Much of the code in this program is identical to that in Fig. C.2, so we concentrate on the new concepts.

Line 45 declares double variable average, which allows us to store the class average as a floating-point number. Line 49 initializes gradeCounter to 0, because no grades have been entered yet. To keep an accurate record of the number of grades entered, the program increments gradeCounter only when the user enters a valid grade.

After the loop terminates, the if...else statement at lines 69–80 executes. The condition at line 69 determines whether any grades were input. If none were input, the else part (lines 79–80) of the if...else statement executes and displays the message "No grades were entered" and the method returns control to the calling method.

Click here to view code image

loses the fractional part of the quotient before the result of the division is assigned to average. This occurs because total and gradeCounter are both integers, and integer division yields an integer result. To perform a floating-point calculation with integer values, we must temporarily treat these values as floating-point numbers for use in the calculation. Java provides the unary cast operator to accomplish this task. Line 72 uses the (double) cast operator—a unary operator—to create a temporary floating-point copy of its operand total (which appears to the right of the operator). Using a cast operator in this manner is called explicit conversion or type casting. The value stored in total is still an integer.

The calculation now consists of a floating-point value (the temporary double version of total) divided by the integer gradeCounter. Java knows how to evaluate only arithmetic expressions in which the operands' types are identical. To ensure that the operands are of the same type, Java performs an operation called promotion (or implicit conversion) on selected operands. For example, in an expression containing values of the types int and double, the int values are promoted to double values for use in the expression. In this example, the value of gradeCounter is promoted to type double, then the floating-point division is performed and the result of the calculation is assigned to average. As long as the (double) cast operator is applied to any variable in the calculation, the calculation will yield a double result.

A cast operator is formed by placing parentheses around any type’s name. The operator is a unary operator (i.e., an operator that takes only one operand). Java also supports unary versions of the plus (+) and minus (—) operators, so you can write expressions like -7 or +5. Cast operators associate from right to left and have the same precedence as other unary operators, such as unary + and unary -. (See the operator precedence chart in Appendix K.)

Line 77 displays the class average. In this example, we display the class average rounded to the nearest hundredth. The format specifier %.2f in printf’s format control string indicates that variable average’s value should be displayed with two digits of precision to the right of the decimal point—indicated by.2 in the format specifier. The three grades entered during the sample execution of class GradeBookTest (Fig. C.6) total 257, which yields the average 85.666666.... Method printf uses the precision in the format specifier to round the value to the specified number of digits. In this program, the average is rounded to the hundredths position and is displayed as 85.67.

Click here to view code image

Fig. C.6 | GradeBookTest class creates an object of class GradeBook (Fig. C.5) and invokes its determineClassAverage method.

Consider the following problem statement:

A college offers a course that prepares students for the state licensing exam for real estate brokers. Last year, ten of the students who completed this course took the exam. The college wants to know how well its students did on the exam. You’ve been asked to write a program to summarize the results. You’ve been given a list of these 10 students. Next to each name is written a 1 if the student passed the exam or a 2 if the student failed.

Your program should analyze the results of the exam as follows:

1. Input each test result (i.e., a 1 or a 2). Display the message “Enter result” on the screen each time the program requests another test result.

2. Count the number of test results of each type.

3. Display a summary of the test results, indicating the number of students who passed and the number who failed.

4. If more than eight students passed the exam, print the message “Bonus to instructor!”

The complete pseudocode appears in Fig. C.7. The Java class that implements the pseudocode algorithm and two sample executions are shown in Fig. C.8. Lines 13–16 of main declare the variables that method processExamResults of class Analysis uses to process the examination results. Several of these declarations use Java’s ability to incorporate variable initialization into declarations (passes is assigned 0, failures 0 and studentCounter 1). Looping programs may require initialization at the beginning of each repetition—normally performed by assignment statements rather than in declarations. Java requires that local variables be initialized before their values are used in an expression.

Click here to view code image

Fig. C.7 | Pseudocode for examination-results problem.

The while statement (lines 19–33) loops 10 times. During each iteration, the loop inputs and processes one exam result. Notice that the if...else statement (lines 26–29) for processing each result is nested in the while statement. If the result is 1, the if...else statement increments passes; otherwise, it assumes the result is 2 and increments failures. Line 32 increments studentCounter before the loop condition is tested again at line 19. After 10 values have been input, the loop terminates and line 36 displays the number of passes and failures. The if statement at lines 39–40 determines whether more than eight students passed the exam and, if so, outputs the message "Bonus to instructor!".

Click here to view code image

Fig. C.8 | Analysis of examination results using nested control statements.

During the sample execution, the condition at line 39 of method main is true—more than eight students passed the exam, so the program outputs a message to bonus the instructor.

This example contains only one class, with method main performing all the class’s work. Occasionally, when it does not make sense to try to create a reusable class to demonstrate a concept, we’ll place the program’s statements entirely within the main method of a single class.

Click here to view code image

where operator is one of the binary operators +, -, *, / or % (or others we discuss later in the text) can be written in the form

Click here to view code image

For example, you can abbreviate the statement

with the addition compound assignment operator, +=, as

The += operator adds the value of the expression on its right to the value of the variable on its left and stores the result in the variable on the left of the operator. Thus, the assignment expression c += 3 adds 3 to c. Figure C.9 shows the arithmetic compound assignment operators, sample expressions using the operators and explanations of what the operators do.

Using the prefix increment (or decrement) operator to add 1 to (or subtract 1 from) a variable is known as preincrementing (or predecrementing). This causes the variable to be incremented (decremented) by 1; then the new value of the variable is used in the expression in which it appears. Using the postfix increment (or decrement) operator to add 1 to (or subtract 1 from) a variable is known as postincrementing (or postdecrementing). This causes the current value of the variable to be used in the expression in which it appears; then the variable’s value is incremented (decremented) by 1.

Figure C.11 demonstrates the difference between the prefix increment and postfix increment versions of the ++ increment operator. The decrement operator (--) works similarly. Line 11 initializes the variable c to 5, and line 12 outputs c’s initial value. Line 13 outputs the value of the expression c++. This expression postincrements the variable c, so c’s original value (5) is output, then c’s value is incremented (to 6). Thus, line 13 outputs c’s initial value (5) again. Line 14 outputs c’s new value (6) to prove that the variable’s value was indeed incremented in line 13.

Click here to view code image

Fig. C.11 | Preincrementing and postincrementing.

Line 19 resets c’s value to 5, and line 20 outputs c’s value. Line 21 outputs the value of the expression ++c. This expression preincrements c, so its value is incremented; then the new value (6) is output. Line 22 outputs c’s value again to show that the value of c is still 6 after line 21 executes.

When incrementing or decrementing a variable in a statement by itself, the prefix increment and postfix increment forms have the same effect, and the prefix decrement and postfix decrement forms have the same effect. It’s only when a variable appears in the context of a larger expression that preincrementing and postincrementing the variable have different effects (and similarly for predecrementing and postdecrementing).

In C and C++, programmers frequently have to write separate versions of programs to support different computer platforms, because the primitive types are not guaranteed to be identical from computer to computer. For example, an int value on one machine might be represented by 16 bits (2 bytes) of memory, on a second machine by 32 bits (4 bytes) of memory, and on another machine by 64 bits (8 bytes) of memory. In Java, int values are always 32 bits (4 bytes).

Each type in Appendix L is listed with its size in bits (there are eight bits to a byte) and its range of values. Because the designers of Java want to ensure portability, they use internationally recognized standards for character formats (Unicode; for more information, visit www.unicode.org) and floating-point numbers (IEEE 754; for more information, visit grouper.ieee.org/groups/754/).

1. a control variable (or loop counter)

2. the initial value of the control variable

3. the increment (or decrement) by which the control variable is modified each time through the loop (also known as each iteration of the loop)

4. the loop-continuation condition that determines if looping should continue.

To see these elements of counter-controlled repetition, consider the application of Fig. C.12, which uses a loop to display the numbers from 1 through 10.

Click here to view code image

Fig. C.12 | Counter-controlled repetition with the while repetition statement.

In Fig. C.12, the elements of counter-controlled repetition are defined in lines 8, 10 and 13. Line 8 declares the control variable (counter) as an int, reserves space for it in memory and sets its initial value to 1. Line 12 displays control variable counter’s value during each iteration of the loop. Line 13 increments the control variable by 1 for each iteration of the loop. The loop-continuation condition in the while (line 10) tests whether the value of the control variable is less than or equal to 10 (the final value for which the condition is true). The program performs the body of this while even when the control variable is 10. The loop terminates when the control variable exceeds 10 (i.e., counter becomes 11).

Click here to view code image

Fig. C.13 | Counter-controlled repetition with the for repetition statement.

When the for statement (lines 10–11) begins executing, the control variable counter is declared and initialized to 1. Next, the program checks the loop-continuation condition, counter <= 10, which is between the two required semicolons. Because the initial value of counter is 1, the condition initially is true. Therefore, the body statement (line 11) displays control variable counter’s value, namely 1. After executing the loop’s body, the program increments counter in the expression ++counter, which appears to the right of the second semicolon. Then the loop-continuation test is performed again to determine whether the program should continue with the next iteration of the loop. At this point, the control variable’s value is 2, so the condition is still true (the final value is not exceeded)—thus, the program performs the body statement again (i.e., the next iteration of the loop). This process continues until the numbers 1 through 10 have been displayed and the counter’s value becomes 11, causing the loop-continuation test to fail and repetition to terminate (after 10 repetitions of the loop body). Then the program performs the first statement after the for—in this case, line 13.

Figure C.13 uses (in line 10) the loop-continuation condition counter <= 10. If you incorrectly specified counter < 10 as the condition, the loop would iterate only nine times. This is a common logic error called an off-by-one error.

a) Vary the control variable from 1 to 100 in increments of 1.

Click here to view code image

b) Vary the control variable from 100 to 1 in decrements of 1.

Click here to view code image

c) Vary the control variable from 7 to 77 in increments of 7.

Click here to view code image

d) Vary the control variable from 20 to 2 in decrements of 2.

Click here to view code image

e) Vary the control variable over the values 2, 5, 8, 11, 14, 17, 20.

Click here to view code image

f) Vary the control variable over the values 99, 88, 77, 66, 55, 44, 33, 22, 11, 0.

Click here to view code image

A person invests $1000 in a savings account yielding 5% interest. Assuming that all the interest is left on deposit, calculate and print the amount of money in the account at the end of each year for 10 years. Use the following formula to determine the amounts:

a = p(1 + r)ⁿ

where

p is the original amount invested (i.e., the principal)

r is the annual interest rate (e.g., use 0.05 for 5%)

n is the number of years

a is the amount on deposit at the end of the nth year.

The solution to this problem (Fig. C.15) involves a loop that performs the indicated calculation for each of the 10 years the money remains on deposit. Lines 8–10 in method main declare double variables amount, principal and rate, and initialize principal to 1000.0 and rate to 0.05. Java treats floating-point constants like 1000.0 and 0.05 as type double. Similarly, Java treats whole-number constants like 7 and -22 as type int.

Click here to view code image

Fig. C.15 | Compound-interest calculations with for.

Classes provide methods that perform common tasks on objects. In fact, most methods must be called on a specific object. For example, to output text in Fig. C.15, line 13 calls method printf on the System.out object. Many classes also provide methods that perform common tasks and do not require objects. These are called static methods. For example, Java does not include an exponentiation operator, so the designers of Java’s Math class defined static method pow for raising a value to a power. You can call a static method by specifying the class name followed by a dot (.) and the method name, as in

Click here to view code image

In Appendix D, you’ll learn how to implement static methods in your own classes.

We use static method pow of class Math to perform the compound-interest calculation in Fig. C.15. Math.pow(x, y ) calculates the value of x raised to the y^th power. The method receives two double arguments and returns a double value. Line 19 performs the calculation a = p(1 + r)ⁿ, where a is amount, p is principal, r is rate and n is year. Class Math is defined in package java.lang, so you do not need to import class Math to use it.

Click here to view code image

Fig. C.16 | do...while repetition statement.

Line 8 declares and initializes control variable counter. Upon entering the do...while statement, line 12 outputs counter’s value and line 13 increments counter. Then the program evaluates the loop-continuation test at the bottom of the loop (line 14). If the condition is true, the loop continues from the first body statement (line 12). If the condition is false, the loop terminates and the program continues with the next statement after the loop.

Click here to view code image

Fig. C.17 | GradeBook class uses the switch statement to count letter grades.

Like earlier versions of the class, class GradeBook (Fig. C.17) declares instance variable courseName (line 7) and contains methods setCourseName (lines 24–27), getCourseName (lines 30–33) and displayMessage (lines 36–41), which set the course name, store the course name and display a welcome message to the user, respectively. The class also contains a constructor (lines 18–21) that initializes the course name.

Class GradeBook also declares instance variables total (line 9) and gradeCounter (line 10), which keep track of the sum of the grades entered by the user and the number of grades entered, respectively. Lines 11–15 declare counter variables for each grade category. Class GradeBook maintains total, gradeCounter and the five letter-grade counters as instance variables so that they can be used or modified in any of the class’s methods. The class’s constructor (lines 18–21) sets only the course name, because the remaining seven instance variables are ints and are initialized to 0 by default.

Class GradeBook contains three additional methods—inputGrades, incrementLetterGradeCounter and displayGradeReport. Method inputGrades (lines 44–66) reads an arbitrary number of integer grades from the user using sentinel-controlled repetition and updates instance variables total and gradeCounter. This method calls method incrementLetterGradeCounter (lines 69–95) to update the appropriate letter-grade counter for each grade entered. Method displayGradeReport (lines 98–122) outputs a report containing the total of all grades entered, the average of the grades and the number of students who received each letter grade. Let’s examine these methods in more detail.

On UNIX/Linux/Mac OS X systems, end-of-file is entered by typing the sequence

on a line by itself. This notation means to simultaneously press both the Ctrl key and the d key. On Windows systems, end-of-file can be entered by typing

[Note: On some systems, you must press Enter after typing the end-of-file key sequence. Also, Windows typically displays the characters ^Z on the screen when the end-of-file indicator is typed, as shown in the output of Fig. C.18.]

The while statement (lines 57–65) obtains the user input. The condition at line 57 calls Scanner method hasNext to determine whether there’s more data to input. This method returns the boolean value true if there’s more data; otherwise, it returns false. The returned value is then used as the value of the condition in the while statement. Method hasNext returns false once the user types the end-of-file indicator.

Line 59 inputs a grade value from the user. Line 60 adds grade to total. Line 61 increments gradeCounter. The class’s displayGradeReport method uses these variables to compute the average of the grades. Line 64 calls the class’s incrementLetterGradeCounter method (declared in lines 69–95) to increment the appropriate letter-grade counter based on the numeric grade entered.

When the flow of control reaches the switch, the program evaluates the expression in the parentheses (grade / 10) following keyword switch. This is the switch’s controlling expression. The program compares this expression’s value (which must evaluate to an integral value of type byte, char, short or int) with each case label. The controlling expression in line 72 performs integer division, which truncates the fractional part of the result. Thus, when we divide a value from 0 to 100 by 10, the result is always a value from 0 to 10. We use several of these values in our case labels. For example, if the user enters the integer 85, the controlling expression evaluates to 8. The switch compares 8 with each case label. If a match occurs (case 8: at line 79), the program executes that case’s statements. For the integer 8, line 80 increments bCount, because a grade in the 80s is a B. The break statement (line 81) causes program control to proceed with the first statement after the switch—in this program, we reach the end of method incrementLetterGradeCounter’s body, so the method terminates and control returns to line 65 in method inputGrades (the first line after the call to incrementLetterGradeCounter). Line 65 is the end of a while loop’s body, so control flows to the while’s condition (line 57) to determine whether the loop should continue executing.

The cases in our switch explicitly test for the values 10, 9, 8, 7 and 6. Note the cases at lines 74–75 that test for the values 9 and 10 (both of which represent the grade A). Listing cases consecutively in this manner with no statements between them enables the cases to perform the same set of statements—when the controlling expression evaluates to 9 or 10, the statements in lines 76–77 will execute. The switch statement does not provide a mechanism for testing ranges of values, so every value you need to test must be listed in a separate case label. Each case can have multiple statements. The switch statement differs from other control statements in that it does not require braces around multiple statements in a case.

Without break statements, each time a match occurs in the switch, the statements for that case and subsequent cases execute until a break statement or the end of the switch is encountered. (This feature is helpful for writing a concise program that displays the iterative song “The Twelve Days of Christmas”).

If no match occurs between the controlling expression’s value and a case label, the default case (lines 91–93) executes. We use the default case in this example to process all controlling-expression values that are less than 6—that is, all failing grades. If no match occurs and the switch does not contain a default case, program control simply continues with the first statement after the switch.

Click here to view code image

Fig. C.18 | Create GradeBook object, input grades and display grade report.

Class GradeBookTest (Fig. C.18) does not directly call GradeBook method incrementLetterGradeCounter (lines 69–95 of Fig. C.17). This method is used exclusively by method inputGrades of class GradeBook to update the appropriate letter-grade counter as each new grade is entered by the user. Method incrementLetterGradeCounter exists solely to support the operations of GradeBook’s other methods, so it’s declared private.

The break statement is not required for the switch’s last case (or the optional default case, when it appears last), because execution continues with the next statement after the switch.

The expression in each case can also be a constant variable—a variable containing a value which does not change for the entire program. Such a variable is declared with keyword final (discussed in Appendix D). Java has a feature called enumerations, which we also present in Appendix D. Enumeration constants can also be used in case labels.

Click here to view code image

This if statement contains two simple conditions. The condition gender == FEMALE compares variable gender to the constant FEMALE to determine whether a person is female. The condition age >= 65 might be evaluated to determine whether a person is a senior citizen. The if statement considers the combined condition

which is true if and only if both simple conditions are true. In this case, the if statement’s body increments seniorFemales by 1. If either or both of the simple conditions are false, the program skips the increment. Some programmers find that the preceding combined condition is more readable when redundant parentheses are added, as in:

Click here to view code image

The table in Fig. C.19 summarizes the && operator. The table shows all four possible combinations of false and true values for expression1 and expression2. Such tables are called truth tables. Java evaluates to false or true all expressions that include relational operators, equality operators or logical operators.

Click here to view code image

This statement also contains two simple conditions. The condition semesterAverage >= 90 evaluates to determine whether the student deserves an A in the course because of a solid performance throughout the semester. The condition finalExam >= 90 evaluates to determine whether the student deserves an A in the course because of an outstanding performance on the final exam. The if statement then considers the combined condition

Click here to view code image

and awards the student an A if either or both of the simple conditions are true. The only time the message "Student grade is A" is not printed is when both of the simple conditions are false. Figure C.20 is a truth table for operator conditional OR (||). Operator && has a higher precedence than operator ||. Both operators associate from left to right.

Click here to view code image

stops immediately if gender is not equal to FEMALE (i.e., the entire expression is false) and continues if gender is equal to FEMALE (i.e., the entire expression could still be true if the condition age >= 65 is true). This feature of conditional AND and conditional OR expressions is called short-circuit evaluation.

Click here to view code image

evaluates age >= 65 regardless of whether gender is equal to 1. This is useful if the right operand of the boolean logical AND or boolean logical inclusive OR operator has a required side effect—a modification of a variable’s value. For example, the expression

Click here to view code image

guarantees that the condition ++age >= 65 will be evaluated. Thus, the variable age is incremented, regardless of whether the overall expression is true or false.

Click here to view code image

which executes the printf call only if grade is not equal to sentinelValue. The parentheses around the condition grade == sentinelValue are needed because the logical negation operator has a higher precedence than the equality operator.

In most cases, you can avoid using logical negation by expressing the condition differently with an appropriate relational or equality operator. For example, the previous statement may also be written as follows:

Click here to view code image

This flexibility can help you express a condition in a more convenient manner. Figure C.22 is a truth table for the logical negation operator.

Only three types of control structures—sequence, selection and repetition—are needed to develop any problem-solving algorithm. Specifically, this appendix demonstrated the if single-selection statement, the if...else double-selection statement and the while repetition statement. These are some of the building blocks used to construct solutions to many problems. We used control-statement stacking to total and compute the average of a set of student grades with counter- and sentinel-controlled repetition, and we used control-statement nesting to analyze and make decisions based on a set of exam results. We introduced Java’s compound assignment operators and its increment and decrement operators. We discussed Java’s primitive types.

We demonstrated the for, do...while and switch statements. We showed that any algorithm can be developed using combinations of the sequence structure (i.e., statements listed in the order in which they should execute), the three types of selection statements—if, if...else and switch—and the three types of repetition statements—while, do...while and for. We discussed how you can combine these building blocks to utilize proven program-construction and problem-solving techniques. We also introduced Java’s logical operators, which enable you to use more complex conditional expressions in control statements. In Appendix D, we examine methods in greater depth.

a) All programs can be written in terms of three types of control structures: __________, __________ and __________.

b) The __________ statement is used to execute one action when a condition is true and another when that condition is false.

c) When it’s not known in advance how many times a set of statements will be repeated, a(n) __________ value can be used to terminate the repetition.

d) Java is a(n) __________ language; it requires all variables to have a type.

e) If the increment operator is __________ to a variable, first the variable is incremented by 1, then its new value is used in the expression.

C.2 State whether each of the following is true or false. If false, explain why.

a) A set of statements contained within a pair of parentheses is called a block.

b) A selection statement specifies that an action is to be repeated while some condition remains true.

c) A nested control statement appears in the body of another control statement.

d) Specifying the order in which statements execute in a program is called program control.

e) Instance variables of type boolean are given the value true by default.

C.3 Write Java statements to accomplish each of the following tasks:

a) Use one statement to assign the sum of x and y to z, then increment x by 1.

b) Test whether variable count is greater than 10. If it is, print "Count is greater than 10".

c) Use one statement to decrement the variable x by 1, then subtract it from variable total and store the result in variable total.

d) Calculate the remainder after q is divided by divisor, and assign the result to q. Write this statement in two different ways.

C.4 Write a Java statement to accomplish each of the following tasks:

a) Declare variables sum and x to be of type int.

b) Assign 1 to variable x.

c) Assign 0 to variable sum.

d) Add variable x to variable sum, and assign the result to variable sum.

e) Print "The sum is: ", followed by the value of variable sum.

C.5 Determine the value of the variables in the statement product *= x++; after the calculation is performed. Assume that all variables are type int and initially have the value 5.

C.6 Identify and correct the errors in each of the following sets of code:

a)

while ( c <= 5 )
{
   product *= c;
   ++c;

b)

Click here to view code image

if ( gender == 1 )
   System.out.println( "Woman" );
else;
   System.out.println( "Man" );

C.7 What is wrong with the following while statement?

while ( z >= 0 )
    sum += z;

a) Typically, __________ statements are used for counter-controlled repetition and __________ statements for sentinel-controlled repetition.

b) The do...while statement tests the loop-continuation condition __________ executing the loop’s body; therefore, the body always executes at least once.

c) The __________ statement selects among multiple actions based on the possible values of an integer variable or expression.

d) The __________ operator can be used to ensure that two conditions are both true before choosing a certain path of execution.

e) If the loop-continuation condition in a for header is initially __________, the program does not execute the for statement’s body.

C.9 State whether each of the following is true or false. If false, explain why.

a) The default case is required in the switch selection statement.

b) The break statement is required in the last case of a switch selection statement.

c) The expression ( ( x > y ) && ( a < b ) ) is true if either x > y is true or a < b is true.

d) An expression containing the || operator is true if either or both of its operands are true.

e) Listing cases consecutively with no statements between them enables the cases to perform the same set of statements.

C.10 Write a Java statement or a set of Java statements to accomplish each of the following tasks:

a) Sum the odd integers between 1 and 99, using a for statement. Assume that the integer variables sum and count have been declared.

b) Calculate the value of 2.5 raised to the power of 3, using the pow method.

c) Print the integers from 1 to 20, using a while loop and the counter variable i. Assume that the variable i has been declared, but not initialized. Print only five integers per line. [Hint: Use the calculation i % 5. When the value of this expression is 0, print a newline character; otherwise, print a tab character. Assume that this code is an application. Use the System.out.println() method to output the newline character, and use the System.out.print( ' ' ) method to output the tab character.]

d) Repeat part (c), using a for statement.

C.11 Find the error in each of the following code segments, and explain how to correct it:

a)

i = 1;

while ( i <= 10 );
    ++i;
}

b)

Click here to view code image

for ( k = 0.1; k != 1.0; k += 0.1 )
   System.out.println( k );

c)

Click here to view code image

switch ( n )
{
   case 1:
     System.out.println( "The number is 1" );
   case 2:
     System.out.println( "The number is 2" );
     break;
   default:
     System.out.println( "The number is not 1 or 2" );
     break;
}

d) The following code should print the values 1 to 10:

Click here to view code image

n = 1;
while ( n < 10 )
   System.out.println( n++ );

a) sequence, selection, repetition.

b) if...else.

c) sentinel, signal, flag or dummy.

d) strongly typed.

e) prefixed.

C.2

a) False. A set of statements contained within a pair of braces ({ and }) is called a block.

b) False. A repetition statement specifies that an action is to be repeated while some condition remains true.

c) True.

d) True.

e) False. Instance variables of type boolean are given the value false by default.

C.3

a) z = x++ + y;

b)

Click here to view code image

if ( count > 10 )
    System.out.println( "Count is greater than 10" );

c) total -= --x;

d)

q %= divisor;
q = q % divisor;

C.4

a)

int sum;
int x;

b) x = 1;

c) sum = 0;

d) sum += x; or sum = sum + x;

e) System.out.printf( "The sum is: %d ", sum );

C.5 product = 25, x = 6

C.6 a) Error: The closing right brace of the while statement’s body is missing. Correction: Add a closing right brace after the statement ++c;.

b) Error: The semicolon after else results in a logic error. The second output statement will always be executed.

Correction: Remove the semicolon after else.

C.7 The value of the variable z is never changed in the while statement. Therefore, if the loop-continuation condition ( z >= 0 ) is true, an infinite loop is created. To prevent an infinite loop from occurring, z must be decremented so that it eventually becomes less than 0.

a) for, while.

b) after.

c) switch.

d) && (conditional AND).

e) false.

C.9

a) False. The default case is optional. If no default action is needed, then there’s no need for a default case.

b) False. The break statement is used to exit the switch statement. The break statement is not required for the last case in a switch statement.

c) False. Both of the relational expressions must be true for the entire expression to be true when using the && operator.

d) True.

e) True.

C.10

a)

Click here to view code image

sum = 0;
for ( count = 1; count <= 99; count += 2 )
   sum += count;

b) double result = Math.pow( 2.5, 3 );

c)

Click here to view code image

i = 1;

while ( i <= 20 )
{
   System.out.print( i );

   if ( i % 5 == 0 )
     System.out.println();
   else
     System.out.print( ' ' );

   ++i;
}

d)

Click here to view code image

for ( i = 1; i <= 20; ++i )
{
   System.out.print( i );

   if ( i % 5 == 0 )
     System.out.println();
   else
     System.out.print( ' ' );
}

C.11 a) Error: The semicolon after the while header causes an infinite loop, and there’s a missing left brace.

Correction: Replace the semicolon by a {, or remove both the ; and the }.

b) Error: Using a floating-point number to control a for statement may not work, because floating-point numbers are represented only approximately by most computers. Correction: Use an integer, and perform the proper calculation in order to get the values you desire:

Click here to view code image

for ( k = 1; k != 10; ++k )
       System.out.println( (double) k / 10 );

c) Error: The missing code is the break statement in the statements for the first case. Correction: Add a break statement at the end of the statements for the first case. This omission is not necessarily an error if you want the statement of case 2: to execute every time the case 1: statement executes.

d) Error: An improper relational operator is used in the while’s continuation condition. Correction: Use <= rather than <, or change 10 to 11.

C.13 Describe the two ways in which control statements can be combined.

C.14 What type of repetition would be appropriate for calculating the sum of the first 100 positive integers? What type would be appropriate for calculating the sum of an arbitrary number of positive integers? Briefly describe how each of these tasks could be performed.

C.15 What is the difference between preincrementing and postincrementing a variable?

C.16 Identify and correct the errors in each of the following pieces of code. [Note: There may be more than one error in each piece of code.]

a)

Click here to view code image

if ( age >= 65 );
   System.out.println( "Age is greater than or equal to 65" );
else
   System.out.println( "Age is less than 65 )";

b)

int x = 1, total;
while ( x <= 10 )
{
    total += x;
    ++x;
}

c)

while ( x <= 100 )
   total += x;
   ++x;

d)

while ( y > 0 )
{
   System.out.println( y );
   ++y;

For Exercise C.17 and Exercise C.18, perform each of the following steps:

a) Read the problem statement.

b) Write a Java program.

c) Test, debug and execute the Java program.

d) Process three complete sets of data.

C.17 (Gas Mileage) Drivers are concerned with the mileage their automobiles get. One driver has kept track of several trips by recording the miles driven and gallons used for each tankful. Develop a Java application that will input the miles driven and gallons used (both as integers) for each trip. The program should calculate and display the miles per gallon obtained for each trip and print the combined miles per gallon obtained for all trips up to this point. All averaging calculations should produce floating-point results. Use class Scanner and sentinel-controlled repetition to obtain the data from the user.

C.18 (Credit Limit Calculator) Develop a Java application that determines whether any of several department-store customers has exceeded the credit limit on a charge account. For each customer, the following facts are available:

a) account number

b) balance at the beginning of the month

c) total of all items charged by the customer this month

d) total of all credits applied to the customer’s account this month

e) allowed credit limit

The program should input all these facts as integers, calculate the new balance (= beginning balance + charges — credits), display the new balance and determine whether the new balance exceeds the customer’s credit limit. For those customers whose credit limit is exceeded, the program should display the message "Credit limit exceeded".

C.19 (Find the Largest Number) The process of finding the largest value is used frequently in computer applications. For example, a program that determines the winner of a sales contest would input the number of units sold by each salesperson. The salesperson who sells the most units wins the contest. Write a pseudocode program, then a Java application that inputs a series of 10 integers and determines and prints the largest integer. Your program should use at least the following three variables:

a) counter: A counter to count to 10 (i.e., to keep track of how many numbers have been input and to determine when all 10 numbers have been processed).

b) number: The integer most recently input by the user.

c) largest: The largest number found so far.

C.20 (Tabular Output) Write a Java application that uses looping to print the following table of values:

Click here to view code image

C.21 (Multiples of 2 with an Infinite Loop) Write an application that keeps displaying in the command window the multiples of the integer 2—namely, 2, 4, 8, 16, 32, 64, and so on. Your loop should not terminate (i.e., it should create an infinite loop). What happens when you run this program?

C.23 (Find the Smallest Value) Write an application that finds the smallest of several integers. Assume that the first value read specifies the number of values to input from the user.

C.24 Assume that i = 1, j = 2, k = 3 and m = 2. What does each of the following statements print?

a) System.out.println( i == 1 );

b) System.out.println( j == 3 );

c) System.out.println( ( i >= 1 ) && ( j < 4 ) );

d) System.out.println( ( m <= 99 ) & ( k < m ) );

e) System.out.println( ( j >= i ) || ( k == m ) );

f) System.out.println( ( k + m < j ) | ( 3 - j >= k ) );

g) System.out.println( !( k > m ) );

C.25 (Calculating the Value of π) Calculate the value of π from the infinite series

Print a table that shows the value of π approximated by computing the first 200,000 terms of this series. How many terms do you have to use before you first get a value that begins with 3.14159?

C.26 What does the following program segment do?

Click here to view code image

for ( i = 1; i <= 5; ++i )
{
   for ( j = 1; j <= 3; ++j )
   {
      for ( k = 1; k <= 4; ++k )
         System.out.print( '*' );
      System.out.println();
    } // end inner for
    System.out.println();
} // end outer for

C.27 (“The Twelve Days of Christmas” Song) Write (as concisely as possible) an application that uses repetition and one or more switch statements to print the song “The Twelve Days of Christmas.”