Additive Operators

The additive operators consist of addition (+), subtraction (-), postdecrement (--), postincrement (++), predecrement (--), preincrement (++), and string concatenation (+). Addition returns the sum of its operands (such as 6 + 4 returns 10), subtraction returns the difference between its operands (such as 6 - 4 returns 2 and 4 - 6 returns -2), postdecrement subtracts 1 from its variable operand and returns the variable’s prior value (such as x--), postincrement adds 1 to its variable operand and returns the variable’s prior value (such as x++), predecrement subtracts 1 from its variable operand and returns the variable’s new value (such as --x), preincrement adds 1 to its variable operand and returns the variable’s new value (such as ++x), and string concatenation merges its string operands and returns the merged string (such as "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 isn’t a string, the operand is 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".

Listing 2-5 presents a CompoundExpressions application that lets you start experimenting with the additive operators.

Listing 2-5. Experimenting with the Additive Operators

public class CompoundExpressions
{
   public static void main(String[] args)
   {
      int age = 65;
      System.out.println(age + 32);
      System.out.println(++age);
      System.out.println(age--);
      System.out.println("A" + "B");
      System.out.println("A" + 5);
      short x = 32767;
      System.out.println(++x);
   }
}

Listing 2-5’s main() method first declares a 32-bit integer age variable that’s initialized to 32-bit integer value 65. It then outputs the result of an expression that adds age’s value to 32-bit integer value 32.

The preincrement and postdecrement operators are now demonstrated. First, preincrement adds 1 to age and the result is output. Then, age’s current value is output and this variable is then decremented via postdecrement. What age values do you think are output?

The next two expression examples demonstrate string concatenation. First, "B" is concatenated to "A" and the resulting AB is output. Then, 32-bit integer value 5 is converted to a one-character string consisting of character 5, which is then concatenated to "A". The resulting A5 is output.

At this point, overflow is demonstrated. First, a 16-bit short integer variable named x is declared and initialized to the largest positive short integer: 32767. The preincrement operator is then applied to x and the result (-32768) is output.

Compile Listing 2-5, as follows:

javac CompoundExpressions.java

Assuming successful compilation, execute the following command to run this application:

java CompoundExpressions

You should observe the following output:

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, such as 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. (A two-dimensional array is essentially a one-dimensional row array of one-dimensional column arrays.)

Listing 2-6 presents a CompoundExpressions application that lets you start experimenting with the array index operator.

Listing 2-6. Experimenting with the Array Index Operator

public class CompoundExpressions
{
   public static void main(String[] args)
   {
      int[] ages = { 52, 28, 93, 16 };
      char gradeLetters[] = { 'A', 'B', 'C', 'D', 'F' };
      float[][] matrix = { { 1.0F, 2.0F, 3.0F }, { 4.0F, 5.0F, 6.0F }};
      System.out.println(ages[0]);
      System.out.println(gradeLetters[2]);
      System.out.println(matrix[1][2]);
      System.out.println(ages['u0002']);
      ages[1] = 19;
      System.out.println(ages[1]);
   }
}

Listing 2-6’s main() method first declares and assigns arrays to variables ages, gradeLetters, and matrix. It then uses the array index operator to access the first element in the ages array (ages[0]), the third element in the gradeLetters array (gradeLetters[2]), and the third column element in the second row element of the matrix table array (matrix[1][2]).

Array indexes must be integer values. These values can be of byte integer, short integer, or integer type. However, they cannot be of long integer type because that could result in a loss of precision. The maximum number of elements that can be stored in an array is a bit less than the largest positive 32-bit integer; a long integer can be much larger than this value.

main() next demonstrates that you can also specify a character as an index value (ages['u0002']). This is legal because Java supports a character-to-integer widening rule; it converts a character value to an integer value, which is then used as an index into the array (ages[2]). However, you should avoid using characters as array indexes because they’re not intuitive and are potentially error prone. For example, what element is accessed by ages['A']? The answer is the 66th element; A’s Unicode value is 65 and the first array index is 0. Given the previous four-element ages array, ages['A'] would result in ArrayIndexOutOfBoundsException.

Finally, main() demonstrates that you can also use the array index operator to assign a value to an array element. In this case, integer 19 is stored in the second array element, which is subsequently accessed and output.

Compile Listing 2-6 (javac CompoundExpressions.java) and run this application (java CompoundExpressions). You should observe the following output:

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, in pennies += 50;, the += operator evaluates the numeric expression on its right (50) and adds the result to the contents of the variable on its left (pennies). 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, check out Listing 2-7.

Listing 2-7. Experimenting with the Bitwise Operators

public class CompoundExpressions
{
   public static void main(String[] args)
   {
      System.out.println(∼181);
      System.out.println(26 & 183);
      System.out.println(26 ^ 183);
      System.out.println(26 | 183);
   }
}

Compile Listing 2-7 (javac CompoundExpressions.java) and run this application (java CompoundExpressions). You should observe the following output:

To make sense of these values, it helps to examine their 32-bit binary representations:

• 181 corresponds to 00000000000000000000000010110101
• 26 corresponds to 00000000000000000000000000011010
• 183 corresponds to 00000000000000000000000010110111

When you specify ∼181, you end up flipping all of the bits: ∼00000000000000000000000010110101 results in 11111111111111111111111101001010. According to twos-complement representation, an integer whose leading bit is 1 is regarded to be negative, which is why ∼181 equates to -182.

The expression 26 & 183 can be represented in binary as follows:

00000000000000000000000000011010
&
00000000000000000000000010110111
--------------------------------
00000000000000000000000000010010

The resulting binary value equates to 18.

The expression 26 ^ 183 can be represented in binary as follows:

00000000000000000000000000011010
^
00000000000000000000000010110111
--------------------------------
00000000000000000000000010101101

The resulting binary value equates to 173.

The expression 26 | 183 can be represented in binary as follows:

00000000000000000000000000011010
|
00000000000000000000000010110111
--------------------------------
00000000000000000000000010111111

The resulting binary value equates to 191.

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 to 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 64-bit double precision floating-point value to a 16-bit signed short integer results in the loss of the fraction .65, so s would contain 4 instead of 4.65.

Recognizing that information loss might not always be a problem, Java permits you to state your intention explicitly 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 wouldn’t fit.

The solution to this problem is to introduce a (byte) cast operator 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 isn’t 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.

Listing 2-8 presents a CompoundExpressions application that lets you start experimenting with the cast operator.

Listing 2-8. Experimenting with the Cast Operator

public class CompoundExpressions
{
   public static void main(String[] args)
   {
      short s = (short) 1.65 + 3;
      System.out.println(s);
 
      char c = 'A';
      byte b = (byte) c;
      System.out.println(b);
 
      b = 100;
      System.out.println(b);
 
      s = 'A';
      System.out.println(s);
 
      s = (short) 'uac00';
      System.out.println(s);
   }
}

Listing 2-8’s main() method first uses the (short) cast operator to narrow the double precision floating-point expression 1.65 + 3 to a 16-bit short integer that’s ultimately assigned to short integer variable s. After outputting s’s value (4), this method demonstrates the mandatory (byte) cast operator when converting from a 16-bit unsigned character type to an 8-bit signed byte integer type.

As previously mentioned, the (byte) cast operator isn’t always required. For example, when assigning a 32-bit signed integer in the range of -128 through +127 to a byte integer variable, (byte) can be omitted because no information will be lost. Assigning 100 to b demonstrates this scenario.

In a similar way, various 16-bit unsigned character values (such as 'A') can be assigned to a 16-bit signed short integer variable without loss of information, and so the (short) cast operator can be avoided. However, other 16-bit unsigned character values don’t fit into this range and must be cast to a short integer before assignment ('uac00', for example).

Compile Listing 2-8 (javac CompoundExpressions.java) and run this application (java CompoundExpressions). You should observe the following output:

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 isn’t 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 isn’t 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 upon 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

Listing 2-9 presents a CompoundExpressions application that lets you start experimenting with the conditional operators.

Listing 2-9. Experimenting with the Conditional Operators

public class CompoundExpressions
{
   public static void main(String[] args)
   {
      int age = 65;
      boolean stillWorking = true;
      System.out.println(age > 64 && stillWorking);
      age--;
      System.out.println(age > 64 && stillWorking);
      int value = 30;
      System.out.println(value < 20 || value > 40);
      value = 10;
      System.out.println(value < 20 || value > 40);
      int numEmployees = 6;
      age = 65;
      System.out.println(age > 64 && ++numEmployees > 5);
      System.out.println("numEmployees = " + numEmployees);
      age = 63;
      System.out.println(age > 64 && ++numEmployees > 5);
      System.out.println("numEmployees = " + numEmployees);
      boolean b = true;
      int i = b ? 1 : 0; // 1 assigns to i
      System.out.println("i = " + i);
      b = false;
      i = b ? 1 : 0; // 0 assigns to i
      System.out.println("i = " + i);
   }
}

Compile Listing 2-9 (javac CompoundExpressions.java) and run this application (java CompoundExpressions). You should observe the following output:

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 and 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.

You have to be careful when comparing floating-point expressions for equality. For example, what does System.out.println(0.3 == 0.1 + 0.1 + 0.1); output? If you guessed that the output is true, you would be wrong. Instead, the output is false.

The reason for this nonintuitive output is that 0.1 cannot be represented exactly in memory. The error compounds when this value is added to itself. For example, if you executed System.out.println(0.1 + 0.1 + 0.1);, you would observe 0.30000000000000004, which doesn’t equal 0.3.

When it comes to object operands (I discuss objects in Chapter 3), these operators don’t compare their contents. Instead, object references are compared. For example, "abc" == "xyz" doesn’t compare a with x. Because string literals are really String objects (Chapter 7 discusses the String class), == 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; there’s no short-circuiting. This same pattern holds for logical exclusive OR and logical inclusive OR.

Listing 2-10 presents a CompoundExpressions application that lets you start experimenting with the logical operators.

Listing 2-10. Experimenting with the Logical Operators

public class CompoundExpressions
{
   public static void main(String[] args)
   {
      System.out.println(!false);
      int age = 65;
      boolean stillWorking = true;
      System.out.println(age > 64 & stillWorking);
      System.out.println();
       
      boolean result = true & true;
      System.out.println("true & true: " + result);
      result = true & false;
      System.out.println("true & false: " + result);
      result = false & true;
      System.out.println("false & true: " + result);
      result = false & false;
      System.out.println("false & false: " + result);
      System.out.println();
 
      result = true | true;
      System.out.println("true | true: " + result);
      result = true | false;
      System.out.println("true | false: " + result);
      result = false | true;
      System.out.println("false | true: " + result);
      result = false | false;
      System.out.println("false | false: " + result);
      System.out.println();
 
      result = true ^ true;
      System.out.println("true ^ true: " + result);
      result = true ^ false;
      System.out.println("true ^ false: " + result);
      result = false ^ true;
      System.out.println("false ^ true: " + result);
      result = false ^ false;
      System.out.println("false ^ false: " + result);
      System.out.println();
 
      int numEmployees = 1;
      age = 65;
      System.out.println(age > 64 & ++numEmployees > 2);
      System.out.println(numEmployees);
   }
}

After outputting the results of the !false and age > 64 & stillWorking expressions, main() outputs three truth tables that show how logical AND, logical inclusive OR, and logical exclusive OR behave when their operands are true or false. It then demonstrates that short-circuiting is ignored by incrementing numEmployees when age > 64 returns true.

Compile Listing 2-10 (javac CompoundExpressions.java) and run this application (java CompoundExpressions). You should observe the following output:

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. Also, it identifies the number, order, and types of arguments that are passed to the method to be picked up by the method’s parameters. For example, in the System.out.println("Hello"); method call, () signifies that a method named println is being called with one argument: "Hello".

Multiplicative Operators

The multiplicative operators consist of multiplication (*), division (/), and remainder (%). Multiplication returns the product of its operands (such as 6 * 4 returns 24), division returns the quotient of dividing its left operand by its right operand (such as 6 / 4 returns 1), and remainder returns the remainder of dividing its left operand by its right operand (such as 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 (Chapter 5 covers exceptions). 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).

Listing 2-11 presents a CompoundExpressions application that lets you start experimenting with the multiplicative operators.

Listing 2-11. Experimenting with the Multiplicative Operators

public class CompoundExpressions
{
   public static void main(String[] args)
   {
      short age = 65;
      System.out.println(age * 1000);
      System.out.println(1.0 / 0.0);
      System.out.println(10 % 4);
      System.out.println(3 / 0);
   }
}

Compile Listing 2-11 (javac CompoundExpressions.java) and run this application (java CompoundExpressions). You should observe the following output:

Object Creation Operator

The object creation operator (new) creates an object from a class, and it also creates an array from an initializer. These topics are discussed 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, returning true when this is the case. For example, "abc" instanceof String returns true because "abc" is a String object. I discuss this operator more fully 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 three 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 three 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.

Listing 2-12 presents a CompoundExpressions application that lets you start experimenting with the shift operators.

Listing 2-12. Experimenting with the Shift Operators

public class CompoundExpressions
{
   public static void main(String[] args)
   {
      System.out.println(2 << 3);
      System.out.println(16 >> 3);
      System.out.println(-4 >> 1);
      System.out.println(-4 >>> 1);
   }
}

Compile Listing 2-12 (javac CompoundExpressions.java) and run this application (java CompoundExpressions). You should observe the following output:

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 it is presented 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)), where 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.

