Incremental Java
Incremental Java Compound Assignment Statements Scenerio Suppose you had an int variable, sum, and you wanted to add 10 to it. How would you do this? Here's one solution:
sum = sum + 10 ;
This kind of operation is very common (where 10 is replaced by whatever value you want). It's so common that Java has a shorter way of saying the same thing. Java uses the compound addition assignment operator, which looks like: += (plus sign, followed by equal sign).
sum += 10 ; // Add 10 to sum
Suppose, instead of adding a value to sum, you wanted to double it? That is, you wanted to multiply it by 2? One way to do this is:
sum = sum * 2 ; // Multiply sum by 2
Can you guess the shortcut? If += lets you add the value on the RHS to the LHS, what do you think the operator is for multiplying the value from the RHS to the LHS? Yes, it's *=.
sum *= 2 ; // Multiply sum by 2
Binary Operators to Binary Assignment Operators Nearly every binary operator can be made into a compound assignment operator. For example, suppose Java has a binary operator @ (it doesn't, but pretend that it does). Java is very likely to have a binary assignment operator @=. Here's the semantics.
lvalue @= rvalue ;
is the same as:
lvalue = lvalue @ (rvalue) ;
Notice that parentheses are added to the rvalue. This is necessary to avoid problems with precedence. For example, consider:
x *= 3 + y
This is equivalent to:
x = x * ( 3 + y ) ;
If we didn't put the parentheses, we'd get:
x = x * 3 + y ; // WRONG!
which, using Java's rule of precedence, would be equivalent
x = ( x * 3 ) + y ; // WRONG!
and give us a different answer from
x = x * ( 3 + y ) ; // RIGHT!
Some Compound Assignment Operators Many Java programmers are unaware of how many different compound assignment operators there are. Here's a partial list: +=, *=, /=, -=, %=, &=, &&=, |=, ||=, <<=, >>=, ^=. Basically, if it's a Java binary operator, you should be able to use a binary compound assignment operator as well.
