Additive Operators

The additive operators consist of addition (+), subtraction (−), postdecrement (−−), postincrement (++), predecrement (−−), preincrement (++), and string concatenation (+). Addition returns the sum of its operands (e.g., 6 + 4 returns 10), subtraction returns the difference between its operands (e.g., 6 – 4 returns 2 and 4 – 6 returns −2), postdecrement subtracts one from its variable operand and returns the variable’s prior value (e.g., x−−), postincrement adds one to its variable operand and returns the variable’s prior value (e.g., x++), predecrement subtracts one from its variable operand and returns the variable’s new value (e.g., −−x), preincrement adds one to its variable operand and returns the variable’s new value (e.g., ++x), and string concatenation merges its string operands and returns the merged string (e.g., "A" + "B" returns "AB").

The addition, subtraction, postdecrement, postincrement, predecrement, and preincrement operators can yield values that overflow or underflow the limits of the resulting value’s type. For example, adding two large positive 32-bit integer values can produce a value that cannot be represented as a 32-bit integer value. The result is said to overflow. Java doesn’t detect overflows and underflows.

Java provides a special widening conversion rule for use with string operands and the string concatenation operator. When either operand is not a string, the operand is first converted to a string prior to string concatenation. For example, when presented with "A" + 5, the compiler generates code that first converts 5 to "5" and then performs the string concatenation operation, resulting in "A5".

Array Index Operator

The array index operator ([]) accesses an array element by presenting the location of that element as an integer index. This operator is specified after an array variable’s name, for example, ages[0].

Indexes are relative to 0, which implies that ages[0] accesses the first element, whereas ages[6] accesses the seventh element. The index must be greater than or equal to 0 and less than the length of the array; otherwise, the virtual machine throws ArrayIndexOutOfBoundsException (consult Chapter 5 to learn about exceptions).

An array’s length is returned by appending “.length” to the array variable. For example, ages.length returns the length of (the number of elements in) the array that ages references. Similarly, matrix.length returns the number of row elements in the matrix two-dimensional array, whereas matrix[0].length returns the number of column elements assigned to the first row element of this array.

Assignment Operators

The assignment operator (=) assigns an expression’s result to a variable (as in int x = 4;). The types of the variable and expression must agree; otherwise, the compiler reports an error.

Java also supports several compound assignment operators that perform a specific operation and assign its result to a variable. For example, the += operator evaluates the numeric expression on its right and adds the result to the contents of the variable on its left. The other compound assignment operators behave in a similar way.

Bitwise Operators

The bitwise operators consist of bitwise AND (&), bitwise complement (∼), bitwise exclusive OR (^), and bitwise inclusive OR (|). These operators are designed to work on the binary representations of their character or integral operands. Because this concept can be hard to understand if you haven’t previously worked with these operators in another language, the following output from a hypothetical application demonstrates these operators:

∼00000000000000000000000010110101 results in 11111111111111111111111101001010
00011010 & 10110111 results in 00000000000000000000000000010010
00011010 ^ 10110111 results in 00000000000000000000000010101101
00011010 | 10110111 results in 00000000000000000000000010111111

The &, ^, and | operators in the last three lines first convert their byte integer operands to 32-bit integer values (through sign bit extension, copying the sign bit’s value into the extra bits) before performing their operations.

Cast Operator

The cast operator—( type )—attempts to convert the type of its operand to type. This operator exists because the compiler will not allow you to convert a value from one type to another in which information will be lost without specifying your intention do so (via the cast operator). For example, when presented with short s = 1.65 + 3;, the compiler reports an error because attempting to convert a double precision floating-point value to a short integer results in the loss of the fraction .65—s would contain 4 instead of 4.65.

Recognizing that information loss might not always be a problem, Java permits you to explicitly state your intention by casting to the target type. For example, short s = (short) 1.65 + 3; tells the compiler that you want 1.65 + 3 to be converted to a short integer and that you realize that the fraction will disappear.

The following example provides another demonstration of the need for a cast operator:

char c = 'A';
byte b = c;

