In the previous chapter you learned that computers think in terms of 1s and
0s, and that you can use those 1s and 0s to represent numbers, characters, and
booleans. Then you learned that through Java you could create meaningful names
that refer to regions of memory using variables. The next step is to take those
variables and do something meaningful with them. In this chapter, you will
address all the mathematical operations you can perform in Java on primitive
data types.

Operators work in conjunction with operands, or the literal values or
variables involved in the operation. There are unary operators, which are
operators that operate on a single operand, as well as operators that operate on
two or more variables.

An addition operation, can add two or more operands, whereas an operand can
be a variable, a literal, or a constant.

Subtraction

Subtraction, again as, you would expect, is accomplished using the minus sign
() operator. The form of a subtraction operation is

operand - operand

For example:

// Subtract a literal from a literal; the result is 5
int result = 10 - 5;
// Subtract a variable from another variable; the result is -1
int a = 5;
int b = 6;
int result = a - b;
// Subtract a variable and a literal from a variable
// The result is 5  6  15 = -1  15 = -16
int result = a - b - 15;

A subtraction operation can compute the difference between two or more
operands, where an operand can be a variable, a literal, or a constant.

Multiplication

Multiplication is accomplished using the asterisk (*) operator. The form of a
multiplication operation is

A multiplication operation can multiply two or more operands, where an
operand can be a variable, a literal, or a constant.

Division

Division is accomplished using the forward slash (/) operator. The form of a
division operation is

operand / operand

For example:

// Divide a literal by a literal; result is 5
int result = 10 / 2;
// Divide a variable by another variable; result is 3
int a = 15;
int b = 5;
int result = a / b;

When dividing integer types, the result is an integer type (see the previous
chapter for the exact data type conversions for mathematical operations). This
means that if you divide an integer unevenly by another integer, it returns the
whole number part of the result; it does not perform any rounding. For example,
consider the following two operations that both result to 1.

Both result1 and result2 resolve to be 1, even though
result1 would typically resolve to 2 if you were rounding off the
result. Therefore, be cognizant of the fact that integer division in Java
results in only the whole number part of the result, any fractional part is
dropped.

When dividing floating-point variables or values, this caution can be safely
ignored. Floating-point division results in the correct result: The fractional
part of the answer is represented in the floating-point variable.

Note the appearance of the f following each literal value in the
first line. When creating a floating-point literal value (a value that has a
fractional element), the default assumption by the compiler is that the values
are double. So, to explicitly tell the compiler that the value is a
float and not a double, you can suffix the value with either a
lowercase or uppercase F.

Modulus

If integer division results in dropping the remainder of the operation, what
happens to it? For example if you divide 10 by 6:

int i = 10 / 6;

The Java result is 1, but the true result is 1 Remainder 4. What happened to
the remainder 4?

Java provides a mechanism to get the remainder of a division operation
through the modulus operator, denoted by the percent character (%). Although the
previous example had a result of 1, the modulus of the operation would give you
that missing 4. The form of a modulus operation is

operand % operand

For example:

int i = 10 / 6; // i = 1
int r = 10 % 6; // r = 4

Similar to the other arithmetic operators in this chapter, the modulus of an
operation can be performed between variables, literals, and constants.