=). This operator assigns the value of the evaluated expression on the right side of the operator to the variable on the left side. As we’ve seen, we can perform a variable assignment alone and during variable declaration as an initializer. The right side of an assignment need not be a constant value. For instance:int age; // Declare a variable
age = 19; // Assign a value to a variable
int height = 6; // Declare and initialize a variable
double hypotenuse = Math.sqrt( Math.pow(3,2) + Math.pow(4,2) );
+= infix binary operator performs addition followed by assignment. The value of the right operand is added to the variable given as the left operand and then reassigned to the variable on the left. Similarly, the *= infix binary operator performs multiplication followed by assignment in a similar manner. Following are descriptions of several of Java’s common compound assignment operators including increment (+1), and decrement (-1) operators.| Operator | Type | Description |
|---|---|---|
++ |
unary, prefix or postfix | increment by 1 |
-- |
unary, prefix or postfix | decrement by 1 |
+= |
binary, infix | increment the left operand by the right operand and reassign |
-= |
binary, infix | decrement the left operand by the right operand and reassign |
*= |
binary, infix | multiply the left operand by the right operand and reassign |
/= |
binary, infix | divide the left operand by the right operand and reassign |
%= |
binary, infix | compute modulus the left operand using the right operand and reassign |
x++; // Equivalent to x = x + 1
++x; // Equivalent to x = x + 1
x--; // Equivalent to x = x - 1
--x; // Equivalent to x = x - 1
x += y; // Equivalent to x = x + y
x -= y; // Equivalent to x = x - y
x *= y; // Equivalent to x = x * y
x /= y; // Equivalent to x = x / y
x %= y; // Equivalent to x = x % y
++) and the decrement operator (--). Both of these operators may be used in prefix and postfix form. The ++ increment operator simultaneously adds a value of 1 to the existing value of a variable and reassigns the variable to the incremented value. The -- decrement operator subtracts a value of 1 from the existing variable value and reassigns it. So, why are there both prefix and postfix versions?a is declared and initialized to a value of 5. After the prefix ++ operator is executed on a, the value changes to 6. Following this the prefix -- operator is applied, and the value is decrements a back to 5. Nothing unusual here. Repeat this example yourself by declaring and initializing new variables, and incrementing and/or decrementing them using the prefix ++ and -- operators.jshell> int a = 5; a ==> 5 jshell> ++a $2 ==> 6 jshell> --a $3 ==> 5 jshell>
++ increment operator always increments the variable by 1 and always reassigns the result to the variable. Likewise, the -- decrement operator always decrements by 1 and always reassigns the result to the variable.jshell> int a = 5; a ==> 5 jshell> a++ // Let's increment by 1 using the postfix operator. $2 ==> 5 // The new value appears to remain 5! jshell> a // Let's check that. a ==> 6 // Now it is 6. What gives? jshell> a-- // Let's decrement by 1 using the postfix operator. $4 ==> 6 // Once again, it appears that the value did not change! jshell> a // Let's check that. a ==> 5 // Now it is 5! jshell>
++ and -- operators when they are used in the postfix position.++ and -- operators change the value of the variable operated upon. The core difference between the prefix and postfix forms of these operators is that expressions using the postfix operators evaluate to the original value of the variable, not the new value.2 + 2 evaluates to the value 4. Also, we know that if we put that expression on the right side of an assignment expression, the variable on the left will be assigned to 4.jshell> int x = (2 + 2); x ==> 4 | created variable x : int jshell>
jshell> int y = (x = 5); // Both x and y are assigned to 5 y ==> 5 // y has the value 5 | created variable y : int jshell> x x ==> 5 // x also has the value 5 | value of x : int jshell> int z = y = x = 6; // z is declared and initialized z ==> 6 | created variable z : int jshell> y y ==> 6 | value of y : int jshell> x x ==> 6 // x, y, and z all have the value 6 | value of x : int jshell>
int variable x, initialize to 0 and then increment it by 1.jshell> int x = 0; x ==> 0 | created variable x : int jshell> ++x; $2 ==> 1 | created scratch variable $2 : int
int x = 0; int y = x++;. What are the values of x and y and why?y is 0 and x is 1. y is assigned to the expression x++, which evaluates to 0 due to the ++ postfix operator. x++ increments and reassigns the initial value of x to 1, but the expression evaluates to the old value of x, which is 0.int x = 0; x -= 10;. What is the value of x and why?x ends with a value of -10 because 0 - 10 equals -10.
