Expressions, statements, and blocks
Abstract
Contents of the lecture.
- Expressions.
- Statements.
- Blocks.
Expressions
Expressions perform the work of a program. Among other things, expressions are used
to compute and to assign values to variables and to help control the execution flow of a
program. The job of an expression is twofold: to perform the computation indicated by the
elements of the expression and to return a value that is the result of the computation.
Definition 1. An expression is a series of variables, operators, and method calls (constructed
according to the syntax of the language) that evaluates to a single value.
Examples of expressions
Operators return a value, so the use of an operator is an expression. This partial listing
of the MaxVariablesDemo program shows some of the program's expressions in bold:
...
// other primitive types
char aChar = 'S';
boolean aBoolean = true;
// display them all
System.out.println("The largest byte value is " +
largestByte); ...
if (Character.isUpperCase(aChar)) {
...
}
Each of these expressions performs an operation and returns a value.
| Expression |
Action |
Value returned |
| aChar = 'S' |
Assigns the character 'S' to the character variable aChar |
The value of aChar after the assignment ('S') |
| "The largest byte value is " + largestByte |
Concatenate the string "The largest byte value is " and the value of largestByte converted to a string |
The resulting string: The largest byte value is 127 |
| Character.isUpperCase(aChar) |
Call the method isUpperCase |
The return value of the method: true |
The data type of the value returned by an expression depends on the elements used in
the expression. The expression aChar = 'S' returns a character because the assignment
operator returns a value of the same data type as its operands and aChar and 'S' are
characters. As you see from the other expressions, an expression can return a boolean value,
a string, and so on.
The Java programming language allows you to construct compound expressions and
statements from various smaller expressions as long as the data types required by one part
of the expression matches the data types of the other. Here's an example of a compound
expression:
x * y * z
In this particular example, the order in which the expression is evaluated is unimportant
because the results of multiplication is independent of order -- the outcome is always the
same no matter what order you apply the multiplications. However, this is not true of all
expressions.
For example, the following expression gives different results depending on
whether you perform the addition or the division operation first:
x + y / 100
//ambiguous
You can specify exactly how you want an expression to be evaluated by using balanced
parentheses ( and ). For example to make the previous expression unambiguous, you could
write:
(x + y)/ 100
//unambiguous, recommended
If you don't explicitly indicate the order in which you want the operations in a compound
expression to be performed, the order is determined by the precedence assigned to the
operators in use within the expression. Operators with a higher precedence get evaluated first.
For example, the division operator has a higher precedence than does the addition operator.
Thus, the two following statements are equivalent:
x + y / 100
x + (y / 100) //unambiguous, recommended
When writing compound expressions, you should be explicit and indicate with
parentheses which operators should be evaluated first. This will make your code easier to
read and to maintain.
The following table shows the precedence assigned to the operators. The operators
in this table are listed in precedence order: the higher in the table an operator appears, the
higher its precedence. Operators with higher precedence are evaluated before operators with
a relatively lower precedence. Operators on the same line have equal precedence.
| postfix operators |
[] . (params) expr++ expr-- |
| unary operators |
++expr --expr +expr -expr ~ ! |
| creation or cast |
new (type) expr |
| multiplicative |
* / % |
| additive |
+ - |
| shift |
<< >> >>> |
| relational |
< > <= >= instanceof |
| equality |
== != |
| bitwise AND |
& |
| bitwise exclusive OR |
^ |
| bitwise inclusive OR |
| |
| logical AND |
&& |
| logical OR |
|| |
| conditional |
? : |
| assignment |
= += -= *= /= %= &= ^= |= <<= >>= >>>= |
When operators of equal precedence appear in the same expression, a rule must govern
which is evaluated first. All binary operators except for the assignment operators are valuated
in left-to-right order. Assignment operators are evaluated right to left.
Statements
Statements are roughly equivalent to sentences in natural languages. A statement forms
a complete unit of execution. The following types of expressions can be made into a statement
by terminating the expression with a semicolon ( ; ) :
- Assignment expressions,
for example
aValue = 8933.234;
- Any use of ++ or --,
for example
aValue++;
- Method calls,
for example
System.out.println(aValue);
- Object creation expressions,
for example
Integer integerObject = new Integer(4);
In addition to these kinds of expression statements, there are two other kinds of
statements. A declaration statement declares a variable. You've seen many examples of
declaration statements, for example
double aValue = 8933.234;
A control flow statement regulates the order in which statements get executed. The for
loop and the if statement are both examples of control flow statements.
Blocks
A block is a group of zero or more statements between balanced braces and can be
used anywhere a single statement is allowed. The following listing shows two blocks from the
MaxVariablesDemo program, each containing a single statement:
| Code: |
if (Character.isUpperCase(aChar)) {
System.out.println("The character " + aChar + " is upper case.");
} else {
System.out.println("The character " + aChar + " is lower case.");
}
|
Summary
An expression is a series of variables, operators, and method calls (constructed
according to the syntax of the language) that evaluates to a single value. You can write
compound expressions by combining expressions as long as the types required by all of
the operators involved in the compound expression are correct. When writing compound
expressions, you should be explicit and indicate with parentheses which operators should
be evaluated first.
If you choose not to use parentheses, then the Java platform evaluates the compound
expression in the order dictated by operator precedence. A statement forms a complete unit
of execution and is terminated with a semicolon ( ; ). There are three kinds of statements:
expression statements,
declaration statements,
and control flow statements.
You can group
zero or more statements together into a block with curly brackets ( { and } ). Even though not
required, we recommend using blocks with control flow statements even if there's only one
statement in the block.
by Anatoliy Malyarenko
9250 bytes more | comments? |   | Score: 0
|
Previous
1060 Stories (530 Pages, 2 Per Page)
Next
RSS feed Java Forums
