The literals (the integers) and the operators are out of order in the above incorrect expression. (One legal arrangement is    13 * -6     for 13 times minus 6.)

Expressions contain operators and operands. You already know what an operator is (a symbol such as +, -, *, or / that calls for an arithmetic operation).

The parts of an expression must be arranged correctly. The syntax of Java describes the correct arrangements. The rules for correct Java expressions are nearly the same as for algebra:

1. Each operator must have the correct number of operands.

   • Multiplication *, Division /, Addition +, Subtraction - should have two operands, one on each side.
   • Negation - and unary plus + should be followed by one operand.
2. Parentheses () can surround a legal expression to make it an operand.

In 13 - 5 the 13 and the 5 are the operands and the - is the operator.

In Java expressions, operators and operands must be explicit. In

14 and sum are the operands. The star for multiplication must be present. The expression 14sum is incorrect.

In a correct expression, parentheses are balanced. Parentheses are balanced when they form matching pairs. Each left parenthesis has a matching right parenthesis. Balanced pairs of parentheses can be nested within other balanced pairs.

For example, the following are balanced:

• ( )
• ( ( ) ( ) )
• ( ( ) ) ( )
• ( ) ( ( )( ) ) ( )

The following are NOT balanced:

• (
• ( ( ( ) )
• ( ( ) ) ( ))
• ( ) ( )( ) ) ( )

The details of expression syntax are in the Java documentation, should you care to dig through it. The best way to learn these rules is to study some examples.

Examine the following expressions. Assume that each variable has already been correctly declared. Decide if the expression is correct, then click on the button.

Arithmetic expressions are especially important. Java has many operators for arithmetic. These operators can be used on floating point numbers and on integer numbers. (However, the % operator is rarely used on floating point.)

For instance, / means integer division if both operands are integers, and means floating point division if one or both operands are floating point.

For example, with 16 bit short variables, the arithmetic is done using 32 bits:

The expression   x / 3   divides a 32-bit value 12 by a 32-bit value 3 and puts the 32-bit answer in result. The literal 3 automatically represents a 32-bit value.

Here is another example:

C:\Private>javac ShortStuff.java
ShortStuff.java:9: possible loss of precision
found   : int
required: short
    result = x / y;
               ^
1 error
C:\Private>

For professional programmers, details like these are sometimes important. But for most programs, use int or long for integers and double for floating point. This will keep you out of trouble (usually). If you can't avoid the problem, use a type cast, as described in a future chapter.

Integer division is easy enough to see when it is by itself, but here is a more confusing case of the same thing:

The division is done first because / has higher precedence than +. The result of the division, 3, is an integer. Now the floating point 1.5 is added to integer 3 to get floating point 4.5.

Integer arithmetic might be used in some parts of an expression and not in others, even though the final value of the expression is floating point.

This can be very confusing. The temptation is to see a floating point value in an expression and then mistakenly do floating point with every operation. For example,

This evaluates to 5.7. Here is what happens, step-by-step:

Most of the operators we are interested in take two operands. In each of the following examples the operator has two operands:

However, unary operators take just one operand:

A binary operator will always have exactly two operands. However, sometimes one or both operands of a binary operator is a subexpression.

Sometimes a subexpression is a constant, like "8". Any expression can be a subexpression of a larger expression. In the following, both operands of the red operator are subexpressions.

When an expression is evaluated, the subexpressions must be evaluated first before the operator that joins them can be applied.

Gotcha: a subexpression may call for integer arithmetic, even though the larger expression calls for floating point. (I keep stressing this, but that is because people get caught by this all the time.)

The rule has to be applied step-by-step. Consider this expression:

What is the result? Apply the rules: innermost parentheses first. Within the parentheses the highest precedence operator first:

Since both operands are integer, the operation is integer division, resulting in:

Now continue to evaluate the expression inside parentheses. The + operator is floating point because one of its operands is, so the parentheses evaluates to 3.5:

Finally do the last operation:

This is close to the result that you might have mistakenly expected if you thought both divisions were floating point. An insidious bug might be lurking in your program!

You may recall how in grade school you did division like this:

13 / 5 == 2 with a remainder of 3.

This is because 13 == 2*5 + 3.

The symbol for finding the remainder is % (percent sign). If you look in the operators, table of table of operators you will see that it has the same precedence as / and *. Here is a program:

public class RemainderExample
{
  public static void main ( String[] args )
  {
    int quotient, remainder;
    quotient  =  17 / 3;
    remainder =  17 % 3;
    
    System.out.println("The quotient : " + quotient );
    System.out.println("The remainder: " + remainder );
    System.out.println("The original : " + (quotient*3 + remainder) );
  }
}

Question 14:
Will the following always print out the original integer, regardless of what it was?
System.out.println("The original : " + (quotient*3 + remainder) ); 

The integer division operator / and the remainder operator % take an integer apart.

The original integer can be put back together again:

In many calculations, it is convenient to do everything with integers, so both / and % are needed.

Question 15:
If you exchange 372 pennies for dollar bills, how many bills do you get? How many pennies are left over?       

For positive integers, INT % X means to fit as many X as you can into INT, and then the left over amount is the value of the expression. Try that with the following:

Question 16:
If X is odd, what is X % 2?      

Often in a program you want to give a name to a constant value. For example you might have a tax rate of 0.045 for durable goods and a tax rate of 0.038 for non-durable goods. These are constants, because their value is not going to change during a run of the program. It is convenient to give these constants a name. This can be done:

You have finally reached the end of the chapter. Click on a subject that interests you to go to where it was discussed.

• operators, table of Table of operators and their precedence.
• operand What an operand is.
• subexpression What a subexpression is.
• floating point contagion Rule for whether an operator is floating point or integer.
• integer division Integer division.
• remainder operator The remainder operator.
• final The final reserved word.