Take a look at these statements:

`int i = 1;`

`j=7;`

`7+count=c;`

`b+14=a+9;`

The first two are fine (assuming that 7 is a valid value for whatever type of variable

`j`is), but the last two are wrong.

**Remember All That Algebra We Taught You? Well, We Broke It.**

After you've gone to all the trouble to learn how to deal with things like

`7+count=c`and

`b+14=a+9`in algebra class, now we take what you know and turn it on its ear in programming class. Sweet, eh?

The problem is that the

`=`we use in programming has pretty much nothing to do with the

`=`that you use in math. It's just close enough to be confusing. In Java, the equals sign is an

*assignment*operator, not an indicator of equality between values as it is in math. There is a comparison operator for equality in Java, it's

`==`, and we'll talk about it shortly. First, let's talk assignment.

**Assignment**

In computers, we use the term assignment to describe sticking a value into the computer's memory so that we can get it back later. It's like using the memory in a programmable calculator. We put some number into our calculator's memory so that we can get it back later for another part of our calculation. It's pretty much the same thing with computers.

With Java, we can store all kinds of values, not just numbers. We can store sections of text, called

*strings*in a

`String`variable, for example. (Java prefers the term "member" over variable, in general. For what we're talking about now, the two terms are interchangeable.) We can also store more than one thing at a time, like all the information about a bicycle in a Bicycle object that keeps track of a bicycle's color, frame size, tire size, gear ratios, etc., all together in one object.

But we're here to just look at assignment today, not the wide variety of things we can assign as values.

To store a value on a calculator, you use some key sequence like

`M+`or

`STO 00`to store the value in the calculator's display to memory. With Java, we use the equals sign to store some value on the right into whatever is on the left side of the equals sign. We read from left to right like this:

`count = a;`

"count equals a"

This means we take the value of

`a`and place it in

`count`. But a better way to read that equals sign is to use the word "becomes" instead of "equals":

`count = 9;`

"count

**becomes**nine"

This makes it more obvious that we're putting in a new value that changes the value of

`count`. In this case, we're putting in a value of 9. The statement up above would be "count becomes a" or, better yet, "count becomes a's value." Because what we're doing in

`count= a;`is taking the value in variable

`a`and copying it into

`count`. If we then print the value in

`count`, it will be the same as whatever is in

`a`at that time.

We can also compute a value to put into our variable.

`count = a + 1;`

"count becomes a plus one"

This makes the value in

`count`be one more than the current value of

`a`.

What we

**can't**do is change sides around the equals sign. In algebra,

*c = a + 1*is the same as

*a + 1 = c*. But in Java that doesn't work:

`a + 1 = count`

This is wrong in Java. Does not compute. Norman, Norman, help me Norman!

We would be trying to make a+1 become the value in count. The problem is, you can't have a storage location named "a+1". Java doesn't see this the way your algebra trained eyes do.

**Comparisons**

In normal math, when we use the equals sign we are making a comparison. We are stating that what's on one side of the equals sign is the same as what's on the other side. For most algebra problems, we assume that the statement is true and try to find values for the variables that result in that.

Another use of equals in some math problems is to state that two things are equal when they may or may not be, then determine whether that statement is true or not. You remember those problems, they looked something like this:

`State whether each of the following is true or false.`

`1. 11 = 6 + 5`

2. 14 = 3 x 7

3 65 - 14 = 17 x 3

2. 14 = 3 x 7

3 65 - 14 = 17 x 3

In Java, the equals sign is already used for assigning values to variables. How do we do a comparison to see whether it's true or not?

**The == Operator**

In some languages,

`=`does both jobs. But in Java, there's a second operator for doing equality comparisons,

`==`, "equals equals". When we want to see if two values are the same, we compare them using a statement something like this:

`if (count == 100) then stop();`

This compares

`count`to the value

`100`, and executes the method

`stop()`if the result of the comparison is

`true`.

**The Dangers of the = Operator**

Something to look out for is using

`=`by accident in such a situation. Like this:

`if (count = 100) then stop();`

Don't do this if you want to compare count to 100!

What this does is

*assign*the value 100 to

`count`. If the assignment is successful (which it almost certainly will be, if the program compiles), the program will then do

`stop()`every time it hits this statement! Because the assignment was successful, so the result is considered to be

`true`.

**Summary**

The equals sign makes the variable on the left equal the computed value from the right side of the equals sign:

`name = "Mergatroyd";`

"name becomes Mergatroyd"

It doesn't work the other way around (putting something from the left into the variable on the right.)

If you want to compare to values to see if they're equal, use "equals equals":

`if (state == "done") then exit();`

"if state equals equals done then exit" or

"if state is equal to done then exit"