 Earlier, we talked about expressions of the form variable equal variable plus one, being very common. In general, updating variables is quite common in Java programs. Presume that the variables in these examples have been declared elsewhere in the program. Whenever you have this pattern, where a variable is updated by an arithmetic operation, you can use an augmented assignment operator. These expressions turn into these simpler expressions. Age plus and becomes one is the same as age equals age plus one. Limit minus and becomes five is the same as limit equals limit minus five and so on. If you don't have a simple update, then you can't use the augmented assignment. There's no way to use augmented assignment to simplify this expression, sorry. Let's get back to adding one and subtracting one, also called incrementing and decrementing, which are among the most common operations that programs perform. There's a special shortcut for this, plus plus for increment and minus minus for decrement. This updates the variable without needing an equal sign. The variable is changed in place. You can also put the operator before the variable name as shown here. Why two versions and what's the difference? When the operators are all by themselves, as in this example, there's really no difference. But when you put them in an expression with other operations, there's a big difference. Here the plus plus follows the variable and it's called a post increment. This is what things look like after we initialize quantity in the first line. Let's see what happens when Java encounters the second statement. It accesses the value of quantity, which is ten. Then the plus plus takes effect and the variable quantity becomes eleven. But our scratch paper still says ten. When we do the multiplication, we get a result of fifty and assign that result to the variable total. Now let's try it with the plus plus before the variable name, which is called a pre-increment. At the end of the first statement, quantity is still ten. And at the beginning of the second statement, we pull out a piece of scratch paper for the right hand side of the equal sign. Because the plus plus comes before the variable name, the increment happens before we access the value of the variable. Now when we look at quantity, we get eleven and multiply that by five, getting fifty five, which goes into our total. I don't recommend writing this sort of thing. I don't think it adds to clarity. However, you will see this in programs that other people write and you need to know how to interpret it correctly. For example, how would you solve this problem? If you ever see an expression like this, here's a technique that will be very useful for you. Find everything with a pre-operator, the plus plus or minus minus preceding the variable name, and write it out completely before the statement in question. Now find everything with a post-operator, the plus plus or minus minus following the variable name, and write it out after the statement. Now go through the statements in order. Here's our situation after the first two statements. We add one to y, then we do the multiplication, and then we subtract one from x. Again, I would recommend writing this code as three statements rather than the original combination, which I think is much harder to understand. One final word of warning. What happens if you use the same variable with both pre- and post-operators on the right hand side of an equal sign? Answer? Don't. Just don't. Not only is it hard to understand, but in other programming languages the result could be completely undefined. In summary, most of the time you will use the increment and decrement operators all by themselves. If you use them in expressions with other operators, you have to be careful to choose whether to put the operator before or after the variable, depending on the effect you want. In the interest of code clarity, you might want to avoid this sort of expression altogether and write things out completely.