The compiler reports an error about loss of precision when it encounters byte b = c;. The reason is that c can represent any unsigned integer value from 0 through 65535, whereas b can only represent a signed integer value from −128 through +127. Even though 'A' equates to +65, which can fit within b’s range, c could just have easily been initialized to 'u0323', which would not fit.

The solution to this problem is to introduce a (byte) cast, as follows, which causes the compiler to generate code to cast c’s character type to byte integer:

byte b = (byte) c;

Java supports the following primitive-type conversions via cast operators:

• Byte integer to character
• Short integer to byte integer or character
• Character to byte integer or short integer
• Integer to byte integer, short integer, or character
• Long integer to byte integer, short integer, character, or integer
• Floating-point to byte integer, short integer, character, integer, or long integer
• Double precision floating-point to byte integer, short integer, character, integer, long integer, or floating-point

A cast operator is not always required when converting from more to fewer bits and where no data loss occurs. For example, when it encounters byte b = 100;, the compiler generates code that assigns integer 100 to byte integer variable b because 100 can easily fit into the 8-bit storage location assigned to this variable.

Conditional Operators

The conditional operators consist of conditional AND (&&), conditional OR (||), and conditional (?:). The first two operators always evaluate their left operand (a Boolean expression that evaluates to true or false) and conditionally evaluate their right operand (another Boolean expression). The third operator evaluates one of two operands based on a third Boolean operand.

Conditional AND always evaluates its left operand and evaluates its right operand only when its left operand evaluates to true. For example, age > 64 && stillWorking first evaluates age > 64. If this subexpression is true, stillWorking is evaluated, and its true or false value (stillWorking is a Boolean variable) serves as the value of the overall expression. If age > 64 is false, stillWorking is not evaluated.

Conditional OR always evaluates its left operand and evaluates its right operand only when its left operand evaluates to false. For example, value < 20 || value > 40 first evaluates value < 20. If this subexpression is false, value > 40 is evaluated, and its true or false value serves as the overall expression’s value. If value < 20 is true, value > 40 is not evaluated.

Conditional AND and conditional OR boost performance by preventing the unnecessary evaluation of subexpressions, which is known as short-circuiting. For example, if its left operand is false, there is no way that conditional AND’s right operand can change the fact that the overall expression will evaluate to false.

If you aren’t careful, short-circuiting can prevent side effects (the results of subexpressions that persist after the subexpressions have been evaluated) from executing. For example, age > 64 && ++numEmployees > 5 increments numEmployees for only those employees whose ages are greater than 64. Incrementing numEmployees is an example of a side effect because the value in numEmployees persists after the subexpression ++numEmployees > 5 has evaluated.

The conditional operator is useful for making a decision by evaluating and returning one of two operands based on the value of a third operand. The following example converts a Boolean value to its integer equivalent (1 for true and 0 for false):

boolean b = true;
int i = b ? 1 : 0; // 1 assigns to i

Equality Operators

The equality operators consist of equality (==) and inequality (!=). These operators compare their operands to determine whether they are equal or unequal. The former operator returns true when equal; the latter operator returns true when unequal. For example, each of 2 == 2 and 2 != 3 evaluates to true, whereas each of 2 == 4 and 4 != 4 evaluates to false.

When it comes to object operands (discussed in Chapter 3), these operators do not compare their contents. For example, "abc" == "xyz" doesn’t compare a with x. Instead, because string literals are really String objects (in Chapter 7 I discuss this concept further), == compares the references to these objects.

Logical Operators

The logical operators consist of logical AND (&), logical complement (!), logical exclusive OR (^), and logical inclusive OR (|). Although these operators are similar to their bitwise counterparts, whose operands must be integer/character, the operands passed to the logical operators must be Boolean. For example, !false returns true. Also, when confronted with age > 64 & stillWorking, logical AND evaluates both subexpressions. This same pattern holds for logical exclusive OR and logical inclusive OR.

Member Access Operator

The member access operator (.) is used to access a class’s members or an object’s members. For example, String s = "Hello"; int len = s.length(); returns the length of the string assigned to variable s. It does so by calling the length() method member of the String class. In Chapter 3 I discuss member access in more detail.

