Trail: Learning the Java Language
Lesson: Language Basics
Section: Operators

# Assignment, Arithmetic, and Unary Operators

## The Simple Assignment Operator

One of the most common operators that you'll encounter is the simple assignment operator "`=`". You saw this operator in the Bicycle class; it assigns the value on its right to the operand on its left:

``` int cadence = 0;
int speed = 0;
int gear = 1;
```

This operator can also be used on objects to assign object references, as discussed in Creating Objects.

## The Arithmetic Operators

The Java programming language provides operators that perform addition, subtraction, multiplication, and division. There's a good chance you'll recognize them by their counterparts in basic mathematics. The only symbol that might look new to you is "`%`", which divides one operand by another and returns the remainder as its result.

```+       additive operator (also used for
String concatenation)
-       subtraction operator
*       multiplication operator
/       division operator
%       remainder operator
```

The following program, `ArithmeticDemo`, tests the arithmetic operators.

```
class ArithmeticDemo {

public static void main (String[] args){

// result is now 3
int result = 1 + 2;
System.out.println(result);

// result is now 2
result = result - 1;
System.out.println(result);

// result is now 4
result = result * 2;
System.out.println(result);

// result is now 2
result = result / 2;
System.out.println(result);

// result is now 10
result = result + 8;
// result is now 3
result = result % 7;
System.out.println(result);
}
}
```

You can also combine the arithmetic operators with the simple assignment operator to create compound assignments. For example, `x+=1;` and `x=x+1;` both increment the value of `x` by 1.

The `+` operator can also be used for concatenating (joining) two strings together, as shown in the following `ConcatDemo` program:

```
class ConcatDemo {
public static void main(String[] args){
String firstString = "This is";
String secondString =
" a concatenated string.";
String thirdString =
firstString+secondString;
System.out.println(thirdString);
}
}
```

By the end of this program, the variable `thirdString` contains "This is a concatenated string.", which gets printed to standard output.

## The Unary Operators

The unary operators require only one operand; they perform various operations such as incrementing/decrementing a value by one, negating an expression, or inverting the value of a boolean.

```+       Unary plus operator; indicates
positive value (numbers are
positive without this, however)
-       Unary minus operator; negates
an expression
++      Increment operator; increments
a value by 1
--      Decrement operator; decrements
a value by 1
!       Logical complement operator;
inverts the value of a boolean
```

The following program, `UnaryDemo`, tests the unary operators:

```
class UnaryDemo {

public static void main(String[] args){
// result is now 1
int result = +1;
System.out.println(result);
// result is now 0
result--;
System.out.println(result);
// result is now 1
result++;
System.out.println(result);
// result is now -1
result = -result;
System.out.println(result);
boolean success = false;
// false
System.out.println(success);
// true
System.out.println(!success);
}
}
```

The increment/decrement operators can be applied before (prefix) or after (postfix) the operand. The code `result++;` and `++result;` will both end in `result` being incremented by one. The only difference is that the prefix version (`++result`) evaluates to the incremented value, whereas the postfix version (`result++`) evaluates to the original value. If you are just performing a simple increment/decrement, it doesn't really matter which version you choose. But if you use this operator in part of a larger expression, the one that you choose may make a significant difference.

The following program, `PrePostDemo`, illustrates the prefix/postfix unary increment operator:

```
class PrePostDemo {
public static void main(String[] args){
int i = 3;
i++;
// prints 4
System.out.println(i);
++i;
// prints 5
System.out.println(i);
// prints 6
System.out.println(++i);
// prints 6
System.out.println(i++);
// prints 7
System.out.println(i);
}
}
```

Problems with the examples? Try Compiling and Running the Examples: FAQs.
Complaints? Compliments? Suggestions? Give us your feedback.

Previous page: Operators
Next page: Equality, Relational, and Conditional Operators

Spec-Zone.ru - all specs in one place