The JavaTM Tutorial

| Start of Tutorial > Start of Trail > Start of Lesson | Search Feedback Form

Trail: Learning the Java Language
Lesson: Language Basics

## Summary of Operators

> This section offers summaries of the operators in the Java progamming language. This section has these subsections:
> - Summary of Arithmetic Operators
> - Summary of Relational and Conditional Operators
> - Summary of Shift and Logical Operators
> - Summary of Assignment Operators
> - Summary of Other Operators
> - Summary of Operator Precedence

### Summary of Arithmetic Operators

> The following table lists the basic arithmetic operators provided by the Java programming language. Except for `+`, which is also used to concatenate strings, these operators can be used only on numeric values.

> Operator | Use | Description
> `+` | `op1 + op2` | Adds `op1` and `op2`
> `-` | `op1 - op2` | Subtracts `op2` from `op1`
> `*` | `op1 * op2` | Multiplies `op1` by `op2`
> `/` | `op1 / op2` | Divides `op1` by `op2`
> `%` | `op1 % op2` | Computes the remainder of dividing `op1` by `op2`

> These short cut operators increment or decrement a number by one.

> Operator | Use | Description
> `++` | `op++` | Increments `op` by 1; evaluates to the value of op before it was incremented
> `++` | `++op` | Increments `op` by 1; evaluates to the value of op after it was incremented
> `--` | `op--` | Decrements `op` by 1; evaluates to the value of op before it was decremented
> `--` | `--op` | Decrements `op` by 1; evaluates to the value of op after it was decremented

> Here are the Java programming language's other arithmetic operators.

> Operator | Use | Description
> `+` | `+op` | Promotes `op` to `int` if it's a `byte`, `short`, or `char`
> `-` | `-op` | Arithmetically negates `op`

### Summary of Relational and Conditional Operators

> Use these relational operators to determine the relationship between two values.

> Operator | Use | Returns `true` if
> `>` | `op1 > op2` | `op1` is greater than `op2`
> `>=` | `op1 >= op2` | `op1` is greater than or equal to `op2`
> `<` | `op1 < op2` | `op1` is less than `op2`
> `<=` | `op1 <= op2` | `op1` is less than or equal to `op2`
> `==` | `op1 == op2` | `op1` and `op2` are equal
> `!=` | `op1 != op2` | `op1` and `op2` are not equal

> You can use the following conditional operators to form multi-part decisions.

> Operator | Use | Returns `true` if
> `&&` | `op1 && op2` | `op1` and `op2` are both `true`, conditionally evaluates `op2`
> `||` | `op1 || op2` | either `op1` or `op2` is `true`, conditionally evaluates `op2`
> `!` | `! op` | `op` is `false`
> `&` | `op1 & op2` | `op1` and `op2` are both `true`, always evaluates `op1` and `op2`
> `|` | `op1 | op2` | either `op1` or `op2` is `true`, always evaluates `op1` and `op2`
> `^` | `op1 ^ op2` | if op1 and op2 are different--that is if one or the other of the operands is true but not both

### Summary of Shift and Logical Operators

> Each shift operator shifts the bits of the left-hand operand over by the number of positions indicated by the right-hand operand. The shift occurs in the direction indicated by the operator itself.

> Operator | Use | Operation
> `>>` | `op1 >> op2` | shift bits of `op1` right by distance `op2`
> `<<` | `op1 << op2` | shift bits of `op1` left by distance `op2`
> `>>>` | `op1 >>> op2` | shift bits of `op1` right by distance `op2` (unsigned)

> These operators perform logical functions on their operands.

> Operator | Use | Operation
> `&` | `op1 & op2` | bitwise `and`
> `|` | `op1 | op2` | bitwise `or`
> `^` | `op1 ^ op2` | bitwise `xor`
> `~` | `~op2` | bitwise complement

### Summary of Assignment Operators

> The basic assignment operator looks as follows and assigns the value of `op2` to `op1`.

> >     op1 = op2;

> In addition to the basic assignment operation, the Java programming language defines these short cut assigment operators that perform an operation and an assignment using one operator.

> Operator | Use | Equivalent to
> `+=` | `op1 += op2` | `op1 = op1 + op2`
> `-=` | `op1 -= op2` | `op1 = op1 - op2`
> `*=` | `op1 *= op2` | `op1 = op1 * op2`
> `/=` | `op1 /= op2` | `op1 = op1 / op2`
> `%=` | `op1 %= op2` | `op1 = op1 % op2`
> `&=` | `op1 &= op2` | `op1 = op1 & op2`
> `|=` | `op1 |= op2` | `op1 = op1 | op2`
> `^=` | `op1 ^= op2` | `op1 = op1 ^ op2`
> `<<=` | `op1 <<= op2` | `op1 = op1 << op2`
> `>>=` | `op1 >>= op2` | `op1 = op1 >> op2`
> `>>>=` | `op1 >>>= op2` | `op1 = op1 >>> op2`

### Summary of Other Operators

> The Java programming language also supports these operators.

> Operator | Use | Description
> --- | --- | ---
> `?:` | `op1 ? op2 : op3` | If `op1` is true, returns `op2`. Otherwise, returns `op3`.
> `[]` | `type []` | Declares an array of unknown length, which contains type elements.
> `[]` | `type[ op2 ]` | Creates and array with `op1` elements. Must be used with the `new` operator.
> `[]` | `op1[ op2 ]` | Accesses the element at `op2` index within the array `op1`. Indices begin at 0 and extend through the length of the array minus one.
> `.` | `op1.op2` | Is a reference to the `op2` member of `op1`.
> `()` | `op1(params)` | Declares or calls the method named `op1` with the specified parameters. The list of parameters can be an empty list. The list is comma-separated.
> `(type)` | `(type) op1` | Casts (converts) op1 to `type`. An exception will be thrown if the type of `op1` is incompatible with `type`.
> `new` | `new op1` | Creates a new object or array. `op1` is either a call to a constructor, or an array specification.
> `instanceof` | `op1 instanceof op2` | Returns true if `op1` is an instance of `op2`

### Summary of Operator Precedence

> The following table shows the precedence assigned to Java's 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 | `= += -= *= /= %= &= ^= |= <<= >>= >>>=`

| Start of Tutorial > Start of Trail > Start of Lesson | Search Feedback Form