teams = players / maxEach; // Assigns players / maxEach to teams half = number / 2; // Assigns number / 2 to half The modulus operator returns the remainder of a division operation involving two integers. The following statement assigns 2 to leftOver: leftOver = 17 % 3; Situations arise where you need to get the remainder of a division. Computations that detect odd numbers or are required to determine how many items are left over after division use the modulus operator. The program in Code Listing 2-17 demonstrates some of these operators used in a simple payroll calculation. Code Listing 2-17 (Wages.java) 1 // This program calculates hourly wages plus overtime. 2 3 public class Wages 4 { 5 public static void main(String[] args) 6 { 7 double regularWages; // The calculated regular wages. 8 double basePay = 25; // The base pay rate. 9 double regularHours = 40; // The hours worked less overtime. 10 double overtimeWages; // Overtime wages 11 double overtimePay = 37.5; // Overtime pay rate 12 double overtimeHours = 10; // Overtime hours worked 13 double totalWages; // Total wages 14 15 regularWages = basePay * regularHours; 16 overtimeWages = overtimePay * overtimeHours; 17 totalWages = regularWages + overtimeWages; 18 System.out.println("Wages for this week are $" + 19 totalWages); 20 } 21 } Program Output Wages for this week are $1375.0 Code Listing 2-17 calculates the total wages an hourly paid worker earned in one week. As mentioned in the comments, there are variables for regular wages, base pay rate, regular hours worked, overtime wages, overtime pay rate, overtime hours worked, and total wages. 2.5 Arithmetic Operators 57 Line 15 in the program multiplies basePay times regularHours and stores the result, which is 1000, in regularWages: regularWages = basePay * regularHours; Line 16 multiplies overtimePay times overtimeHours and stores the result, which is 375, in overtimeWages: overtimeWages = overtimePay * overtimeHours; Line 17 adds the regular wages and the overtime wages and stores the result, 1375, in totalWages: totalWages = regularWages + overtimeWages; The println statement in lines 18 and 19 displays the message on the screen reporting the weeks wages. Integer Division When both operands of the division operator are integers, the operator will perform integer division. This means the result of the division will be an integer as well. If there is a remainder, it will be discarded. For example, look at the following code: double number; number = 5 / 2; This code divides 5 by 2 and assigns the result to the number variable. What value will be stored in number? You would probably assume that 2.5 would be stored in number because that is the result your calculator shows when you divide 5 by 2; however, that is not what happens when the previous Java code is executed. Because the numbers 5 and 2 are both integers, the fractional part of the result will be thrown away, or truncated. As a result, the value 2 will be assigned to the number variable. In the previous code, it doesnt matter that number is declared as a double because the fractional part of the result is discarded before the assignment takes place. In order for a division operation to return a floating-point value, one of the operands must be of a floating-point data type. For example, the previous code could be written as follows: double number; number = 5.0 / 2; In this code, 5.0 is treated as a floating-point number, so the division operation will return a floating-point number. The result of the division is 2.5. Operator Precedence It is possible to build mathematical expressions with several operators. The following statement assigns the sum of 17, x, 21, and y to the variable answer: answer = 17 + x + 21 + y; Some expressions are not that straightforward, however. Consider the following statement: outcome = 12 + 6 / 3; 58 Chapter 2 Java Fundamentals What value will be stored in outcome? The 6 is used as an operand for both the addition and division operators. The outcome variable could be assigned either 6 or 14, depending on when the division takes place. The answer is 14 because the division operator has higher precedence than the addition operator. Mathematical expressions are evaluated from left to right. When two operators share an operand, the operator with the highest precedence works first. Multiplication and division have higher precedence than addition and subtraction, so the statement above works like this: 1. 6 is divided by 3, yielding a result of 2 2. 12 is added to 2, yielding a result of 14 It could be diagrammed as shown in Figure 2-5. Table 2-8 Precedence of arithmetic operators (highest to lowest) Highest Precedence ? - (unary negation) * / % Lowest Precedence ? + - Table 2-9 Associativity of arithmetic operators Operator Associativity - (unary negation) Right to left * / % Left to right + - Left to right Figure 2-5 Precedence illustrated Table 2-8 shows the precedence of the arithmetic operators. The operators at the top of the table have higher precedence than the ones below them. The multiplication, division, and modulus operators have the same precedence. The addition and subtraction operators have the same precedence. If two operators sharing an operand have the same precedence, they work according to their associativity. Associativity is either left to right or right to left. Table 2-9 shows the arithmetic operators and their associativity. 2.5 Arithmetic Operators 59 Grouping with Parentheses Parts of a mathematical expression may be grouped with parentheses to force some operations to be performed before others. In the statement below, the sum of a, b, c, and d is divided by 4.0. average = (a + b + c + d) / 4.0; Without the parentheses, however, d would be divided by 4 and the result added to a, b, and c. Table 2-11 shows more expressions and their values. Table 2-10 Some expressions and their values Expression Value 5 + 2 * 4 13 10 / 2 - 3 2 8 + 12 * 2 - 4 28 4 + 17 % 2 - 1 4 6 - 3 * 2 + 7 - 1 6 Table 2-11 More expressions and their values Expression Value (5 + 2) * 4 28 10 / (5 - 3) 5 8 + 12 * (6 - 2) 56 (4 + 17) % 2 - 1 0 (6 - 3) * (2 + 7) / 3 9 Table 2-10 shows some expressions and their values. In the Spotlight: Calculating Percentages and Discounts Determining percentages is a common calculation in computer programming. Although the % symbol is used in general mathematics to indicate a percentage, most programming languages (including Java) do not use the % symbol for this purpose. In a program, you have to convert a percentage to a floating-point number, just as you would if you were using a calculator. For example, 50 percent would be written as 0.5 and 2 percent would be written as 0.02. Lets look at an example. Suppose you earn $6,000 per month and you are allowed to contribute a portion of your gross monthly pay to a retirement plan. You want to determine the amount of your pay that will go into the plan if you contribute 5 percent, 8 percent, or 10 percent of your gross wages. To make this determination you write a program like the one shown in Code Listing 2-18. Code Listing 2-18 (Contribution.java) 1 // This program calculates the amount of pay that 2 // will be contributed to a retirement plan if 5%, 3 // 8%, or 10% of monthly pay is withheld. 4 5 public class Contribution 6 { 7 public static void main(String[] args) 8 { 9 // Variables to hold the monthly pay and 10 // the amount of contribution. 11 double monthlyPay = 6000.0; 12 double contribution; 13 14 // Calculate and display a 5% contribution. 15 contribution = monthlyPay * 0.05; 16 System.out.println("5 percent is $" + 17 contribution + 18 " per month."); 19 20 // Calculate and display an 8% contribution. 21 contribution = monthlyPay * 0.08; 22 System.out.println("8 percent is $" + 23 contribution + 24 " per month."); 25 26 // Calculate and display a 10% contribution. 27 contribution = monthlyPay * 0.1; 28 System.out.println("10 percent is $" + 29 contribution + 30 " per month."); 31 } 32 } Program Output 5 percent is $300.0 per month. 8 percent is $480.0 per month. 10 percent is $600.0 per month. Lines 11 and 12 declare two variables: monthlyPay and contribution. The monthlyPay variable, which is initialized with the value 6000.0, holds the amount of your monthly pay. The contribution variable will hold the amount of a contribution to the retirement plan. The statements in lines 15 through 18 calculate and display 5 percent of the monthly pay. The calculation is done in line 15, where the monthlyPay variable is multiplied by 0.05. The result is assigned to the contribution variable, which is then displayed by the statement in lines 16 through 18. 60 Chapter 2 Java Fundamentals 2.5 Arithmetic Operators 61 Similar steps are taken in lines 21 through 24, which calculate and display 8 percent of the monthly pay, and lines 27 through 30, which calculate and display 10 percent of the monthly pay. Calculating a Percentage Discount Another common calculation is determining a percentage discount. For example, suppose a retail business sells an item that is regularly priced at $59, and is planning to have a sale where the items price will be reduced by 20 percent. You have been asked to write a program to calculate the sale price of the item. To determine the sale price you perform two calculations: First, you get the amount of the discount, which is 20 percent of the items regular price. Second, you subtract the discount amount from the items regular price. This gives you the sale price. Code Listing 2-19 shows how this is done in Java. Code Listing 2-19 (Discount.java) 1 // This program calculates the sale price of an 2 // item that is regularly priced at $59, with 3 // a 20 percent discount subtracted. 4 5 public class Discount 6 { 7 public static void main(String[] args) 8 { 9 // Variables to hold the regular price, the 10 // amount of a discount, and the sale price. 11 double regularPrice = 59.0; 12 double discount; 13 double salePrice; 14 15 // Calculate the amount of a 20% discount. 16 discount = regularPrice * 0.2; 17 18 // Calculate the sale price by subtracting 19 // the discount from the regular price. 20 salePrice = regularPrice - discount; 21 22 // Display the results. 23 System.out.println("Regular price: $" + regularPrice); 24 System.out.println("Discount amount $" + discount); 25 System.out.println("Sale price: $" + salePrice); 26 } 27 } Program Output Regular price: $59.0 Discount amount $11.8 Sale price: $47.2 Lines 11 through 13 declare three variables. The regularPrice variable holds the items regular price, and is initialized with the value 59.0. The discount variable will hold the amount of the discount once it is calculated. The salePrice variable will hold the items sale price. Line 16 calculates the amount of the 20 percent discount by multiplying regularPrice by 0.2. The result is stored in the discount variable. Line 20 calculates the sale price by subtracting discount from regularPrice. The result is stored in the salePrice variable. The statements in lines 23 through 25 display the items regular price, the amount of the discount, and the sale price. 62 Chapter 2 Java Fundamentals The Math Class The Java API provides a class named Math, which contains numerous methods that are useful for performing complex mathematical operations. In this section we will briefly look at the Math.pow and Math.sqrt methods. The Math.pow Method In Java, raising a number to a power requires the Math.pow method. Here is an example of how the Math.pow method is used: result = Math.pow(4.0, 2.0); The method takes two double arguments. It raises the first argument to the power of the second argument, and returns the result as a double. In this example, 4.0 is raised to the power of 2.0. This statement is equivalent to the following algebraic statement: result = 42 Here is another example of a statement using the Math.pow method. It assigns 3 times 63 to x: x = 3 * Math.pow(6.0, 3.0); And the following statement displays the value of 5 raised to the power of 4: System.out.println(Math.pow(5.0, 4.0)); The Math.sqrt Method The Math.sqrt method accepts a double value as its argument and returns the square root of the value. Here is an example of how the method is used: result = Math.sqrt(9.0); In this example the value 9.0 is passed as an argument to the Math.sqrt method. The method will return the square root of 9.0, which is assigned to the result variable. The following statement shows another example. In this statement the square root of 25.0 (which is 5.0) is displayed on the screen: System.out.println(Math.sqrt(25.0)); 2.6 Combined Assignment Operators 63 For more information about the Math class, see Appendix G, available on the books companion Web site at www.pearsonhighered.com/gaddis. ------------------------------------ Expression Value 6 + 3 * 5 ______ 12 / 2 - 4 ______ 9 + 14 * 2 - 6 ______ 5 + 19 % 3 - 1 ______ (6 + 2) * 3 ______ 14 / (11 - 4) ______ 9 + 12 * (8 - 3) ______ 2.23 Is the division statement in the following code an example of integer division or floating-point division? What value will be stored in portion? double portion; portion = 70 / 3; 2.6 Combined Assignment Operators Concept: The combined assignment operators combine the assignment operator with the arithmetic operators. Quite often, programs have assignment statements of the following form: x = x + 1; On the right side of the assignment operator, 1 is added to x. The result is then assigned to x, replacing the value that was previously there. Effectively, this statement adds 1 to x. Here is another example: balance = balance + deposit; Assuming that balance and deposit are variables, this statement assigns the value of balance + deposit to balance. The effect of this statement is that deposit is added to the value stored in balance. Here is another example: balance = balance - withdrawal; Assuming that balance and withdrawal are variables, this statement assigns the value of balance - withdrawal to balance. The effect of this statement is that withdrawal is subtracted from the value stored in balance. Checkpoint www.myprogramminglab.com 2.22 Complete the following table by writing the value of each expression in the Value column. 64 Chapter 2 Java Fundamentals If you have not seen these types of statements before, they might cause some initial confusion because the same variable name appears on both sides of the assignment operator. Table 2-12 shows other examples of statements written this way. Table 2-12 Various assignment statements (assume x = 6 in each statement) Statement What It Does Value of x after the Statement x = x + 4; Adds 4 to x 10 x = x - 3; Subtracts 3 from x 3 x = x * 10; Multiplies x by 10 60 x = x / 2; Divides x by 2 3 x = x % 4 Assigns the remainder of x / 4 to x. 2 Table 2-13 Combined assignment operators Operator Example Usage Equivalent To += x += 5; x = x + 5; -= y -= 2; y = y - 2; *= z *= 10; z = z * 10; /= a /= b; a = a / b; %= c %= 3; c = c % 3; These types of operations are common in programming. For convenience, Java offers a special set of operators designed specifically for these jobs. Table 2-13 shows the combined assignment operators, also known as compound operators. As you can see, the combined assignment operators do not require the programmer to type the variable name twice. The following statement: balance = balance + deposit; could be rewritten as balance += deposit; Similarly, the statement balance = balance - withdrawal; could be rewritten as balance -= withdrawal; Checkpoint www.myprogramminglab.com 2.24 Write statements using combined assignment operators to perform the following: a) Add 6 to x b) Subtract 4 from amount 2.7 Conversion between Primitive Data Types 65 c) Multiply y by 4 d) Divide total by 27 e) Store in x the remainder of x divided by 7 2.7 Conversion between Primitive Data Types Concept: Before a value can be stored in a variable, the values data type must be compatible with the variables data type. Java performs some conversions between data types automatically, but does not automatically perform any conversion that can result in the loss of data. Java also follows a set of rules when evaluating arithmetic expressions containing mixed data types. Java is a strongly typed language. This means that before a value is assigned to a variable, Java checks the data types of the variable and the value being assigned to it to determine whether they are compatible. For example, look at the following statements: int x; double y = 2.5; x = y; The assignment statement is attempting to store a double value (2.5) in an int variable. When the Java compiler encounters this line of code, it will respond with an error message. (The JDK displays the message possible loss of precision.) Not all assignment statements that mix data types are rejected by the compiler, however. For instance, look at the following program segment: int x; short y = 2; x = y; This assignment statement, which stores a short in an int, will work with no problems. So why does Java permit a short to be stored in an int, but does not permit a double to be stored in an int? The obvious reason is that a double can store fractional numbers and can hold values much larger than an int can hold. If Java were to permit a double to be assigned to an int, a loss of data would be likely. Just like officers in the military, the primitive data types are ranked. One data type outranks another if it can hold a larger number. For example, a float outranks an int, and an int outranks a short. Figure 2-6 shows the numeric data types in order of their rank. The higher a data type appears in the list, the higher is its rank. Figure 2-6 Primitive data type ranking 66 Chapter 2 Java Fundamentals In assignment statements where values of lower-ranked data types are stored in variables of higher-ranked data types, Java automatically converts the lower-ranked value to the higherranked type. This is called a widening conversion. For example, the following code demonstrates a widening conversion, which takes place when an int value is stored in a double variable: double x; int y = 10; x = y; // Performs a widening conversion A narrowing conversion is the conversion of a value to a lower-ranked type. For example, converting a double to an int would be a narrowing conversion. Because narrowing conversions can potentially cause a loss of data, Java does not automatically perform them. Cast Operators The cast operator lets you manually convert a value, even if it means that a narrowing conversion will take place. Cast operators are unary operators that appear as a data type name enclosed in a set of parentheses. The operator precedes the value being converted. Here is an example: x = (int)number; The cast operator in this statement is the word int inside the parentheses. It returns the value in number, converted to an int. This converted value is then stored in x. If number were a floating-point variable, such as a float or a double, the value that is returned would be truncated, which means the fractional part of the number is lost. The original value in the number variable is not changed, however. Table 2-14 shows several statements using cast operators. Table 2-14 Example uses of cast operators Statement Description littleNum = (short)bigNum; The cast operator returns the value in bigNum, converted to a short. The converted value is assigned to the variable littleNum. x = (long)3.7; The cast operator is applied to the expression 3.7. The operator returns the value 3, which is assigned to the variable x. number = (int)72.567; The cast operator is applied to the expression 72.567. The operator returns 72, which is used to initialize the variable number. value = (float)x; The cast operator returns the value in x, converted to a float. The converted value is assigned to the variable value. value = (byte)number; The cast operator returns the value in number, converted to a byte. The converted value is assigned to the variable value. Note that when a cast operator is applied to a variable, it does not change the contents of the variable. It only returns the value stored in the variable, converted to the specified data type. Recall from our earlier discussion that when both operands of a division are integers, the operation will result in integer division. This means that the result of the division will be 2.7 Conversion between Primitive Data Types 67 an integer, with any fractional part of the result thrown away. For example, look at the following code: int pies = 10, people = 4; double piesPerPerson; piesPerPerson = pies / people; Although 10 divided by 4 is 2.5, this code will store 2 in the piesPerPerson variable. Because both pies and people are int variables, the result will be an int, and the fractional part will be thrown away. We can modify the code with a cast operator, however, so it gives the correct result as a floating-point value: piesPerPerson = (double)pies / people; The variable pies is an int and holds the value 10. The expression (double)pies returns the value in pies converted to a double. This means that one of the division operators operands is a double, so the result of the division will be a double. The statement could also have been written as follows: piesPerPerson = pies / (double)people; In this statement, the cast operator returns the value of the people variable converted to a double. In either statement, the result of the division is a double. Warning! The cast operator can be applied to an entire expression enclosed in parentheses. For example, look at the following statement: piesPerPerson = (double)(pies / people); This statement does not convert the value in pies or people to a double, but converts the result of the expression pies / people. If this statement were used, an integer division operation would still have been performed. Heres why: The result of the expression pies / people is 2 (because integer division takes place). The value 2 converted to a double is 2.0. To prevent the integer division from taking place, one of the operands must be converted to a double. Mixed Integer Operations One of the nuances of the Java language is the way it internally handles arithmetic operations on int, byte, and short variables. When values of the byte or short data types are used in arithmetic expressions, they are temporarily converted to int values. The result of an arithmetic operation using only a mixture of byte, short, or int values will always be an int. For example, assume that b and c in the following expression are short variables: b + c Although both b and c are short variables, the result of the expression b + c is an int. This means that when the result of such an expression is stored in a variable, the variable must be an int or higher data type. For example, look at the following code: short firstNumber = 10, secondNumber = 20, thirdNumber; 68 Chapter 2 Java Fundamentals