Notice: This material is excerpted from Special Edition Using Java, ISBN: 0-7897-0604-0. The electronic version of this material has not been through the final proof reading stage that the book goes through before being published in printed form. Some errors may exist here that are corrected before the book is published. This material is provided "as is" without any warranty of any kind.
by Scott Williams
Expressions-combinations of operators and operands-are one of the key building blocks of the Java language, as they are of many programming languages. Expressions allow you to do arithmetic calculations, concatenate strings, compare values, perform logical operations, and manipulate objects. Without expressions, a programming language is dead-useless and lifeless.
You've already seen expressions, mostly fairly simple ones, in other chapters in this book. Chapter 9 in particular showed you that operators-one of the two key elements in an expression-form one of the main classifications of Java tokens, along with such things as keywords, comments, and so on. In this chapter, you take a closer look at how you can use operators to build expressions-in other words, how to put operators to work for you.
In this chapter, you take a look at the following:
There are all kinds of technical definitions of what an expression is, but at its simplest, an expression is what results when operands and operators are joined together according to the syntax rules of the language. As such, expressions are usually used to perform operations-manipulations-on variables or values. In table 12.1, you see legal Java expressions.Table 12.1 Legal Java Expressions
Name of Expression Example Additive expression x+5 Assignment expression x=5 Array indexing sizes[11] Method invocation Triangle.RotateLeft(50)
In fact, because you don't always need operators, the following are also legal Java expressions, just as they would be legal in C or C++:
As seen in Chapter 9, operators are one of the key categories of tokens in the Java language. Java operators can take one, two, or three operands. Operators that take a single operand are called unary or monadic operators. Some unary operators come before the operand (these are called prefix operators), while others come after the operand (these are called postfix operators). These expressions both use unary operators:
See "Operators," Appendix B
Operators that take two operands are called binary or dyadic operators. These expressions both make use of binary operators:
Java also includes one operator-the conditional operator-that takes three operands. It is called a ternary or triadic operator. You'll learn about it a little later in this chapter.
A complete table of all the Java operators is provided at the end of this chapter.
Virtually every programming language provides a mechanism for arithmetic calculations. In Java, such calculations would be performed in arithmetic expressions. Because you are already no doubt familiar with such arithmetic expressions from other languages, let's start with them.
Most of the arithmetic operators in Java are binary operators-they take two operands. The binary arithmetic operators in Java are split into two groups:
The multiplication, division, addition, and subtraction operators need little explanation. Each produces a value which is equivalent to the result of the corresponding mathematical operation performed on the same quantities. If you've read Chapter 9, you remember that there are some type conversion rules that are important here. You'll handle that issue in more detail in "Type Conversions" later in this chapter. For now, assume that operations on integers produce an integer result, while operations on floating point values produce floating point results.
See "Type Conversions," Chapter 12
The remainder operator deserves some special attention. (C and C++ programmers are familiar with the use of this operator with integer operands.) In general, the expression
x%y
yields the remainder after y has been divided into x. Consider the following examples:
Operation Remainder 10 % 3 1 15 % 4 3 49 % 7 0
Java extends the remainder operator a little, by defining its operation with floating point operands as well. The value it produces is still the "remainder after division," as in the following examples:
Operation Remainder 12%2.5 2.0 15.5%4 3.5
The technical formula for determining the value of x%y where at least one of x or y is of floating point type is as follows:
x - ( (int)(x/y) * y)
The int operator is an example of the cast operator. Its syntax is the same as in C and C++. You read about it in more detail later in this chapter.
In C, the % operator is commonly referred to as modulus and can only be applied to integral operands. The term "modulus" comes from the word "modulo," common in algebra and number theory; two integers are said to be "congruent modulo n" if their difference is a multiple of n.
There are two unary arithmetic operators in Java:
???Author: opposite of above? What the hell does that mean?--Lisa
The unary negation simply produces the arithmetic negation of its numeric operand. Thus an expression like -x simply produces the arithmetic negative of whatever the value is of x. The unary + operator was first introduced in ANSI C, and was introduced primarily for "symmetry" with the unary negation. It simply produces the value of its operand; in other words, it essentially does nothing!
At the beginning of this chapter, you learned that expressions are just combinations of operators and operands. And while that definition may be true, it's not always very helpful. Sometimes you need to create and use pretty complex expressions-maybe to perform some kind of complicated calculation or other long involved manipulation. You need deeper understanding of how Java expressions are created and evaluated. In this section, you look at three major tools that will help you in your work with Java expressions: operator associativity, operator precedence, and order of evaluation.
The easiest of the expression rules is associativity. All the arithmetic operators are said to associate left-to-right. This means that if the same operator appears more than once in an expression-as in a+b+c, for example-then the leftmost occurrence will be evaluated first, followed by the one to its right, and so on. Consider the following assignment statement:
x = a+b+c;
In this example, the value of the expression on the right of the = is calculated and assigned to the variable x on the left. In calculating the value on the right, the fact that the + operator associates left-to-right means that the value of a+b is calculated first, and the result is then be added to c. The result of that second calculation is what will be assigned to x.
Notice that in the previous example, a+b+c, the same operator appears twice. It's when the same operator appears more than once-as it does in this case-that you apply the associativity rule.
You would use the associativity rule in evaluating the right-hand sides of each of the following assignment statements:
volume = length * width * height ; OrderTotal = SubTotal + Freight + Taxes ; PerOrderPerUnit = Purchase / Orders / Units ;
When you have an expression that involves different operators, the associativity rule doesn't help much. The associativity rule helps figure out how combinations of the same operator would be evaluated. Now you need to know how expressions using combinations of different operators are evaluated.
Like most programming languages, and like basic arithmetic, Java operators conform to strict rules of precedence. The multiplicative operators (*, /, and %) have higher precedence than the additive operators (+ and -). In other words, in a compound expression that incorporates both multiplicative and additive operators, the multiplicative operators are evaluated first. Consider the following assignment statement, which is intended to convert a Fahrenheit temperature to Celsius:
Celsius = Fahrenheit - 32 * 5 / 9;
Because the * and / operators have higher precedence, the sub-expression 32*5/9 is evaluated first (yielding the result 17) and that value is subtracted from the Fahrenheit variable. Clearly, this isn't going to give you a correct conversion from Fahrenheit to Celsius.
Whenever you need to change the order of evaluation of operators in an expression, you can use brackets. Any expression within brackets is evaluated first. To perform the correct conversion above, you would write:
Celsius = ( Fahrenheit - 32 ) * 5 / 9;
Interestingly, there are some languages that do not use rules of precedence. Some languages, like APL for Example, use a straight left-to-right or right-to-left order of evaluation, regardless of the operators involved.
These precedence rules would help you with the following examples:
NewAmount = (Savings + Cash) * ExchangeRate ; TotalConsumption = (Distance1 + Distance2) * ConsumptionRate ;
The precedence of the unary arithmetic operators-in fact all unary operators-is very high; it's above all the other arithmetic operators. This means that in the following example, you multiply the value -5 times the value of Xantham:
Ryman = -5 * Xantham;
Many people, when they first learn a language, confuse the issue of operator precedence with order of evaluation. The two are actually quite different. The precedence rules help you determine which operators come first in an expression, and help you determine what the operands are of an operator. For example, in the following line of code, the operands of the * operator are a and (b+c):
d = a * (b+c) ;
The order of evaluation rules, on the other hand, help you to determine not when operators are evaluated, but when operands are evaluated. In some programming languages, like C and C++, the order of evaluation is not well-defined. But in Java, the order of evaluation of operands is always well-defined. Here are three rules that should help you remember how an expression will be evaluated:
In C and C++, there are a number of "loopholes" in the precedence rules: situations in which the order of evaluation of operands is not guaranteed. The three rules you just learned about make things much clearer in Java. There is nothing about the evaluation of Java expressions that is implementation specific: if an expression is evaluated one way on one Java system, it is evaluated identically in all Java systems.
As you know, Java is a typed language. In fact, Java can be called strongly typed, because it performs extensive type-checking (to help detect programmer errors) and imposes strict restrictions on when values can be converted from one type to another. There are really two different kinds of conversions. Explicit conversions occur when you deliberately change the data type of a value; ad hoc conversions can happen without your intervention, even without your knowledge.
Java performs a number of ad hoc type conversions when evaluating expressions, but the rules are simpler and more controlled than in the case of C or even C++.
For unary operators, the situation is very simple: operands of type byte or short are converted to int, and all other operands are left as-is.
For binary operators, the situation is only slightly more complex. For operations involving only integral operands, if either of the operands is long, then the other is also converted to long; otherwise, both operands are converted to int. The result of the expression is an int, unless the value produced is so large that a long is required. For operations involving at least one floating point operand, if either of the operands is double, then the other is also converted to double and the result of the expression is also a double; otherwise, both operands are converted to float, and the result of the expression is also a float. Consider the expressions in listing 12.1.
Listing 12.1 Some Mixed Expressions Showing Type Conversions short Width; long Length, Area; double TotalCost, CostPerFoot; // In the multiplication below, Width will be converted to a // long, and the result of the calculation will be a long. Area = Length * Width; // In the division below, Area will be converted to a double, // and the result of the calculation will be a double CostPerFoot = TotalCost / Area ;
The cast operator consists of a type name within round brackets. It is a unary operator with high precedence and comes before its operand. The cast operator produces the value of its operand, converted to the type named within the brackets. You saw an example of the cast operator in the previous section called "Remainder Operator." It was:
x - ( (int)(x/y) * y)
When x is divided by y in this example, the type of the result is either floating point or integer, depending on the types of x and y. Either way, the value of x/y is explicitly converted to type int by the cast operator.
Note that not all conversions are legal. Values of any arithmetic type can be cast to any other arithmetic type. Boolean values cannot be cast to any other type. Casting objects is a little more tricky, but the general rule is that an object of one class can be cast to a superclass but not to a subclass.
See "Declaring a Class," Chapter 10
Because casting involves an unconditional type conversion (if the conversion is legal), it is also sometimes known as type coercion.
In Java, strings are native data types, and the concatenation of strings is supported using the + operator. The behavior of the + operator with strings is just what you'd expect. In the following expression, the strings referenced by variables String1 and String2 will be concatenated:
String1 + String2
If a non-string value is added to a string, it is converted to a string before concatenation. This means, for example, that a numeric value can be added to a string. The numeric value is converted to an appropriate sequence of digit characters which are concatenated to the original string. All the following are legal string concatenations:
"George " + "Burns" "Burns" + " and " + "Allen" "Fahrenheit" + 451 "Answer is: " + true
Java incorporates a full slate of operators for comparing two or more quantities. There are really two different categories of these operators
Java supports the relational operators in the following list. Each takes numeric operands (integral or floating point) and produces a Boolean result.
Operator Boolean Result < Less than <= Less than or equal to > Greater than >= Greater than or equal to
The precedence of the relational operators is below that of the arithmetic operators, but above that of the assignment operator. Thus, the following two assignment statements produce identical results:
result1 = a+b < c*d ; result2 = (a+b) < (c*d) ;
The associativity is left-to-right, but this feature isn't really very useful. It may not be immediately obvious why, but consider the following expression:
a < b < c
The first expression, a<b, is evaluated first, and produces a value of true or false. This value then would have to be compared to c. Since a boolean cannot be used in a relational expression, the compiler will generate a syntax error.
In C and C++, the relational operators produce an integer value of 0 or 1, which can be used in any expression expecting an integer. Expressions like the following are legal in C or C++, and will generate compiler errors in Java:
RateArray [ day1 < day2 ] NewValue = OldValue + ( NewRate > OldRate ) * Interest;
The following equality operators are very similar to the relational operators, with slightly lower precedence:
Operator Boolean Result == Is equal to != Is not equal to
The equality operators can take operands of virtually any type. In the case of the primitive data types, the values of the operands are compared. However, if the operands are some other type of object, the operands must refer to exactly the same objects. Consider the following example:
String1 == String2
In this example, String1 and String2 must refer to the same string-not to two different strings that happen to contain the same sequence of characters, but to exactly the same string.
The associativity of these operators is again left-to-right. You've seen that the associativity of the relational operators is really not useful to you as a programmer. The associativity of the equality operators is only slightly more useful. Take a look at the following example:
StartTemp == EndTemp == LastRace
Here the variables StartTemp and EndTemp are compared first, and the boolean result of that comparison is compared to LastRace, which must be boolean. If LastRace is of some non-boolean type, the compiler will generate an error.
Writing code that depends on this kind of subtlety is considered to be extremely poor form. Even if you understand it completely when you write it, chances are you'll be as mystified as everyone else when you try to read it a few weeks or months later. Try to use constructs in your code that are easily read. If there is some reason that you must use an expression like the one just given, be sure to use comments to explain how the expression operates and, if possible, why you've chosen to implement your algorithm that way.
In computing, it is not uncommon to need to combine values using the logical operations of And, Or, and Exclusive Or. You are probably familiar with these operations from previous experience. When you are programming in Java, you have the ability to perform such logical operations in two different ways:
The bitwise operators in Java allow you to perform a logical operation on a pair of Boolean operands, or on each bit in a pair of integral operands. Such an operation is relatively rare, but might be necessary when you're having to manipulate the individual bits in a control word from a database record, or when manipulating hardware registers or performing other low-level programming. These operations also potentially enable you to pack data more densely when memory is at a premium, though the extra processing overhead and programming difficulty would rarely make this worthwhile.
Begin by making sure that you're comfortable with the idea of an integral value being made up of individual bits. (If this is old hat to you, feel free to skip a few paragraphs to the discussion of the operators).
For now, consider only integral values of type byte-for example, occupying one byte (eight bits) of memory. Each of the eight bits can have the value of 0 or 1. The value of the whole quantity is determined by using base 2 arithmetic, meaning that the rightmost bit means a value of 0 or 1; the next bit means a value of 0 or 2; the next means a value of 0 or 4, and so on. Table 12.2 shows a number of examples.Table 12.2 Some Base 10 Values and Their Base 2 Equivalents
Base 10 Value 128 64 32 16 8 4 2 1 17 0 0 0 0 1 0 0 0 1 63 0 0 0 1 1 1 1 1 1 131 0 1 0 0 0 0 0 1 1 75 0 0 1 0 0 1 0 1 1
The numeric quantities in table 12.2 are all positive integers, and I've done that on purpose. Negative numbers are a little more difficult to represent. In fact, for any integral quantity in Java, the leftmost bit is reserved for the sign-bit. If the sign-bit is 1, then the value is negative. The rest of the bits in a negative number are also determined a little differently than the way I've described, but don't worry about that now. Floating point numbers also have their own special binary representation, but that's beyond the scope of this book.
The three binary bitwise operators perform the logical operations of And, Or, and Exclusive Or (sometimes called Xor) on each bit in turn. The three operators are:
The operands of the bitwise operators can also be Boolean, in addition to being of any integral type. In the case of operands of integral type, the operation is performed on each bit in the operands in turn. In case you're a bit rusty on the rules for logical operations, table 12.3 summarizes them for you.Table 12.3 Summary of Logical Operations
bit1 bit2 bit1 & bit2 bit1 | bit2 bit1 ^ bit2 true true true true false true false false true true false true false true true false false false false false
Table 12.4 shows the results of each of these operations performed on two sample values.Table 12.4 Bitwise Operation Examples
Expression Binary Representation 11309 0010 1100 0010 1101 798 0000 0011 0001 1110 11309 & 798 0000 0000 0000 1100 11309 | 798 0010 1111 0011 1111 11309 ^ 798 0010 1111 0011 0011
The precedence of the bitwise logical operators is below that of the equality operators.
See "Bitwise Arithmetic Operators" Chapter 8
There are two additional binary logical operators:
These operators behave very much as the bitwise operators do, with two main exceptions. First, the logical operators may only take boolean operands. Second, the operands are evaluated left to-right; if the value of the expression is determined after evaluating the left-hand operand, the right-hand operand will not be evaluated. In the following example, if x is indeed less than y, then m and n are be compared:
(x<y) || (m>n)
If the left-hand side of the above expression produces the boolean value true, then the result of the whole expression is true, regardless of the result of the comparison m>n. Note that in the following expression using the bitwise operator, m and n are compared regardless of the values of x and y:
(x<y) | (m>n)
The precedence of the two logical operators is below that of the bitwise operators just discussed.
There are two unary logical operators:
For integral operands, this operator is the "bit flipper"-each bit in its operand is toggled. What was 0 becomes 1, what was 1 becomes 0.)
Both these operators have high precedence, equivalent to that of the other unary operators.
Take a look at the following example, which shows a combination of the logical negation and the short-turn logical &.
if (!dbase.EOF & dbase.RecordIsValid() )
Because the logical negation has high precedence, it is evaluated first. If EOF refers to End of File, you might check in the first operation to see if you hit end of file on this database. If you haven't, then the second operand is evaluated, which in this case is a method invocation that might determine the validity of the record. The key to understanding is that if the first operand is false-in other words you have hit end of file-then you don't check for a valid record.
There are three shift operators in Java:
These are binary operators, taking integral operands. The left-hand operand is the value to be shifted, while the right hand operand is the number of bits to shift by. The left shift and the unsigned right shift populate the vacated spaces with zeroes. The signed right shift populates the vacated spaces with the sign bit. The following examples are for 8-bit quantities of type byte, but the same principles would apply to larger quantities:
The precedence of the shift operators is above that of the relational operators, but below the additive arithmetic operators.
See "Bitwise Shifting Operators," Chapter 8
C and C++ programmers should note that while the right-shift of signed values in those languages is platform-specific behavior that will vary from system to system, all shifts in Java are well-defined.
The C and C++ languages attempt to be general enough to match the underlying hardware as closely as possible-regardless of what that hardware architecture might be. Programmers using those languages endure considerable complexity in the language as a result. The Java designers took a different approach. Java assumes an underlying hardware architecture that uses a 2's-complement representation for negative numbers, and that uses the IEEE 754 standard for floating point arithmetic. The result is that Java programmers only have to learn the behavior of one platform. There is virtually nothing in the Java language that is "platform-specific".
The conditional operator is the one ternary or triadic operator in Java, and operates as it does in C and C++. It takes the following form:
In this syntax, expression1 must produce a Boolean value. If this value is true, then expression2 is evaluated, and its result is the value of the conditional. If expression1 is false, then expression3 is evaluated, and its result is the value of the conditional.
Consider the following examples. The first is using the conditional operator to determine the maximum of two values; the second is determining the minimum of two values; the third is determining the absolute value of a quantity:
BestReturn = Stocks > Bonds ? Stocks : Bonds ; LowSales = JuneSales < JulySales ? JuneSales : JulySales ; Distance = Site1-Site2 > 0 ? Site1-Site2 : Site2 - Site1 ;
In reviewing these examples, think about the precedence rules, and convince yourself that none of the three examples requires any brackets in order to be evaluated correctly.
The increment and decrement operators are unary operators that add and subtract, respectively, the value 1 (or 1.0) from the operand:
The operand must be a variable, and may be of any numeric type. The operator may come before the operand (called the prefix case) or after the operand (called the postfix case). In the prefix case, the value of the expression is the value of the operand before incrementing. In the postfix case, the value of the expression is the value of the operand after incrementing. Table 12.5 illustrates the two cases.Table 12.5 Comparing the Prefix and Postfix Increment Operators
Prefix Case Postfix Case Length = 12.5; Length = 12.5; NewLength = ++Length; OldLength = Length++; Following these two Following these two statements, statements, Length has value 13.5 Length has value 13.5 NewLength has value 13.5 OldLength has value 12.5
The increment and decrement operators have high precedence equivalent to that of the other unary operators.
See "Increment/Decrement Operators" Chapter 8
Java has two different kinds of assignment operators: the simple assignment, and the compound assignment. All the assignment operators have low precedence.
The simple assignment is the operator you are probably already familiar with:
This binary operator takes the value of its right-hand operand and stores it in the left-hand operand. The left-hand operand must be a variable. The value of the right-hand operand is converted, if necessary, to the data type of the left-hand operand.
In C, almost any data type can be converted to almost any other across an assignment statement. In Java, conversions between numeric data types are only performed if they do not result in loss of precision or magnitude. Any attempted conversion that would result in such a loss produces a compiler error.
Like most other operators, the assignment operator also produces a result, that being the value of the left-hand operand after the assignment, which means that a statement like the following is legal, if extremely bad form:
a = (b=7) + 3;
This assigns the value 7 to b, and the value 10 to a.
The assignment operators associate right-to-left, so that the two assignments below are both legal and produce identical results:
a=b=c; a=(b=c);
In each case, the value of c is assigned to b, after which the value of b is assigned to a. Multiple assignments of this form are generally considered to be poor form.
The compound assignment operators have the following form:
The compound assignment operator behaves as follows, for a binary operator op:
expression1 op= expression2
is equivalent to
expression1 = expression1 op expression2
except that expression1 is only evaluated once. All the following are legal assignment statements in Java:
Location += DownShift ; NewValue -= Taxes ; Loan *= InterestRate ; Cost /= Units ; BitMask <<= 3 ;
The simple assignment operator takes operands of virtually any type; the value on the right is converted to the type of the variable on the left, with a compiler error if the conversion cannot be performed. The compound assignments, on the other hand, because they depend on the underlying binary operations, can only be used with operands of primitive type.
The binary instanceof operator takes two operands: an object on the left, and a class name on the right. If the object on the left is indeed an instance of the class on the right (or any of its subclasses), then this operator returns a Boolean value of true. Otherwise, it returns false. The use of instanceof in the following example prevents an exception being thrown at runtime in the initialization of my_car:
if ( your_car instanceof MotorVehicle )
MotorVehicle my_car =(MotorVehicle) your_car;
Here are the last three Java operators:
These three operators have very high precedence-the highest in the Java language.
Because Java is an evolutionary outgrowth of C and C++, it's understandable that the expression syntax for the three languages is so similar. If you already know C, it's important that you keep in mind that the three languages are only similar-not identical.
The most important difference, without question, is that order of evaluation is guaranteed in Java, and is generally undefined or implementation specific in C:
See "Order of Evaluation," Chapter 12
In Java, the remainder, increment, and decrement operators are defined for all numeric data types; in C only for integers.
Relational and equality operators in Java produce a boolean result; in C they produce results of type int. Furthermore, the logical operators in Java are restricted to boolean operands.
Java supports native operations on strings-including string concatenation and string assignment. C does not support strings.
In C, using the right-shift operator on a signed quantity results in implementation-specific behavior. Java, by using two different right-shift operators-one which pads with zeroes and the other that does sign-extension-avoids this confusion.
You've now learned about all the Java operators-the building blocks of Java expressions. Here is the final precedence table (see table 12.6)with the highest precedence operators at the top. Operators on the same line are of equal precedence. All these operators associate left-to-right, except the unary operators, assignments, and the conditional. For any single operator, operand evaluation is strictly left-to-right, and all operands are evaluated before operations are performed.Table 12.6 The Complete Java Operator Table
Description Operators High Precedence . [] () Unary + - ~ ! ++ -- instanceof Multiplicative * / % Additive + - Relational < <= >= > > Equality == != Bitwise And & Bitwise Xor ^ Bitwise Or | Short-turn And && Short-turn Or || Conditional ?: Assignment = op=
For technical support for our books and software contact support@mcp.com
Copyright ©1996, Que Corporation