Arrays are special objects that have a single length member. When you specify an array variable followed by the member access operator, followed by length, the resulting expression returns the number of elements in the array as a 32-bit integer. For example, ages.length returns the length of (the number of elements in) the array that ages references.

Method Call Operator

The method call operator—()—is used to signify that a method (discussed in Chapter 3) is being called. Furthermore, it identifies the number, order, and types of arguments that are passed to the method to be picked up by the method’s parameters. System.out.println("Hello"); is an example.

Multiplicative Operators

The multiplicative operators consist of multiplication (*), division (/), and remainder (%). Multiplication returns the product of its operands (e.g., 6*4 returns 24), division returns the quotient of dividing its left operand by its right operand (e.g., 6/4 returns 1), and remainder returns the remainder of dividing its left operand by its right operand (e.g., 6%4 returns 2).

The multiplication, division, and remainder operators can yield values that overflow or underflow the limits of the resulting value’s type. For example, multiplying two large positive 32-bit integer values can produce a value that cannot be represented as a 32-bit integer value. The result is said to overflow. Java doesn’t detect overflows and underflows.

Dividing a numeric value by 0 (via the division or remainder operator) also results in interesting behavior. Dividing an integer value by integer 0 causes the operator to throw an ArithmeticException object (I cover exceptions in Chapter 5). Dividing a floating-point/double precision floating-point value by 0 causes the operator to return +infinity or -infinity, depending on whether the dividend is positive or negative. Finally, dividing floating-point 0 by 0 causes the operator to return NaN (Not a Number).

Object Creation Operator

The object creation operator (new) creates an object from a class and also creates an array from an initializer. I discuss these topics in Chapter 3.

Relational Operators

The relational operators consist of greater than (>), greater than or equal to (>=), less than (<), less than or equal to (<=), and type checking (instanceof). The former four operators compare their operands and return true when the left operand is (respectively) greater than, greater than or equal to, less than, or less than or equal to the right operand. For example, each of 5.0 > 3, 2 >= 2, 16.1 < 303.3, and 54.0 <= 54.0 evaluates to true.

The type-checking operator is used to determine if an object belongs to a specific type. I discuss this topic in Chapter 4.

Shift Operators

The shift operators consist of left shift (<<), signed right shift (>>), and unsigned right shift (>>>). Left shift shifts the binary representation of its left operand leftward by the number of positions specified by its right operand. Each shift is equivalent to multiplying by 2. For example, 2 << 3 shifts 2’s binary representation left by 3 positions; the result is equivalent to multiplying 2 by 8.

Each of signed and unsigned right shift shifts the binary representation of its left operand rightward by the number of positions specified by its right operand. Each shift is equivalent to dividing by 2. For example, 16 >> 3 shifts 16’s binary representation right by 3 positions; the result is equivalent to dividing 16 by 8.

The difference between signed and unsigned right shift is what happens to the sign bit during the shift. Signed right shift includes the sign bit in the shift, whereas unsigned right shift ignores the sign bit. As a result, signed right shift preserves negative numbers, but unsigned right shift doesn’t. For example, −4 >> 1 (the equivalent of −4 / 2) evaluates to −2, whereas −4 >>> 1 evaluates to 2147483646.

Unary Minus/Plus Operators

Unary minus (−) and unary plus (+) are the simplest of all operators. Unary minus returns the negative of its operand (such as −5 returns −5 and --5 returns 5), whereas unary plus returns its operand verbatim (such as +5 returns 5 and +−5 returns −5). Unary plus is not commonly used but is present for completeness.

Precedence and Associativity

When evaluating a compound expression, Java takes each operator’s precedence (level of importance) into account to ensure that the expression evaluates as expected. For example, when presented with the expression 60 + 3 * 6, you expect multiplication to be performed before addition (multiplication has higher precedence than addition), and the final result to be 78. You don’t expect addition to occur first, yielding a result of 378.

Precedence can be circumvented by introducing open and close parentheses, ( and ), into the expression, where the innermost pair of nested parentheses is evaluated first. For example, evaluating 2 * ((60 + 3) * 6) results in (60 + 3) being evaluated first, (60 + 3) * 6 being evaluated next, and the overall expression being evaluated last. Similarly, in the expression 60 / (3–6), subtraction is performed before division.