Listing 2-13 presents a CompoundExpressions application that lets you start experimenting with precedence and associativity.

Listing 2-13. Experimenting with Precedence and Associativity

public class CompoundExpressions
{
   public static void main(String[] args)
   {
      System.out.println(60 + 3 * 6);
      System.out.println(2 * ((60 + 3) * 6));
      System.out.println(9 * 4 / 3);
      int x, y, z;
      x = y = z = 100;
      System.out.println(x);
      System.out.println(y);
      System.out.println(z);
 
      int i = 0x12345678;
      byte b = (byte) (i & 255);
      System.out.println(b);
      System.out.println("b == 0x78: " + (b == 0x78));
      b = (byte) ((i >> 8) & 255);
      System.out.println(b);
      System.out.println("b == 0x56: " + (b == 0x56));
      b = (byte) ((i >> 16) & 255);
      System.out.println(b);
      System.out.println("b == 0x34: " + (b == 0x34));
      b = (byte) ((i >> 24) & 255);
      System.out.println(b);
      System.out.println("b == 0x12: " + (b == 0x12));
  }
}

You’ll often find yourself needing to use open and close parentheses to change an expression’s evaluation order. For example, consider the second part of the main() method, which extracts each of the 4 bytes in the 32-bit value assigned to integer variable i and outputs this byte.

