switch Multiple-Selection Statement

We discussed the if single-selection statement and the if...else double-selectionstatement in Chapter 4. Java provides the switch multiple-selection statement to perform different actions based on the possible values of an integer variable or expression. Each action. is associated with the value of a constant integral expression (i.e., a constant value of type byte, short, int or char, but not long) that the variable or expression on which the switch is based may assume.

GradeBook Class with switch Statement to Count A, B, C, D and F Grades

Figure 5.9 contains an enhanced version of the GradeBook class introduced in Chapter 3 and further developed in Chapter 4. The version of the class we now present not only calculates the average of a set of numeric grades entered by the user, but uses a switch statement to determine whether each grade is the equivalent of an A, B, C, D or F and to increment the appropriate grade counter. The class also displays a summary of the number of students who received each grade. Please refer to Fig. 5.10 for sample input and output of the GradeBook-Test application that uses class GradeBook to process a set of grades.

Figure 5.9. GradeBook class uses switch statement to count A, B, C, D and F grades.

(This item is displayed on pages 193 - 195 in the print version)

 1 // Fig. 5.9: GradeBook.java
 2 // GradeBook class uses switch statement to count A, B, C, D and F grades.
 3 import java.util.Scanner; // program uses class Scanner
 4
 5 public class GradeBook
 6 {
 7 private String courseName; // name of course this GradeBook represents
 8 private int total; // sum of grades 
 9 private int gradeCounter; // number of grades entered
10 private int aCount; // count of A grades 
11 private int bCount; // count of B grades 
12 private int cCount; // count of C grades 
13 private int dCount; // count of D grades 
14 private int fCount; // count of F grades 
15
16 // constructor initializes courseName;
17 // int instance variables are initialized to 0 by default
18 public GradeBook( String name )
19 {
20 courseName = name; // initializes courseName
21 } // end constructor
22
23 // method to set the course name
24 public void setCourseName( String name )
25 {
26 courseName = name; // store the course name
27 } // end method setCourseName
28
29 // method to retrieve the course name
30 public String getCourseName()
31 {
32 return courseName;
33 } // end method getCourseName
34
35 // display a welcome message to the GradeBook user
36 public void displayMessage()
37 {
38 // getCourseName gets the name of the course
39 System.out.printf( "Welcome to the grade book for
%s!

",
40 getCourseName() );
41 } // end method displayMessage
42
43 // input arbitrary number of grades from user
44 public void inputGrades()
45 {
46 Scanner input = new Scanner( System.in );
47
48 int grade; // grade entered by user
49
50 System.out.printf( "%s
%s
 %s
 %s
",
51 "Enter the integer grades in the range 0-100.",
52 "Type the end-of-file indicator to terminate input:",
53 "On UNIX/Linux/Mac OS X type  d then press Enter",
54 "On Windows type  z then press Enter" );
55
56 // loop until user enters the end-of-file indicator
57 while ( input.hasNext() )
58 {
59 grade = input.nextInt(); // read grade
60 total += grade; // add grade to total
61 ++gradeCounter; // increment number of grades
62
63 // call method to increment appropriate counter
64 incrementLetterGradeCounter( grade );
65 } // end while
66 } // end method inputGrades
67
68 // add 1 to appropriate counter for specified grade
69 public void incrementLetterGradeCounter( int numericGrade )
70 {
71 // determine which grade was entered 
72 switch ( grade / 10 ) 
73 { 
74  case 9: // grade was between 90 
75  case 10: // and 100 
76  ++aCount; // increment aCount 
77  break; // necessary to exit switch 
78 
79  case 8: // grade was between 80 and 89 
80  ++bCount; // increment bCount 
81  break; // exit switch 
82 
83  case 7: // grade was between 70 and 79 
84  ++cCount; // increment cCount 
85  break; // exit switch 
86 
87  case 6: // grade was between 60 and 69 
88  ++dCount; // increment dCount 
89  break; // exit switch 
90 
91  default: // grade was less than 60 
92  ++fCount; // increment fCount 
93  break; // optional; will exit switch anyway
94 } // end switch 
95 } // end method incrementLetterGradeCounter
96
97 // display a report based on the grades entered by user
98 public void displayGradeReport()
99 {
100 System.out.println( "
Grade Report:" );
101
102 // if user entered at least one grade...
103 if ( gradeCounter != 0 )
104 {
105 // calculate average of all grades entered
106 double average = (double) total / gradeCounter;
107
108 // output summary of results
109 System.out.printf( "Total of the %d grades entered is %d
",
110 gradeCounter, total );
111 System.out.printf( "Class average is %.2f
", average );
112 System.out.printf( "%s
%s%d
%s%d
%s%d
%s%d
%s%d
",
113 "Number of students who received each grade:",
114 "A: ", aCount, // display number of A grades
115 "B: ", bCount, // display number of B grades
116 "C: ", cCount, // display number of C grades
117 "D: ", dCount, // display number of D grades
118 "F: ", fCount ); // display number of F grades
119 } // end if
120 else // no grades were entered, so output appropriate message
121 System.out.println( "No grades were entered" );
122 } // end method displayGradeReport
123 } // end class GradeBook

Figure 5.10. GradeBookTest creates a GradeBook object and invokes its methods.

(This item is displayed on page 198 in the print version)

 1 // Fig. 5.10: GradeBookTest.java
 2 // Create GradeBook object, input grades and display grade report.
 3
 4 public class GradeBookTest
 5 {
 6 public static void main( String args[] )
 7 {
 8 // create GradeBook object myGradeBook and
 9 // pass course name to constructor
10 GradeBook myGradeBook = new GradeBook(
11 "CS101 Introduction to Java Programming" );
12
13 myGradeBook.displayMessage(); // display welcome message
14 myGradeBook.inputGrades(); // read grades from user
15 myGradeBook.displayGradeReport(); // display report based on grades
16 } // end main
17 } // end class GradeBookTest

 

Welcome to the grade book for
CS101 Introduction to Java Programming!

Enter the integer grades in the range 0-100.
Type the end-of-file indicator to terminate input:
 On UNIX/Linux/Mac OS X type  d then press Enter
 On Windows type  z then press Enter
99
92
45
57
63
71
76
85
90
100
^Z

Grade Report:
Total of the 10 grades entered is 778
Class average is 77.80
Number of students who received each grade:
A: 4
B: 1
C: 2
D: 1
F: 2

 

Like earlier versions of the class, class GradeBook (Fig. 5.9) declares instance variable courseName (line 7) and contains methods setCourseName (lines 2427), getCourseName (lines 3033) and displayMessage (lines 3641), 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 1821) that initializes the course name.

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

Class GradeBook (Fig. 5.9) contains three additional methodsinputGrades, incrementLetterGradeCounter and displayGradeReport. Method inputGrades (lines 4466) reads an arbitrary number of integer grades from the user using sentinel-controlled repetition and updates instance variables total and gradeCounter. Method inputGrades calls method incrementLetterGradeCounter (lines 6995) to update the appropriate letter-grade counter for each grade entered. Class GradeBook also contains method displayGradeReport (lines 98122), which 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.

Line 48 in method inputGrades declares variable grade, which will store the user's input. Lines 5054 prompt the user to enter integer grades and to type the end-of-file indicator to terminate the input. The end-of-file indicator is a system-dependent keystroke combination which the user enters to indicate that there is no more data to input. In Chapter 14, Files and Streams, we will see how the end-of-file indicator is used when a program reads its input from a file.

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

        d

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

        z

[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 is shown in the output of Fig. 5.9]

Portability Tip 5.1

The keystroke combinations for entering end-of-file are system dependent.

The while statement (lines 5765) obtains the user input. The condition at line 57 calls Scanner method hasNext to determine whether there is more data to input. This method returns the boolean value TRue if there is more data; otherwise, it returns false. The returned value is then used as the condition in the while statement. As long as the end-of-file indicator has not been typed, method hasNext will return TRue.

Line 59 inputs a grade value from the user. Line 60 uses the += operator to add 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 6995) to increment the appropriate letter-grade counter based on the numeric grade entered.

