BHSawesome AP CSA

To take a simple example, 2 + 3 is an expression consisting of the two literal values 2 and 3 and the operator +. The values are sometimes called the operands of the expression. The + operator works in Java about how you expect, adding together its two operands and producing a new value, in this case 5. The expression 2 + 3 is an example of an arithmetic expression, an expressions consisting of numeric values being operated on by one of Java’s arithmetic operators.

Java uses the standard mathematical operators for addition (+), subtraction (-), and division (/). The multiplication operator is written as *, as it is in most programming languages, since the character sets used until relatively recently didn’t have a character for a real multiplication sign, ×, and keyboards still don’t have a key for it. For similar reasons the ÷ symbol is not used in Java.

Just like variables have a type that was determined when we declared it, expressions have a type that is determined by the kind of value they produce. Arithmetic expressions can be of type int or double depending on the types of the values in the expression.

An arithmetic expression consisting only of int values will always evaluate to an int value, even if the true mathematical result is not an integer. But an arithmetic expression that contains at least one double value will always evaluate to a double value.

This means that when if we divide two ints, we will get an int result and the decimal part of the result will be thrown away. So, for instance, 5 / 2 would give us 2, not 2.5. This is called truncating division. If we want to preserve the part after the decimal point we need a double result, so we should make at least one of the values in the expression a double like 2.0. The expression 5 / 2.0 will give us 2.5.

Java also supports a fifth arithmetic operator, %, called the remainder operator. Like the other four basic arithmetic operators it takes two operands. Mathematically it returns the remainder after dividing the first number by the second, using truncating division. For instance, 5 % 2 evaluates to 1 since 2 goes into 5 two times with a remainder of 1.

While you may not have heard of remainder as an operator, think back to elementary school math when you first learned long division, before you learned about decimals. You probably learned how to give the answer to a long division that didn’t divide evenly in terms of the number of even divisions and the remainder. The remainder is what is returned by the % operator. In the figures below, the remainders are the same values that would be returned by 2 % 3 and 5 % 2.

Sometimes people—including Professor Lewis in the next video—will call % the modulo, or mod, operator. That is not actually correct though the difference between remainder and modulo only matters when the signs of the operands differ. (The difference has to do with what kind of division is done before finding the remainder; the remainder operator is based on truncating integer division where the quotient is truncated toward zero while modulo is based on Euclidean division which truncates toward negative infinity.) With operands of the same sign, remainder and modulo give the same results. Java does have a method Math.floorMod in the Math class if you need to use modulo instead of remainder, but % is all you need in the AP exam and it will only be used with positive operands.

Here’s the video.

While computers are pretty good at math they will only do what we tell them. And sometimes what we tell them isn’t exactly what we wanted. For instance, we can get bit by an unexpected truncating division if we divide two ints when we really wanted a double result.

And sometimes it’s something as silly as using the wrong operator. For example, when the Hubble Space Telescope was launched to space in 1990, a bug where a programmer subtracted when they should have added (or possibly the other way around) caused it to point in the wrong direction! It missed its target stars by about half a degree which is about the width of the moon seen from Earth. Thorough testing is the only way to make sure there are no logic errors that will cause runtime errors in your code. Try the following example that tries to convert centimeters to inches. Can you fix the runtime error?

Another kind of math bug is when we ask Java to do something mathematically impossible. The main one we need to know about is what happens when we divide by zero, something that is not defined in math. In an int expression, dividing by zero will result in an ArithmeticException , as we saw in the Section 1.2 Debugging and being stuck. Try it in one of the active codes to see what happens.

Each arithmetic operator operates on just two operands. So what does an expression like 2 * 3 + 4 mean? If we remember our PEMDAS, we know in regular math that this expression should evaluate to 10 since we first multiply 2 times 3, getting 6, and then add 4 to that, getting 10. It works the same in Java. Java evaluates the * operator with the two operands are 2 and 3, and then the + operator with the value of the subexpression 2 * 3 and 4.

This kind of expression, where one or both of the operands are also arithmetic expressions, not just variables or a literal values, is called a compound expression.

When compound expressions are evaluated, Java uses operator precedence rules, just like we do in regular math. So the expression 2 + 5 * 3 is 17, not 21 because the expression 5 * 3 is evaluated first and then becomes one of the operands to the + operator.

In Java, multiplication *, division /, and remainder % are done before addition + and subtraction -. However, as under PEMDAS rules, anything in parentheses is done first. It doesn’t hurt to put in extra parentheses if you are unsure as to what will be done first or just to make it more clear.