After processing the declaration and initialization of 32-bit integer variable i (int i = 0x12345678;), the compiler encounters byte b = (byte) (i & 255);. It generates bytecode that first evaluates expression i & 255, which returns a 32-bit result, passes this result to the (byte) cast operator to convert it to an 8-bit result, and assigns the 8-bit result to 8-bit byte integer variable b.

Suppose the parentheses were absent, resulting in byte b = (byte) i & 255;. The compiler would then report an error about loss of precision because it interprets this expression as follows.

1. Cast variable i to an 8-bit byte integer. The cast operator is a unary operator that takes only one operand. Also, cast has higher precedence (12) than bitwise AND (6) so cast is evaluated first.
2. Widen i to a 32-bit integer as the left operand of bitwise AND (&). Operand 255 is already a 32-bit integer.
3. Apply bitwise AND to these operands. The result is a 32-bit integer.
4. Attempt to assign the 32-bit integer result to 8-bit byte integer variable b.

The 32-bit integer result can vary from 0 through 255. However, the largest positive integer that b can store is 127. If the result ranges from 128 through 255, it will be converted to -1 through -128. This is a loss of precision and so the compiler reports an error.

Another example where main() uses open and close parentheses to change evaluation order is System.out.println("b == 0x78: " + (b == 0x78));. When the parentheses are missing, the compiler reports an “incomparable types: String and int” error. It does so because string concatenation has higher precedence (10) than equality (7). As a result, the compiler interprets the expression (without parentheses) as follows.