Method incrementLetterGradeCounter contains a switch statement (lines 7294) that determines which counter to increment. In this example, we assume that the user enters a valid grade in the range 0100. A grade in the range 90100 represents A, 8089 represents B, 7079 represents C, 6069 represents D and 059 represents F. The switch statement consists of a block that contains a sequence of case labels and an optional default case. These are used in this example to determine which counter to increment based on the grade.

When the flow of control reaches the switch, the program evaluates the expression in the parentheses (grade / 10) following keyword switch. This is called the controlling expression of the switch. The program compares the value of the controlling expression (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 any value for 0100 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 the int value 8. The switch compares 8 with each case. If a match occurs (case 8: at line 79), the program executes the statements for that case. 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 switchin this program, we reach the end of method incrementLetterGradeCounter's body, so control returns to line 65 in method inputGrades (the first line after the call to incrementLetterGradeCounter). This line marks the end of the body of the while loop that inputs grades (lines 5765), 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 7475 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 statementswhen the controlling expression evaluates to 9 or 10, the statements in lines 7677 will execute. The switch statement does not provide a mechanism for testing ranges of values, so every value that must be tested should be listed in a separate case label. Note that 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 each 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 is often referred to as "falling through" to the statements in subsequent cases. (This feature is perfect for writing a concise program that displays the iterative song "The Twelve Days of Christmas" in Exercise 5.29.)

Common Programming Error 5.7

Forgetting a break statement when one is needed in a switch is a logic error.

If no match occurs between the controlling expression's value and a case label, the default case (lines 9193) 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.

GradeBookTest Class that Demonstrates Class GradeBook

Class GradeBookTest (Fig. 5.10) creates a GradeBook object (lines 1011). Line 13 invokes the object's displayMessage method to output a welcome message to the user. Line 14 invokes the object's inputGrades method to read a set of grades from the user and keep track of the sum of all the grades entered and the number of grades. Recall that method inputGrades also calls method incrementLetterGradeCounter to keep track of the number of students who received each letter grade. Line 15 invokes method displayGradeReport of class GradeBook, which outputs a report based on the grades entered (as in the input/output window in Fig. 5.10). Line 103 of class GradeBook (Fig. 5.9) determines whether the user entered at least one gradethis helps us avoid dividing by zero. If so, line 106 calculates the average of the grades. Lines 109118 then output the total of all the grades, the class average and the number of students who received each letter grade. If no grades were entered, line 121 outputs an appropriate message. The output in Fig. 5.10 shows a sample grade report based on 10 grades.

Note that class GradeBookTest (Fig. 5.10) does not directly call GradeBook method incrementLetterGradeCounter (lines 6995 of Fig. 5.9). 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 class GradeBook's other methods and thus could be declared private. Recall from Chapter 3 that methods declared with access modifier private can be called only by other methods of the class in which the private methods are declared. Such methods are commonly referred to as utility methods or helper methods because they can be called only by other methods of that class and are used to support the operation of those methods.

switch Statement UML Activity Diagram

Figure 5.11 shows the UML activity diagram for the general switch statement. Most switch statements use a break in each case to terminate the switch statement after processing the case. Figure 5.11 emphasizes this by including break statements in the activity diagram. The diagram makes it clear that the break statement at the end of a case causes control to exit the switch statement immediately.

Figure 5.11. switch multiple-selection statement UML activity diagram with break statements.

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

Software Engineering Observation 5.2

Provide a default case in switch statements. Including a default case focuses you on the need to process exceptional conditions.

Good Programming Practice 5.8

Although each case and the default case in a switch can occur in any order, place the default case last. When the default case is listed last, the break for that case is not required. Some programmers include this break for clarity and symmetry with other cases.

When using the switch statement, remember that the expression after each case can be only a constant integral expressionthat is, any combination of integer constants that evaluates to a constant integer value (e.g., -7, 0 or 221). An integer constant is simply an integer value. In addition, you can use character constantsspecific characters in single quotes, such as 'A', '7' or '$'which represent the integer values of characters. (Appendix B, ASCII Character Set shows the integer values of the characters in the ASCII character set, which is a subset of the Unicode character set used by Java.)

The expression in each case also can be a constant variablea variable that contains a value which does not change for the entire program. Such a variable is declared with keyword final (discussed in Chapter 6, Methods: A Deeper Look). J2SE 5.0 has a new feature called enumerations, which we also present in Chapter 6. Enumeration constants can also be used in case labels. In Chapter 10, Object-Oriented Programming: Polymorphism, we present a more elegant way to implement switch logicwe use a technique called polymorphism to create programs that are often clearer, easier to maintain and easier to extend than programs using switch logic.