During evaluation, operators with the same precedence level (such as addition and subtraction, which both have level 10) are processed according to their associativity (a property that determines how operators having the same precedence are grouped when parentheses are missing).

For example, expression 9 * 4 / 3 is evaluated as if it was (9 * 4) / 3 because * and / are left-to-right associative operators. In contrast, expression x = y = z = 100 is evaluated as if it was x = (y = (z = 100))—100 is assigned to z, z’s new value (100) is assigned to y, and y’s new value (100) is assigned to x—because = is a right-to-left associative operator.

Most of Java’s operators are left-to-right associative. Right-to-left associative operators include assignment, bitwise complement, cast, compound assignment, conditional, logical complement, object creation, predecrement, preincrement, unary minus, and unary plus.

If Statement

The if statement evaluates a Boolean expression and executes another statement when this expression evaluates to true. This statement has the following syntax:

if (Boolean expression)
   statement

If consists of reserved word if, followed by a Boolean expression in parentheses, followed by a statement to execute when Boolean expression evaluates to true.

The following example demonstrates this statement:

if (numMonthlySales > 100)
   wage += bonus;

If the number of monthly sales exceeds 100, numMonthlySales > 100 evaluates to true and the wage += bonus; assignment statement executes. Otherwise, this assignment statement doesn’t execute.

if (numMonthlySales > 100){
   wage += bonus;
}

If-Else Statement

The if-else statement evaluates a Boolean expression and executes one of two statements depending on whether this expression evaluates to true or false. This statement has the following syntax:

if (Boolean expression)
   statement1
else
   statement2

If-else consists of reserved word if, followed by a Boolean expression in parentheses, followed by a statement1 to execute when Boolean expression evaluates to true, followed by a statement2 to execute when Boolean expression evaluates to false.

The following example demonstrates this statement:

if ((n & 1) == 1)
   System.out.println("odd");
else
   System.out.println("even");

This example assumes the existence of an int variable named n that has been initialized to an integer. It then proceeds to determine if the integer is odd (not divisible by 2) or even (divisible by 2).

The Boolean expression first evaluates n & 1, which bitwise ANDs n’s value with 1. It then compares the result to 1. If they are equal, a message stating that n’s value is odd outputs; otherwise, a message stating that n’s value is even outputs.

The parentheses are required because == has higher precedence than &. Without these parentheses, the expression’s evaluation order would change to first evaluating 1 == 1 and then trying to bitwise AND the Boolean result with n’s integer value. This order results in a compiler error message because of a type mismatch: you cannot bitwise AND an integer with a Boolean value.

You could rewrite this if-else statement example to use the conditional operator, as follows: System.out.println((n & 1) == 1 ? "odd" : "even");. However, you cannot do so with the following example:

if ((n & 1) == 1)
   odd();
else
   even();

This example assumes the existence of odd() and even() methods that don’t return anything. Because the conditional operator requires that each of its second and third operands evaluates to a value, the compiler reports an error when attempting to compile (n & 1) == 1 ? odd() : even().

You can chain multiple if-else statements together, resulting in the following syntax:

if (Boolean expression1)
   statement1
else
if (Boolean expression2)
   statement2
else
   ...
else
   statementN

If Boolean expression1 evaluates to true, statement1 executes. Otherwise, if Boolean expression2 evaluates to true, statement2 executes. This pattern continues until one of these expressions evaluates to true and its corresponding statement executes, or the final else is reached and statementN (the default statement) executes.

The following example demonstrates this chaining:

if (testMark >= 90)
{
   gradeLetter = 'A';
   System.out.println("You aced the test.");
}
else
if (testMark >= 80)
{
   gradeLetter = 'B';
   System.out.println("You did very well on this test.");
}
else
if (testMark >= 70)
{
   gradeLetter = 'C';
   System.out.println("Not bad, but you need to study more for future tests.");
}
else
if (testMark >= 60)
{
   gradeLetter = 'D';
   System.out.println("Your test result suggests that you need a tutor.");
}
else
{
   gradeLetter = 'F';
   System.out.println("Your test result is pathetic; you need summer school.");
}

Switch Statement