1. Convert b’s value to a string.
2. Concatenate this string to "b == 0x78: ".
3. Compare the resulting string with 32-bit integer 0x78 for equality, which is illegal.

Compile Listing 2-13 (javac CompoundExpressions.java) and run this application (java CompoundExpressions). You should observe the following output:

If Statement

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

if (Boolean expression)
   statement

This statement 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 the if 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-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. It has the following syntax:

if (Boolean expression)
   statement1

else
   statement2

This statement 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 the if-else 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’s 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’re 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.

Listing 2-14 presents a GradeLetters application that demonstrates chaining together multiple if-else statements.

Listing 2-14. Experimenting with If-Else Chaining

public class GradeLetters
{
   public static void main(String[] args)
   {
      int testMark = 69;
      char gradeLetter;
 
      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("You'll 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 fail and need to attend summer school.");
      }
 
      System.out.println("Your grade is " + gradeLetter + ".");
   }
}

Compile Listing 2-14 as follows:

javac GradeLetters.java

Execute the resulting application as follows:

java GradeLetters

You should observe the following output:

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. It has the following syntax:

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

This statement 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. It has the following syntax:

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

This statement 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.

The for statement 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 for to iterate over the array of command-line arguments passed to main():

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

The initialization section declares variable i for controlling the loop, the 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 the update section increments i by 1. The for-based loop continues until i’s value equals the array’s length.

