**Operators**

The standard math functions that are built into the Java language are called

*operators*. These are the sort of math functions you would expect to find on a simple calculator, plus some extras:

+ - * / % ++ --

There are other operators used for comparisons, these are the math operators. You can learn more about them in the Java Language Specification, specifically in Integer Operations, Floating-Point Operations, and more extensively through Chapter 15, Expressions.

`+`and

`-`do what you would expect, they add and subtract one value from another.

`*`is the symbol used for multiplication, instead of the × used in math class.

`*`is used because it's easier for the computer to recognize it as a math operator, × just looks like a letter 'x' to the computer. Similarly,

`/`is used for division. The ÷ sign isn't on most keyboards, but / has been common on keyboards even before they were attached to computers.

The % sign doesn't do what you might, at first, expect. It doesn't calculate a percentage, as it does on most calculators. It returns the remainder of a division. For example, if you do 10/3 (ten divided by three), the result will be 3. But what if you want to get the remainder? That's what % does. 10%3 will return a value of 1. '%' is sometimes called "modulo". It's a bit of a misnomer, mathematically, but the use of the term is common and well understood, so it's not unusual to pronounce 10%3 as "ten modulo three". This is a very valuable function for keeping a value within a certain range, such as keeping an object located onscreen in graphics by having it "wrap" from one side of the screen to the other when it reaches an edge.

`++`and

`--`are the "increment" and "decrement" operators. Increment means "go up by one unit", and decrement "go down by one unit". So if you've got a variable like:

`int i = 5;`

And you do

`i++`

, the value of `i`

will become 6. Doing `i--`

will take away 1. `++`and

`--`can be placed either before or after the value they act on, for example:

`number = i++;`

count = --j;

There will be different effects on your program depending on whether they come before or after the value. You can find information on that in the Java Language Specification as well, in sections 15.14 and 15.15 which cover the two ways of using these operators. In general, it's best to stick to using them

*after*your value until you understand the differences.

**Assignment Operators**

You can also do math as part of assigning a value. For example, let's say we want to add three to a value in our program. The obvious way to do this would be:

`i = i + 3;`

This takes the prior value of

`i`, adds 3 to it, then puts the result back into variable

`i`. With an

*assignment operator*we can do the same thing more tersely:

`i += 3;`

We've combined the

`+`with

`=`to create an operator. This does the same thing as

`i = i + 3;`

. Your program doesn't care which way you type it. The same thing can be done with the other operators that take two values:`i *= 4; // Multiply i by four, store result back in i.`

i /= 2; // Divide i in half.

i %= 3; // Put the remainder of i/3 in i.

i -= 7; //Subtract seven from i.

**More Complex Math**

This is what we can do with the basic math operators built into the language. To get more operations, like those found on a scientific or programmer's calculator, we use methods of some of the standard packages of Java. Which I'll cover in a future article.

Until then, have a look at java.lang.Math.