The switch statement lets you choose from among several execution paths in a more efficient manner than with equivalent chained if-else statements. This statement has the following syntax:

switch (selector expression )
{
   casevalue1 :statement1 [break;]
   casevalue2 :statement2 [break;]
   ...
   casevalueN :statementN [break;]
   [default:statement ]
}

Switch consists of reserved word switch, followed by a selector expression in parentheses, followed by a body of cases. The selector expression is any expression that evaluates to an integer or character value. For example, it might evaluate to a 32-bit integer or to a 16-bit character.

Each case begins with reserved word case; continues with a literal value and a colon character (:); continues with a statement to execute; and optionally concludes with a break statement, which causes execution to continue after the switch statement.

After evaluating the selector expression, switch compares this value with each case’s value until it finds a match. When there is a match, the case’s statement is executed. For example, when the selector expression’s value matches value1, statement1 executes.

The optional break statement (anything placed in square brackets is optional), which consists of reserved word break followed by a semicolon, prevents the flow of execution from continuing with the next case’s statement. Instead, execution continues with the first statement following switch.

If none of the cases’ values match the selector expression’s value, and if a default case (signified by the default reserved word followed by a colon) is present, the default case’s statement is executed.

The following example demonstrates this statement:

switch (direction)
{
   case  0: System.out.println("You are travelling north."); break;
   case  1: System.out.println("You are travelling east."); break;
   case  2: System.out.println("You are travelling south."); break;
   case  3: System.out.println("You are travelling west."); break;
   default: System.out.println("You are lost.");
}

This example assumes that direction stores an integer value. When this value is in the range 0–3, an appropriate direction message is output; otherwise, a message about being lost is output.

For Statement

The for statement lets you loop over a statement a specific number of times or even indefinitely. This statement has the following syntax:

for ([initialize]; [test]; [update])
   statement

For consists of reserved word for, followed by a header in parentheses, followed by a statement to execute. The header consists of an optional initialize section, followed by an optional test section, followed by an optional update section. A nonoptional semicolon separates each of the first two sections from the next section.

The initialize section consists of a comma-separated list of variable declarations or variable assignments. Some or all of these variables are typically used to control the loop’s duration and are known as loop-control variables.

The test section consists of a Boolean expression that determines how long the loop executes. Execution continues as long as this expression evaluates to true.

Finally, the update section consists of a comma-separated list of expressions that typically modify the loop-control variables.

For is perfect for iterating (looping) over an array. Each iteration (loop execution) accesses one of the array’s elements via an array [ index ] expression, where array is the array whose element is being accessed and index is the zero-based location of the element being accessed.

The following example uses the for statement to iterate over the array of command-line arguments that is passed to the main() method:

public static void main(String[] args)
{
   for (int i = 0; i < args.length; i++)
      System.out.println(args[i]);
}

For’s initialization section declares variable i for controlling the loop, its test section compares i’s current value to the length of the args array to ensure that this value is less than the array’s length, and its update section increments i by 1. The loop continues until i’s value equals the array’s length.

Each iteration accesses one of the array’s values via the args[i] expression. This expression returns this array’s ith value (which happens to be a String object in this example). The first value is stored in args[0].

The following example uses for to output the contents of the previously declared matrix array, which is redeclared here for convenience:

float[][] matrix = { { 1.0F, 2.0F, 3.0F }, { 4.0F, 5.0F, 6.0F }};
for (int row = 0; row < matrix.length; row++)
{
   for (int col = 0; col < matrix[row].length; col++)
      System.out.print(matrix[row][col] + " ");
   System.out.print("
");
}

Expression matrix.length returns the number of rows in this tabular array. For each row, expression matrix[row].length returns the number of columns for that row. This latter expression suggests that each row can have a different number of columns, although each row has the same number of columns in the example.

System.out.print() is closely related to System.out.println(). Unlike the latter method, System.out.print() outputs its argument without a trailing newline.

This example generates the following output:

1.0 2.0 3.0
4.0 5.0 6.0

While Statement

The while statement repeatedly executes another statement while its Boolean expression evaluates to true. This statement has the following syntax:

while (Boolean expression)
   statement

While consists of reserved word while, followed by a parenthesized Boolean expression, followed by a statement to repeatedly execute.

The while statement first evaluates the Boolean expression. If it is true, while executes the other statement. Once again, the Boolean expression is evaluated. If it is still true, while re-executes the statement. This cyclic pattern continues.

Prompting the user to enter a specific character is one situation in which while is useful. For example, suppose that you want to prompt the user to enter a specific uppercase letter or its lowercase equivalent. The following example provides a demonstration:

int ch = 0;
while (ch != 'C' && ch != 'c')
{
   System.out.println("Press C or c to continue.");
   ch = System.in.read();
}

This example begins by initializing variable ch. This variable must be initialized; otherwise, the compiler will report an uninitialized variable when it tries to read ch’s value in the while statement’s Boolean expression.

This expression uses the conditional AND operator (&&) to test ch’s value. This operator first evaluates its left operand, which happens to be expression ch != 'C'. (The != operator converts 'C' from 16-bit unsigned char type to 32-bit signed int type prior to the comparison.)

If ch doesn’t contain C (it doesn’t at this point—0 was just assigned to ch), this expression evaluates to true.

The && operator next evaluates its right operand, which happens to be expression ch != 'c'. Because this expression also evaluates to true, conditional AND returns true and while executes the compound statement.

The compound statement first outputs, via the System.out.println() method call, a message that prompts the user to press the C key with or without the Shift key. It next reads the entered keystroke via System.in.read(), saving its integer value in ch.

From left to write, System identifies a standard class of system utilities, in identifies an object located in System that provides methods for inputting 1 or more bytes from the standard input device, and read() returns the next byte (or −1 when there are no more bytes).

Following this assignment, the compound statement ends and while re-evaluates its Boolean expression.

Suppose ch contains C’s integer value. Conditional AND evaluates ch != 'C', which evaluates to false. Seeing that the expression is already false, conditional AND short-circuits its evaluation by not evaluating its right operand and returns false. The while statement subsequently detects this value and terminates.

Suppose ch contains c’s integer value. Conditional AND evaluates ch != 'C', which evaluates to true. Seeing that the expression is true, conditional AND evaluates ch != 'c', which evaluates to false. Once again, the while statement terminates.

for (int i = 0; i < 10; i++)
   System.out.println(i);

int i = 0;
while (i < 10)
{
   System.out.println(i);
   i++;
}

Do-While Statement

The do-while statement repeatedly executes a statement while its Boolean expression evaluates to true. Unlike the while statement, which evaluates the Boolean expression at the top of the loop, do-while evaluates the Boolean expression at the bottom of the loop. This statement has the following syntax:

do
  statement
while (Boolean expression );

Do-while consists of the do reserved word, followed by a statement to repeatedly execute, followed by the while reserved word, followed by a parenthesized Boolean expression, followed by a semicolon.

The do-while statement first executes the other statement. It then evaluates the Boolean expression. If it is true, do-while executes the other statement. Once again, the Boolean expression is evaluated. If it is still true, do-while re-executes the statement. This cyclic pattern continues.

The following example demonstrates do-while prompting the user to enter a specific uppercase letter or its lowercase equivalent:

int ch;
do
{
   System.out.println("Press C or c to continue.");
   ch = System.in.read();
}
while (ch != 'C' && ch != 'c'),

This example is similar to its predecessor. Because the compound statement is no longer executed prior to the test, it’s no longer necessary to initialize ch—ch is assigned System.in.read()’s return value prior to the Boolean expression’s evaluation.

Looping Over the Empty Statement

Java refers to a semicolon character appearing by itself as the empty statement. It’s sometimes convenient for a loop statement to execute the empty statement repeatedly. The actual work performed by the loop statement takes place in the statement header. Consider the following example:

for (String line; (line = readLine()) != null; System.out.println(line));

This example uses for to present a programming idiom for copying lines of text that are read from some source, via the fictitious readLine() method in this example, to some destination, via System.out.println() in this example. Copying continues until readLine() returns null. Note the semicolon (empty statement) at the end of the line.

for (int i = 0; i < 10; i++); // this ; represents the empty statement
   System.out.println("Hello");