Each array element is accessed via the args[i] expression, which returns this array’s ith element’s value (which happens to be a String object in this example). The first value is stored in args[0].

Listing 2-15 presents a DumpMatrix application that uses a for-based loop to output the contents of a two-dimensional matrix array.

Listing 2-15. Iterating over a Two-Dimensional Array’s Rows and Columns

public class DumpMatrix
{
   public static void main(String[] args)
   {
      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.

Compile Listing 2-15 as follows:

javac DumpMatrix.java

Execute the resulting application as follows:

java DumpMatrix

You should observe the following output:

While Statement

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

while (Boolean expression)
   statement

This statement consists of reserved word while, followed by a parenthesized Boolean expression, followed by a statement to execute repeatedly. The while statement first evaluates the Boolean expression. If it’s true, while executes the other statement. Once again, the Boolean expression is evaluated. If it’s still true, while re-executes the statement. This cyclic pattern continues.

Prompting the user to enter a specific character is one situation where 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 first initializes 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 before 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 one or more bytes from the standard input device, and read() returns the next byte (or -1 when there are no more bytes).

After 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. Detecting 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. Detecting that the expression is true, conditional AND evaluates ch != 'c', which evaluates to false. Once again, the while statement terminates.

Do-While Statement

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

do
   statement
while (Boolean expression);

This statement consists of the do reserved word, followed by a statement to execute repeatedly, 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’s true, do-while executes the other statement. Once again, the Boolean expression is evaluated. If it’s 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 before the test, it’s no longer necessary to initialize ch—ch is assigned System.in.read()’s return value before 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.