Java Programming For Android

Editor's Notes

• #20: You use variables for storing and retrieving data for your program. Objects store their individual states in fields. Fields are also called instance variables because their values are unique to each individual instance of a class. The code example shows a Shirt class that declares several non-static fields (such as price, shirtID, and colorCode in the Shirt class). When an object is instantiated from a class, these variables contain data specific to a particular object instance of the class. For example, one instance of the Shirt class might have the value of 7 assigned to the quantityInStock non-static field, while another instance of the Shirt class might have the value of 100 assigned to the quantityInStock non-static field.
• #21: Your programs can also have variables defined within methods. These variables are called local variables because they are available only locally within the method in which they are declared. Note: Throughout this course, the terms variables or fields are used to refer to variables. If the situation requires, local variable will be used when it applies.
• #22: Variables are used extensively in the Java programming language for tasks such as:Holding unique attribute data for an object instance (as you have seen with the price and ID variables)Assigning the value of one variable to anotherRepresenting values within a mathematical expressionPrinting the values to the screen. For example, the Shirt class uses the price and ID variables to print the price and ID values for the shirt:System.out.println("Shirt price: " + price);System.out.println("Shirt ID: " + shirtID);Holding references to other objects
• #23: Attribute variable declaration and initialization follow the same general syntax. The syntax for field declaration and initialization is:[modifiers] type identifier [= value];The syntax for initializing a variable inside of a method is:identifier = value;The syntax for declaring and initializing a variable inside of a method is:type identifier [= value];where:[modifiers]represents several special Java technology keywords, such as public and private, that modify the access that other code has to a field. Modifiers are optional (as indicated by the square brackets). For now, all of the fields you create should have a public modifier.type represents the type of information or data held by the variable. Some variables contain characters, some contain numbers, and some are boolean and can contain only one of two values. All variables must be assigned a type to indicate the type of information that they contain.
• #25: Many of the values in Java technology programs are stored as primitive data types. The slide lists the eight primitive types built in to the Java programming language.
• #26: There are four integral primitive types in the Java programming language, identified by the keywords byte, short, int, and long. These types store numbers that do not have decimal points. If you need to store people’s ages, for example, a variable of type byte would work because byte types can accept values in that range. When you specify a literal value for a long type, put a capital L to the right of the value to explicitly state that it is a long type. Integer literals are assumed by the compiler to be of type int unless you specify otherwise by using an L indicating long type.A new SE 7 feature allows you to express any of the integral types as binary (0s and 1s). For instance, a binary expression of the number 2 is shown as an allowed value of the byte integral type. The binary value is 0b10. Notice that this value starts with 0b (that is, zero followed by either a lowercase or uppercase letter B). This indicates to the compiler that a binary value follows.Another new feature of SE 7 is seen in the int row. The ability to include underscores in a lengthy int number helps with readability of the code. For instance, you might use this to make it easier to read a large integral number, substituting underscores for commas. The use of the underscore has no effect on the numerical value of the int, nor does it appear if the variable is printed to the screen.
• #27: The Shirt class contains two attributes of type int to hold the values for a shirtID and the quantity in stock, and literal values are used to supply a default starting value of zero (0) for each.public int shirtID = 0; // Default ID for the shirtpublic int quantityInStock = 0; // Default quantity for all shirtsNote: The only reason to use the byte and short types in programs is to save memory consumption. Because most modern desktop computers contain an abundance of memory, most desktop application programmers do not use byte and short types. This course uses primarily int and long types in the examples.
• #28: There are two types for floating point numbers: float and double. These types are used to store numbers with values to the right of the decimal point, such as 12.24 or 3.14159. When you specify a literal value for a floattype, put a capital F (float) to the right of the value to explicitly state that it is a float type, not a double type. Literal values for floating point types are assumed to be of type double unless you specify otherwise, using the F indicating float type. The Shirt class shows the use of one double literal value to specify the default value for the price:public double price = 0.0; // Default price for all shirtsNote: Use the double type when a greater range or higher accuracy is needed.
• #29: Another data type you use for storing and manipulating data is single-character information. The primitive type used for storing a single character (such as a y) is char, which is 16 bits in size. The Shirt class shows the use of one textual literal value to specify the default value for a colorCode:public char colorCode = 'U';When you assign a literal value to a char variable, such as t, you must use single quotation marks around the character: 't' Using single quotation marks around the character clarifies for the compiler that the t is just the literal value t, rather than a variable t that represents another value.
• #30: Computer programs must often make decisions. The result of a decision, whether the statement in the program is true or false, can be saved in boolean variables. Variables of type boolean can store only:The Java programming language literals true or falseThe result of an expression that evaluates only to true or false. For example, if the variable answer is equal to 42, then the expression “if answer < 42” evaluates to a false result.
• #32: As with a class or method, you must assign an identifier or a name to each variable in your program. Remember, the purpose of the variable is to act as a mechanism for storing and retrieving values. Therefore, you should make variable identifiers simple but descriptive. For example, if you store the value of an item ID, you might name the variable myID, itemID, itemNumber, or anything else that clarifies the use of the variable to yourself and to others reading your program.Did You Know? Many programmers follow the convention of using the first letter of the type as the identifier: inti, floatf, and so on. This convention is acceptable for small programs that are easy to decipher, but generally you should use more descriptive identifiers.
• #34: You can assign a value to a variable at the time when the variable is declared, or you can assign the variable later. To assign a value to a variable during declaration, add an equal sign (=) after the declaration, followed by the value to be assigned. For example, the price field in the Shirt class could be assigned the value 12.99 as the price for a Shirt object.double price = 12.99;An example of boolean variable declaration and assignment is:boolean isOpen = false;The=operator assigns the value on the right side to the item on the left side. The = operator should be read as “is assigned to.” In the preceding example, you could say, “12.99 is assigned to price.” Operators such as the assignment operator (=) are presented later in this course.Note: Fields are automatically initialized: integral types are set to 0, floating point types are set to 0.0, the char type is set to \u0000, and the boolean type is set to false. However, you should explicitly initialize your fields so that other people can read your code. Local variables (declared within a method) must be explicitly initialized before being used.
• #35: You can declare one or more variables on the same line of code, but only if they are all of the same type. The syntax for declaring several variables in one line of code is:type identifier = value [, identifier = value];Therefore, if there are separate retail and wholesale prices in the Shirt class, they might be declared as follows:double price = 0.0, wholesalePrice = 0.0;
• #36: You can assign values to variables by using several different approaches.Assigning literal values directly to variables (as has been described throughout this lesson):int ID = 0;float pi = 3.14F;char myChar = 'G';boolean isOpen = false;Assigning the value of one variable to another variable:int ID = 0;int saleID = ID;The first line of code creates an integer called ID and uses it to store the number 0. The second line of code creates another integer called saleID and uses it to store the same value as ID (0). If the contents of IDare changed later, the contents of saleID do not automatically change. Even though the two integers currently have the same value, they can be independently changed later in a program.
• #37: Assigning the result of an expression to integral, floating point, or boolean type variables:In the following lines of code, the result of everything on the right side of the = operator is assigned to the variable on the left side of the = operator.float numberOrdered = 908.5F;float casePrice = 19.99F;float price = (casePrice * numberOrdered);int hour = 12;boolean isOpen = (hour > 8);Assigning the return value of a method call to a variable (This approach is described later in the course.)
• #38: In this lesson, you have learned about variables that have values that you can change. In this section, you learn how to use constants to represent values that cannot change.Assume that you are writing part of a scheduling application, and you need to refer to the number of months in a year. Make the variable a constant by using the final keyword to inform the compiler that you do not want the value of the variable to be changed after it has been initialized. Also, by convention, name the constant identifier using all capital letters, with underscores separating words, so that it is easy to determine that it is a constant:final int NUMBER_OF_MONTHS = 12;Any values that tend to change rarely, if ever, are good candidates for a constant variable (for example, MAX_COUNT, PI, and so on).If someone attempts to change the value of a constant after it has already been assigned a value, the compiler gives an error message. If you modify your code to provide a different value for the constant, you need to recompile your program.Guidelines for Naming ConstantsYou should name constants so that they can be easily identified. Generally, constants should be capitalized, with words separated by an underscore (_).
• #39: When you use a literal value or create a variable or constant and assign it a value, the value is stored in the memory of the computer.The figure shows that local variables are stored separately (on the stack) from fields (on the heap). Objects and their fields and methods are usually stored in heap memory. Heap memory consists of dynamically allocated memory chunks containing information used to hold objects (including their fields and methods) while they are needed by your program. Other variables are usually stored in stack memory. Stack memory stores items that are used for only a brief period of time (shorter than the life of an object), such as variables declared inside of a method.
• #42: Programs do a lot of mathematical calculating, from the simple to the complex. Arithmetic operators let you specify how the numerical values within variables should be evaluated or combined. The standard mathematical operators (often called binary operators) used in the Java programming language are shown in the tables in this section.Note: The % is known as a modulus.
• #43: A common requirement in programs is to add or subtract 1 from the value of a variable. You can do this by using the + operator as follows:age = age + 1;
• #44: However, incrementing or decrementing by 1 is such a common action that there are specific unary operators for it: the increment (++) and decrement (––) operators. These operators can come before (pre-increment and pre-decrement) or after (post-increment and post-decrement) a variable.The line of code in the previous slide, in which the age was incremented by 1, can also be written as follows:age++; or ++age;
• #45: Use these operators within an expression cautiously. With the prefix form, the operation (increment or decrement) is applied before any subsequent calculations or assignments. With the postfix form, the operation is applied after the subsequent calculations or operations, so that the original value—and not the updated value―is used in subsequent calculations or assignments. The table shows increment and decrement operators.
• #46: The example in the slide shows basic use of the increment and decrement operators:int count=15;int a, b, c, d;a = count++;b = count;c = ++count;d = count;System.out.println(a + ", " + b + ", " + c + ", " + d);The result of this code fragment is:15, 16, 17, 17Discussion: What is the result of the following code?int i = 16;System.out.println(++i + " " + i++ + " " + i);
• #48: In a complex mathematical statement with multiple operators on the same line, how does the computer pick which operator it should use first? To make mathematical operations consistent, the Java programming language follows the standard mathematical rules for operator precedence. Operators are processed in the following order:1. Operators within a pair of parentheses2. Increment and decrement operators3. Multiplication and division operators, evaluated from left to right4. Addition and subtraction operators, evaluated from left to rightIf standard mathematical operators of the same precedence appear successively in a statement, the operators are evaluated from left to right.
• #49: Your expression will be automatically evaluated with the rules of precedence. However, you should use parentheses to provide the structure you intend:c = (((25 - 5) * 4) / (2 - 10)) + 4;c = ((20 * 4) / (2 - 10)) + 4;c = (80 / (2 - 10)) + 4;c = (80 / -8) + 4;c = -10 + 4;c = -6;
• #51: Assigning a variable or an expression to another variable can lead to a mismatch between the data types of the calculation and the storage location that you are using to save the result. Specifically, the compiler will either recognize that precision will be lost and not allow you to compile the program, or the result will be incorrect. To fix this problem, variable types have to be either promoted to a larger size type, or type cast to a smaller size type.For example, consider the following assignment:int num1 = 53; // 32 bits of memory to hold the valueint num2 = 47; // 32 bits of memory to hold the valuebyte num3; // 8 bits of memory reservednum3 = (num1 + num2); // causes compiler error
• #52: In some circumstances, the compiler changes the type of a variable to a type that supports a larger size value. This action is referred to as a promotion. Some promotions are done automatically by the compiler if data would not be lost by doing so. These promotions include:If you assign a smaller type (on the right of the =) to a larger type (on the left of the =)If you assign an integral type to a floating point type (because there are no decimal places to lose)The following example contains a literal (an int) that will automatically be promoted to another type (a long) before the value (6) is assigned to the variable (big of type long).long big = 6;Because 6 is an int type, promotion works because the int value is converted to a long value.
• #53: Type casting lowers the range of a value, quite literally chopping it down to a smaller size, by changing the type of the value (for example, by converting a long value to an int value). You do this so that you can use methods that accept only certain types as arguments, so that you can assign values to a variable of a smaller data type, or so that you can save memory. Put the target_type (the type that the value is being type cast to) in parentheses in front of the item that you are type casting. The syntax for type casting a value is:identifier = (target_type) valuewhere:identifier is the name you assign to the variablevalue is the value you want to assign to the identifier(target_type)is the type to which you want to type cast the value. Notice that the target_type must be in parentheses.
• #54: Other potential problems are as follows:int myInt;long myLong = 99L;myInt = (int) (myLong); // No data loss, only zeroes.// A much larger number would// result in data loss.int myInt;long myLong = 123987654321L;myInt = (int) (myLong); // Number is "chopped"If you type cast a float or double value with a fractional part to an integral type such as an int, all decimal values are lost. However, this method of type casting is sometimes useful if you want to truncate the number down to the whole number (for example, 51.9 becomes 51).
• #55: The Java technology compiler makes certain assumptions when it evaluates expressions. You must understand these assumptions to make the appropriate type casts or other accommodations.Integral Data Types and OperationsMost operations result in int or long:byte, char, and short values are promoted to int before the operation.If either argument is of the long type, the other is also promoted to long, and the result is of the long type.byte b1 = 1, b2 = 2, b3;b3 = b1 + b2; // Error: result is an int but b3 is a bytePromoting FloatsIf an expression contains a float, the entire expression is promoted to float. All literal floating point values are viewed as double.
• #56: Just as integral types default to int under some circumstances, values assigned to floating point types always default to a double type, unless you specifically state that the value is a float type.For example, the following line causes a compiler error. Because 27.9 is assumed to be a double type, a compiler error occurs because a double type value cannot fit into a float variable.float float1 = 27.9;//compiler errorBoth of the following work correctly:The F notifies the compiler that 27.9 is a float value:float float1 = 27.9F;27.9 is cast to a float type:float float1 = (float) 27.9;
• #57: The code example uses principles from this section to calculate a person’s age in days and seconds.
• #63: In computer programming, it is common to need to repeat a number of statements. Typically, the code continues to repeat the statements until something changes. Then the code breaks out of the loop and continues with the next statement.
• #65: The code in the slide shows a very simple while loop in the Elevator class. Remember that this particular elevator accepts commands for going up or down only one floor at a time. So to move a number of floors, the goUp() or goDown() method needs to be called a number of times.Notice how the boolean expression is written. The expression returns true if currentFloor is not equal to desiredFloor. So, when these two variables are equal, this expression returns false (because the elevator is now at the desired floor), and the while loop is not executed.
• #66: This setFloor method uses two different types of variables. The currentFloor variable is an instance variable, usually called a field. It is a member of the Elevator class. In an earlier lesson, you saw how fields of an object could be accessed by using the dot notation. Fields are declared outside of method code, usually just after the class declaration.The desiredFloor variable is a local variable, declared within the setFloor method and accessible only within that method. Another way to say this is that its scope is the setFloor method. As you will see later, local variables can also be declared within loops or if statements. Regardless of whether a local variable is declared within a method, a loop, or an if statement, its scope is always the block within which it is declared.
• #67: The example shows some code for generating the square root of number. The boolean expression squares the current value of the square root and checks to see whether it is close to the number of which you are trying to find the square root. If it is close enough (the expression returns true), the program execution skips the statements in the while block and continues with the System.out.println() statement that outputs the square root. If the value is not yet close enough, the code within the block runs and does two things:Adjusts the value of squareRoot so that it will be closer the next time it is checkedPrints the current “guessed” value of squareRoot
• #68: The example in the slide shows how long it would take to double your money at a particular interest rate. The while loop’s boolean expression checks to see whether your money (converted to pennies) has doubled. If it has not, the block of the loop adds the interest of another year to the current total, and the loop repeats the boolean expression check.Note: Converting to pennies is done to simplify the example so that the int type can be used.
• #69: Loops are often used to repeat a set of commands a specific number of times. You can easily do this by declaring and initializing a counter (usually of type int), incrementing that variable inside the loop, and checking if the counter has reached a specific value in the while boolean expression.Although this works, Java has a special counter loop (a for loop), which is covered in the following slides.
• #71: In the for loop, the three expressions needed for a loop that runs a set number of times are all moved into the parentheses after the for keyword. This makes the for loop more compact and readable.
• #72: Notice that for loops are very versatile; you can initialize more than one variable in the first part and modify more than one variable in the third part of the for statement. Also, the type need not be an int.The code in the slide declares two Strings and, as it loops, appends to one String while removing from the other String. These changes are in the third part of the for statement. This part is for updates and, although often used for incrementing the String, can be used for any kind of update (as shown here).The output of the loop is:|------||-----|||----||||---|||||--||||||-
• #74: The code in the slide shows a simple nested loop to output a block of @ symbols with height and width given in the initial local variables. Notice how the outer code prints a new line to start a new row, while the inner loop uses the print() method of System.out to print an @ symbol for every column.
• #75: Here’s a nested while loop that is a little more complex than the previous for example. The nested loop tries to guess a name by building a String of the same length completely at random.Looking at the inner loop first, the code initializes charasciiChar to a lowercase letter randomly. These chars are then added to String guess, until that String is as long as the String that it is being matched against. Notice the convenience of the concatenation operator here, allowing concatenation of a String and a char.The outer loop tests to see if the guess is the same as a lowercase version of the original name. If it is not, guess is reset to an empty String and the inner loop runs again, usually millions of times for a five-letter name. (Note that names longer than five letters will take a very long time.)
• #78: Output:Age is 27Age is 12Age is 82 …Age is 1
• #81: ArrayLists can be iterated through in exactly the same way as arrays.
• #82: There are two useful keywords that can be used when you work with loops: break and continue. break enables you to jump out of a loop, while continue sends you back to the start of the loop.The example in the slide shows the use of break. Assuming that the code is to find out if any of the scores in the array are above passmark, you can set passed to true and jump out of the loop as soon as the first such score is found.
• #83: The example in this slide shows the use of continue on a similar example. In this case, assume that you want to know if a certain number of passes has been achieved. So the approach is to check first to see whether the unit's score is not enough. If this is the case, the continue command goes to the start of the loop again. If the score is sufficient, the number of passesReqd is decremented and further processing possibly takes place.This example and the previous one are intended only to show what the functions of break and continue are, and not to show particular programming techniques. Both have a similar function: They ensure that parts of the loop are not processed unnecessarily. Sometimes this can also be achieved by the design of if blocks, but it is useful to have these two options in complex algorithms.
• #85: The do/while loop is a one-to-many iterative loop: The condition is at the bottom of the loop and is processed after the body. The body of the loop is,therefore, processed at least once. If you want the statement or statements in the body to be processed at least once, use a do/while loop instead of a while or for loop. The syntax for the do/while loop is shown in the slide.
• #86: The setFloor method of the Elevator class uses a do/while loop to determine whether the elevator is at the chosen floor. If the value of the currentFloor variable is not equal to the value of the desiredFloor variable, the elevator continues moving either up or down.
• #93: In our daily lives, we have to make a lot of decisions, and we often use the word “if” with some condition when making those decisions. For example, “If the house is blue, I will take a tour of it.” Or, “If the car is a sports car and it is safe, I will buy it.” These types of decisions go through our minds subconsciously every day.
• #95: One of the tasks that programs often perform is to evaluate a condition and, depending on the result, execute different blocks or branches of code. For example, your program might check to see if the value of one variable is equal to the value of another variable and, if so, do something. The image illustrates the type of decision people make every day. In addition to arithmetic operators, such as plus (+) and increment (++), the Java programming language provides several relational operators, including < and > for “less than” and “greater than,” respectively, and && for “AND.” These operators are used when you want your program to execute different blocks or branches of code depending on different conditions, such as checking if the value of two variables is the same. Note: Each of these operators is used within the context of a decision construct, such as an if or if/else construct, which will be presented later.
• #96: An elevator has many functions. We begin with an elevator that has only the following functionality. (This functionality will be enhanced as you look at further examples in subsequent lessons.) The functions of the elevator in this lesson:The doors of the elevator can open.The doors of the elevator can close.The elevator can go up one floor.The elevator can go down one floor.You will see several variations of the Elevator class in this and subsequent lessons, including several variations illustrating the use of decision constructs. The complete Elevator Example code for this lesson is as follows:
• #97: A test class, similar to the example test class, runs the elevator through some tests.
• #98: Relational operators compare two values to determine their relationship. The table lists the different conditions you can test by using relational operators. The result of all relational operators is a boolean value. Boolean values can be either true or false. For example, all of the examples in the table yield a boolean result of true.Note: The equal sign (=) is used to make an assignment.
• #99: If you use the == operator to compare object references to String objects, the operator tests whether the addresses in the String object references in memory are equal, not their contents.Discussion: Are all of the following String object references equal?String helloString1 = ("hello");String helloString2 = "hello";String helloString3 = new String("hello");If you want to test equality between the strings of characters (such as whether the name “Fred Smith” is equal to “Joseph Smith”), use the equals method of the String class. The class in the example contains two employee names and a method that compares names.
• #100: You will also need to be able to make a single decision based on more than one condition. Under such circumstances, you can use conditional operators to evaluate complex conditions as a whole. The table in the slide lists the common conditional operators in the Java programming language. For example, all of the examples in the table yield a boolean result of false.Discussion: What relational and conditional operators are expressed in the following paragraph?If the toy is red, I will purchase it. However, if the toy is yellow and costs less than a red item, I will also purchase it. If the toy is yellow and costs the same as or more than another red item, I will not purchase it. Finally, if the toy is green, I will not purchase it.
• #101: The ternary operator is a conditional operator that takes three operands. It requires a shorter syntax than an if/else statement. Use the ?: operator instead of an if/else statement if it makes your code more readable―for example, when the expressions are compact and without side-effects (such as assignments). The first operand is a boolean expression.You learn about if/else statements in the next section.
• #104: An if statement, or an if construct, executes a block of code if an expression is true. There are a few variations on the basic if construct. However, the simplest is:if (boolean_expression) { <code_block>} // end of if construct// program continues herewhere:boolean_expression is a combination of relational operators, conditional operators, and values resulting in a value of true or falsecode_block represents the lines of code that are executed if the expression is trueFirst, the boolean_expression is tested. If the expression is true, then the code block is executed. If the boolean_expression is not true, the program skips to the brace marking the end of the if construct code block.
• #105: The ElevatorTest class tests an Elevator object by invoking its methods. One of the first methods that the ElevatorTest class invokes is the goDown method. Two ifstatements can fix this problem. The following goDown method contains two if constructs that determine whether the elevator should go down or display an error. The entire ElevatorTest class is as follows:
• #107: Sometimes you might need to execute an if statement as part of another if statement. The code example illustrates how to use nested if statements to check the values of two variables. If the value of the currentFloor variable is equal to the MIN_FLOORS constant, an error message is printed and the elevator does not go down. If the value of the currentFloor variable is greater than the MIN_FLOORS constant and the doors are closed, the elevator goes down. The entire NestedIfElevator example code is listed as follows. Note: Use nested if/else constructs sparingly because they can be confusing to debug.
• #108: Often, you want one block of code to be executed if the expression is true, and another block of code to be executed if the expression is false. You can use an if construct to execute a code block if the expression is true with an else construct that executes only if the expression is false. The syntax for an if/else construct is shown in the example in the slide, where:boolean_expression is a combination of relational operators, conditional operators, and values resulting in a value of true or falsecode_block1 represents the lines of code that are executed if the expression is true, and code_block2 represents the lines of code that are executed if the expression is false.
• #109: You can use one if/else statement to fix the problem of the elevator going to an invalid floor. The goDown method shown in the slide example contains one if/else construct that determines whether the elevator should go down or display an error. If the value of the currentFloor variable is equal to the MIN_FLOORS constant, an error message is printed and the elevator does not go down. Otherwise (else), the value of the currentFloor variable is assumed to be greater than the MIN_FLOORS constant and the elevator goes down. The complete code example is as follows:
• #112: You can chain if and else constructs together to state multiple outcomes for several different expressions. The syntax for a chained if/else construct is shown in the slide example, where:boolean_expression is a combination of relational operators, conditional operators, and values resulting in a value of true or falsecode_block1 represents the lines of code that are executed if the expression is truecode_block2 represents the lines of code that are executed if the expression is false and the condition in the second if is truecode_block3 represents the lines of code that are executed if the expression in the second if also evaluates to false
• #113: The example is an IfElseDateclass containing several chained if/elseconstructs that determine how many days there are in a month. The calculateNumDays method chains three if/elsestatements together to determine the number of days in a month. Although this code is syntactically correct, chaining if/elsestatements can result in confusing code and should be avoided.
• #115: Another keyword used in decision making is the switch keyword. The switch construct helps you avoid confusing code because it simplifies the organization of the various branches of code that can be executed.TheIfElseDateclass example could be rewritten by using a switch construct. The syntax for the switch construct is shown in the slide, where:The switch keyword indicates a switch statementvariable is the variable whose value you want to test. The variable can be only of type char, byte, short, int, or String.The case keyword indicates a value that you are testing. A combination of the case keyword and a literal_value is referred to as a case label.
• #116: The example contains a SwitchDate class that uses a switch construct to determine how many days there are in a month.The calculateNumDays method in the SwitchDate class uses a switch statement to branch on the value of the month variable. If the month variable is equal to 1, 3, 5, 7, 8, 10, or 12, the code jumps to the appropriate case label and then drops down to execute System.out.println("There are 31 days in that month.").