In Java, you need to be aware of the type of the result of a binary (two-argument) arithmetic operator.

For unary (single-argument) arithmetic operators:

This can result in unexpected behavior for a newcomer to Java programming. For example, the code below results in a compilation error:

short a = 1;
short b = 2;
short c = a + b;    // Compilation error

The reason is that the result of the addition is an int value, which cannot be stored in a variable typed short unless you explicitly cast it, as in:

short c = (short) (a + b);

Also, there are a couple of quirks to keep in mind regarding division by 0:

	Note
	In Java, unlike C/C++, it is legal to compute the remainder of floating-point numbers. The result is the remainder after dividing the dividend by the divisor an integral number of times. For example, 7.9 % 1.2 results in 0.7 (approximately, given the precision of a float or double type).

The location of the shortcut operator is only important if the operator is used in an expression where the operand value is assigned to another variable or returned from a method.

That is to say that:

x++;

is equivalent to:

++x;

But in an assignment:

y = x++;

is not the same as:

y = ++x;

Shortcut operators are often used in for loops to increment the loop index variable (as we will see soon).

Only numerical primitive types (byte, short, char, int, float, long, and double) can be compared using the ordering operators (>, >=, <, and <=). Objects and booleans can only be tested for [in]equality (==, !=).

Due to Java’s type safety (booleans are not integers and vice versa), it is not possible to make the common mistake:

int x = 5;
int y = 3 + 2;

// Does not compile
if (x = y) {
    // Do something
}

// You must use equality operator
if (x == y) {
    // Do something
}

These logical operators accept boolean values only. Attempting to use numerical or other operand types results in a compilation error.

As with many modern programming languages, Java uses short circuit evaluation when evaluating logical boolean operators. This means that conditional operators evaluate the second operand only when needed:

For example:

int i = 0;
int j = 5;
if ( (i != 0) && ((j / i) > 1) ) {
    // Do something
}

Because we use a logical AND (&&), the first expression evaluates to false and so the second expression is not tested and the overall condition is false.

In general, these bitwise operators may be applied to integral values only. For the ~, &, \|, and ^ operators:

For the shift operators:

The bitwise operators may also be used with boolean values to produce a boolean result. However, you cannot combine boolean and integral operands in a bitwise expression.

Actually, a compound assignment expression of the form E1 op= E2 is equivalent to E1 = (T) ((E1) op (E1)), where T is the type of E1.

For example, the following code is compiles without error:

short x = 3;
x += 4.6;

and results in x having the value 7 because it is equivalent to:

short x = 3;
x = (short) (x + 4.6);

The short-cut conditional operator (?:) (also known as the “if-then-else operator” or the “ternary operator”) is used very often to make Java code more compact, so it is worthwhile to get accustomed to it.

For example:

int x = 0;
int y = 5;

// Long way

int z1;
if (x == 0) {
    z1 = 0;
} else {
    z1 = x / y;
}

// Short-cut way
int z2 = (x == 0) ? 0 : x / y;

We’ll explore the other operators listed on this slide in more depth throughout this class.

Use the () operator to change precedence of operators:

x << (((((x == 0 ? 0 : (x / y)) + 5) * z) > 4) ? 3 : 7)

Other than in the most trivial situations, It is always a good practice to use () to document your intentions, regardless of precedence rules.

For example, change:

int x = 5 - y * 2 > 0 ? y : 2 * y;

to:

int x = ((5 - (y * 2)) > 0) ? y : (2 * y);

even though both lines will assign the same value to x