BHSawesome AP CSA

In Java, type casting is used to convert values from one type to another. By casting we don’t mean something to do with fishing, but it is a similar idea to casting a bronze, without needing to heat anything to 913 degrees Celsius. But like molten bronze is reshaped by melting it and pouring it into a mold, our data is reshaped via a cast operator. In Java when you cast you are changing the “shape” (or type) of the value.

The cast operator, which looks like (int) and (double) placed before any expression (a literal, a number, a variable, or more complex expression in parentheses) produces a value of the given type by converting the value of the original expression to the new type. The casting operators (int) and (double) can be used to convert from a double value to an int value (or vice versa).

For example, (double) 1 / 3 will evaluate to a double value 0.33333333 instead of an int truncated value 0. And (int) 3.6 will evaluate to the int value 3, chopping off the digits to the right of the decimal point.

A conversion from int to double is called a widening conversion because a double can represent any int value but not vice versa; thus a double is considered a wider data type than an int.

As you can see in the exercise above, when Java divides two ints, it produces an int result by truncating the actual mathematical result, removing anything after the decimal point. Thus 3 / 4 evaluates to 0, not 0.75 as we might expect. It also does not evaluate to 1 even though 0.75 is closer to 1 than it is to 0; truncating is not the same as rounding!

But as we learned in Section 2.3 Arithmetic expressions, in any expression involving a double, the double is “contagious” and will cause the other operand to be turned into a double and thus the value of the expression as a whole to be computed using the rules of double math. Thus the expression 3.0 / 4 is evaluated as if it had been written 3.0 / 4.0 and produces the double value 0.75.

If an expressions involves at least one literal value then we can just use a literal double to force Java to use double math. But what if we want to evaluate an expression using int variables but under the rules of double math?

That’s where casting comes in. Since casting an int to double produces a double value, if that value is the operand in an expression, it will then infect the other operand and cause the expression as a whole to produce a double. This is especially useful when we have int variables that we want to do non-integer division with:

int total; // a variable containing the sum of a bunch of ints
int count; // the number of ints that went into total

// Compute the average of the bunch of ints summed into total.
double average = (double) total / count;

Another thing to notice is that cast is an operator, just like +, *, -, /, and %. So it has a precedence just like all the other operators and it is actually quite high. The expression above works because the cast of total to double happens first and then that double value infects count and the whole expression is computed using double math. If instead, we had written:

double average = (double) (total / count);

then the division would have happened first, yielding a truncated int value which would then—too late—be converted to the equivalent double value, losing the fractional part of the true mathematical answer.

Since casting a double value to int throws away mathematical precision it might seem that we’d rarely want to do that. But we can use truncation, with a bit of arithmetic, to round double values to the nearest int value by adding or subtracting 0.5 and then casting the result with (int):

double number;    // positive value from somewhere
double negNumber; // negative value from somewhere

int nearestInt = (int) (number + 0.5);
int nearestNegInt = (int) (negNumber – 0.5);

For example, if we divide 7.0 / 4.0 we get 1.75. And if we cast that to an int, it would be truncated to 1. But if we want to round it to the nearest int, rather than truncating it, adding 0.5 will produce a number that is greater than 2.0 and thus will get truncated to 2. Assuming we’re okay rounding above the next integer value if the decimal part is greater than 0.5, as it is here. Then casting that value to an int will truncate down. So in this case 1.75 + 0.5 gives us 2.25 which is then truncated to 2. On the other hand adding 0.5 to the result of evaluating 5.0 / 4.2, namely 1.25, only gets us to 1.75 which truncates back to 1 which is the nearest integer to 1.25.

And notice that here we need to parenthesize the expression number + 0.5 so that it is evaluated first and then the result cast to a double. Without the parentheses, the cast to int would convert number to an int first because of the higher precedence of casting than division, and then that truncated int value would be infected by the 0.5 giving us a double result with a fractional part of 0.5.

Both the int and double data types have limitations in the numbers they can represent. These limitations are due to the fact that for efficiency reasons computer hardware represents both types using a fixed number of bits, 32 bits for each int and 64 bits for a double.

For ints, this means there is a biggest number that can be represented, just like there’s a biggest number that can be represented in a fixed number of digits. Because ints can represent both positive and negative numbers, half of the bit patters are used to represent negative numbers and half to represent the non-negative numbers including zero. The maximum int value is \(2,147,483,647\) also known as \(2^{31} - 1\text{.}\) The minimum value (most negative) is \(-2,147,483,648\) or \(-(2^{31})\text{.}\) There are constants in Java, Integer.MAX_VALUE and Integer.MIN_VALUE, that we can use if we need to refer to those values in a program.

If we try to store value smaller than Integer.MIN_VALUE or bigger than Integer.MAX_VALUE in an int variable or if an expression that is supposed to produce an int value would produce a value outside that range, the result overflows and produces a mathematically incorrect value. Roughly speaking the value will “wrap around” so, for instance, Integer.MAX_VALUE + 1 gives us the same value as Integer.MIN_VALUE and Integer.MIN_VALUE - 1 brings us back to Integer.MAX_VALUE.

If we try to write a literal int that is out of range the compiler will give us an error as shown in the exercise below.

The double type, despite using twice as many bits per number as ints, also has limitations. Doubles work more like scientific notation, storing a signed magnitude, and an exponent. This means they can represent both very small numbers (the smallest positive value is approximately \(4.9 \times 10^{-324}\)) and very large (the largest positive double value is approximately \(1.8 \times 10^{308}\text{.}\))

However this means, that like scientific notation, there is a limit to the precision with which doubles can represent numbers, about 14-15 decimal places. That has a few consequences. One is that irrational numbers like \(\pi\) and \(\sqrt{2}\) that have an infinite decimal representation can only be approximated. But also simpler numbers like 1/3 which have repeating decimal representations can only be approximated. So the value we get if we evaluate 1.0 / 3.0 is actually roughly \(1.85 \times 10^{-17}\) less than 1/3.

In practice, of course, 14-15 digits of precision is plenty for most purposes. But you should be aware that the accuracy of any calculation on a computer is limited by the fact that computers can only hold a limited number of digits. When these limitations lead to incorrect results it is called a round-off error. Programmers who write software that does complex scientific calculations do something called numeric analysis to make sure their programs won’t be affected by round-off errors but most of us don’t have to worry about that most of the time.

This would be a good project to work together in pairs, and switch drivers (who has control of the keyboard in pair programming) after every line of code. In the code below, type in three made up int grades and then sum and average them. Use casting to report the result as a double. For example, if the grades are 90, 100, and 94, the sum of the three numbers is 90 + 100 + 94 = 284, and the average is the sum 284 divided by 3 which, when cast to a double, is 94.666667. You should use your variables instead of the numbers in your formulas. Follow the pseudo code below.

Your teacher may suggest that you use a different Java IDE for this challenge so that you can use input to get these values using the Scanner class, for example with this JuiceMind template or replit template that you can use if you want to try the challenge with input.