Expressions

Goals

Understand and work with expressions.

Concepts

conditional operator
equality
exclusive OR (XOR)
expression
identity
inclusive OR
operator
post-increment
pre-increment
short-circuiting
truth table

Lesson

An expression represents the result of some comparison or mathematical operation, such as adding two things (e.g. x + 2) or seeing if one number or variable is greater than another (e.g. x > y). Expressions can be made up of variables, literals, and/or symbols called operators. The result of an expression is a value of some type—normally the type of the values in the expression, but not always. Here are some examples of expressions:

5
x
x + 5
y = x + 5
true
3 == 4

Interestingly the assignment operator itself yields a value. It is actually valid to assign one variable with the result of another assignment, as in x = (y = 5), in which case x will be assigned the result of y = 5, which in this case is 5. This can get confusing. Most of the time you won't want to use an assignment in a situation where something else depends on the result of the assignment expression, with the exception being Java's “try-with-resources”, an advanced concept you'll learn in a future lesson.

Mathematical Operators

In your expressions most of the operators you'll use are those you are already familiar with in arithmetic, including +, -, *, and /. These operators for the most part have the precedence you are used to (e.g. multiplication takes precedence over addition), and you can override precedence by using parentheses ( and ). See the References section if you have a doubt. Of special note is the % operator, which is the remainder or modulus operator of division. You can also compare numbers using <, <=, ==, !=, >=, and >.

int sum = 1 + 80 + 92;  //173
int result = (2 + 70) / (3 * 6); //note operator precedence
double third = (double)result / 3; //note conversion

Java doesn't perform conversions between integer and floating point types until it is told to. This can lead to some odd results. The expression 4 / 3, without any casts, will yield 1. That's because both 4 and 3 are integers, so Java provides the result as an integer: four divided by three is one, with some remainder, which Java throws away in order to provide you with an integer. If you expect a non-integer result, make sure one of the components of the expression is a floating point number. You could use one or two floating point literals as in 4.0/3.0; or you could cast one or both of the values to floating point as in (double)4/3, or 4/(double)3. Casting the end result to a floating point, as in (double)(4/3) or double var=4/3 won't help, though, as the value has already been converted to an integer at this point and the remainder lost.

Equality Operators

You've already seen that Java uses = to indicate a variable assignment. Two equals signs together make up an expression to determine if two primitive values are identical, such as 4 + 5 == 9. The result of this expression is the boolean value true.

Unless you are comparing integral values such as 123.0, do not compare floating point numbers using the equality == operator. Because there are many floating point numbers that IEEE 754 floating point numbers cannot represent exactly, the number being compared might not be exactly what you think you are comparing. The correct way to compare floating point numbers involves subtracting them and checking that the difference is smaller than a certain limit, something you will learn more about in a future lesson.

Logical Operators

When part or all of an expression evaluates to a boolean type, you can use && (logical AND), || (logical OR), and ! (logical NOT). The operator && takes precedence over ||, but in your own code use parentheses to keep from confusing others.

int result = (2 + 70) / (3 * 6); //note operator precedence
boolean isFour = result == 4;
boolean isFive = result == 5;
boolean isSmall = result < 10;
boolean isSmallButNotSix = isSmall && result != 6;
boolean isSmallButNotFive = isSmall && !isFive;

You may notice that there are certain rules that the logical operators always follow used in expressions. For example, for expressions involving || if either side is true then the outcome will be true. In an expression involving && both sides of the expression must evaluate to true or the the result will be false.

There is yet another logical operator called the exclusive OR (XOR), represented by the caret ^ symbol. While the inclusive OR will produce a value of true if either side or both sides of the expression are true, the exclusive OR operator will only produce true if one side but not both sides is true. The ^ (XOR) logical operator is seldom needed when comparing boolean values.

The rules of Boolean expressions allow us to create a truth table containing all possible outcomes involving each logical operator.

Logical Truth Table
Input Values		AND	OR	XOR	NOT
`boolean foo`	`boolean bar`	`foo && bar`	`foo \|\| bar`	`foo ^ bar`	`!foo`
`false`	`false`	`false`	`false`	`false`	`true`
`false`	`true`	`false`	`true`	`true`	`true`
`true`	`false`	`false`	`true`	`true`	`false`
`true`	`true`	`true`	`true`	`false`	`false`

