# 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.

OperatorDescription
`+`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) {

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

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

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

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

result = result + 8;
// result is now 10
System.out.println(original_result + " + 8 = " + result);
original_result = result;

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

This program prints the following:

``````1 + 2 = 3
3 - 1 = 2
2 * 2 = 4
4 / 2 = 2
2 + 8 = 10
10 % 7 = 3
``````

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.

OperatorDescription
`+`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) {

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

result--;
// result is now 0
System.out.println(result);

result++;
// result is now 1
System.out.println(result);

result = -result;
// result is now -1
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);
}
}
``````