The conditional operators && (AND), || (inclusive OR) are short-circuiting. This means that if Java evaluates part of the expression and knows what the answer must logically be, it will not evaluate the other part of the expression. For example in the expression (isTall || isHeavy), if isTall happens to be true there is no need for Java to look at isHeavy, because with the || expression the statement evaluates to true if either part s true. That is, if isTall is true, the value of isHeavy is irrelevant, so Java doesn't even look at it. This behavior may seem unimportant now, but will be significant if part of the short-circuited expression is a method that never gets called.

Assignment

You've already used the assignment operator =, but there are some other operators that do assignment and a little bit more. These were inherited from C/C++, and while cool if you're trying to be clever, most of the time you should not be clever but smart. Don't overuse these. One exception is within loops, where it's expected to see an increment operator (i++). Here are some examples of assignment operators. See the References section for a complete list.

Example	Same As
`a += b`	`a = a + b`
`i++`	`i = i + 1`

The increment operator has one other subtlety: both i++ and ++i are will add one to the variable i. But when used in an expression ++i (the pre-increment operator) will return the value of i after it has been incremented, while i++ (the post-increment operator) will return the value of i before it was incremented.

int i = 5;
int before = i++;  //i==6, before==5
int after = ++i;  //i==7, after=7

Used properly, the i++ and ++i operators can be used to produce some witty, compact code. But in the real world you are not paid to be witty or to make your code compact. You are paid to make your code work, and playing tricks like this is error prone and makes the code hard to read, not to mention hard to maintain. Avoid relying on the distinction between pre-increment and post-increment operators unless the meaning is obvious.

Ternary Operator

One last operator is especially cool, acting like a test. The expression (a ? b : c) (parentheses added for clarity) means: “If a is true, then yield the value b; otherwise, yield the value c.”

int admissionPrice = attendeeNumber <= 50 ? 10 : 20;

The admission price for the first 50 attendees will be $10, but for the rest the price will be $20.

Example of a ternary operator being used for determining the admission to a show based upon the order of attendees.

Here are some more examples

int a = 5;
System.out.println(a * 3 == 15 ? "foo" : "bar"); //prints "foo"
System.out.println(a < 3 ? "foo" : "bar"); //prints "bar"

Review

Summary

Operator Precedence
Operators	Precedence
additive	`+ -`
assignment	`= += -= *= /= %= &= ^= <<= >>= >>>=`
bitwise exclusive OR	`^`
equality	`== !=`
logical AND	`&&`
logical OR	`\|\|`
multiplicative	`* / %`
postfix	`expr++ expr--`
relational	`< > <= >= instanceof`
shift	`<< >> >>>`
ternary	`? :`
unary	`++expr --expr +expr -expr ~ !`

Gotchas

Be careful not to use = (assignment) when you mean == (equals). This trips up the best programmers! Thankfully the compiler will warn you if you use = in an expression that is expected to yield a value. This is another reason to use final whenever possible.

In the Real World

When you create a complex expression, don't rely on order-of-precedence—use parentheses to remove all doubt and help your fellow developers understand the code.
The ternary operator is neat and useful. Just don't overuse it, and please don't nest them unless you can make it completely clear what you're doing. The compiler will understand, but your teammates may not.

Think About It

Is this expression so long that it needs to be split out into an extra variable so it can be understood more easily?

Self Evaluation

What is the difference between a variable and an operator?
What is the difference between = and ==?
What is the type of the value produced by the expression 5 == 3?
What does it mean for an expression to "short-circuit"? Provide an example.
How would you negate a Boolean expression?
Explain how the ternary operator works.
What is the difference between ++i and i++?

Task

Create a program that makes the following determinations using expressions:

Create a variable that holds the result of an assignment of another variable.
What is the floating point value of (5 + 2) / 3?
What is the floating point value of 0.1 + 0.2?
If 17 people are in a room and 5 of them leave, what percentage of the original group is still in the room?
Create a boolean variable holding the result of an expression evaluating whether Pluto is farther from the sun than Earth is from the sun.
After calculating the the slope of a line with a rise of 456 and a run of 789, print either "steep" or "gradual", based upon whether the slope you calculated is greater than 1, using the ternary operator.

Create a compressed archive of your entire project directory and send it to your teacher as you have in previous lessons.

References

Acknowledgments

Operator precedence table modified from the table in The Java™ Tutorials (Oracle).

Expressions

Goals

Concepts

Lesson

Mathematical Operators

Equality Operators

Logical Operators

Assignment

Ternary Operator

Review

Summary

Gotchas

In the Real World

Think About It

Self Evaluation

Task

See Also

References

Acknowledgments