Summer’s over — what’s your move? Join Pro for 50% off using code [MAKEITHAPPEN](https://www.codecademy.com/checkout?periods=year&plan_id=proGoldAnnualV2&discountCode=MAKEITHAPPEN)


You have learned how to create variables of different types and store values in them. But what do we do with these variables once we create them?
In this lesson, you will learn some of the basic operations we can perform on variables, including math and comparisons.

Learn Java: Manipulating Variables

In our bank account example from the last exercise, we used the `+` operator to add the values `balance` and `depositAmount`:

```java
double balance = 20000.99;
double depositAmount = 1000.0;
balance = balance + depositAmount;
// balance now holds 21000.99
```
If we wanted to withdraw from the balance, we would use the `-` operator:
```java
double withdrawAmount = 500;
balance = balance - withdrawAmount;
// balance now holds 19500.99
```
Addition and subtraction work with `int` type values as well! If we had `60` pictures of cats on our phone, and we took `24` more, we could use the following line of code to store `84` in `numPicturesOfCats`.
```java
int numPicturesOfCats = 60 + 24;
```
What if we took one additional picture of our cat? We can reflect this change using an increment operator `++`. When we append `++` to a number-based variable, it increases the value by `1`. We also have the decrement operator, `--`, which decreases the value by `1`.

```java
// Take a picture
numPicturesOfCats++ // Value is now 85

// Delete a picture
numPicturesOfCats-- // Value is now 84
```

Addition and Subtraction

Throughout this lesson, we've discussed the different ways we can manipulate a variable; however, what do we do with a variable that should never change its value?

For example, the year we were born will always stay the same. There's no way we can change that information. A value like this in our code should be unchangeable.

To declare a variable with a value that cannot be manipulated, we need to use the `final` keyword. To use the `final` keyword, prepend `final` to a variable declaration like so:
```java
final int yearBorn = 1968;
```
When we declare a variable using `final`, the value cannot be changed; any attempts at doing so will cause an error to occur:
```error
error: cannot assign a value to final variable yearBorn
```


final Keyword

So how would we validate our paycheck to see if we got paid the right amount?

We can use another relational operator to do this. `==` will tell us if two variables are equal:

```java
double paycheckAmount = 620;
double calculatedPaycheck = 15.50 * 40;

System.out.print(paycheckAmount == calculatedPaycheck);
// This will print true, since paycheckAmount equals calculatedPaycheck
```

Notice that the equality check is **two** equal signs, instead of one. One equal sign, `=`, is how we assign values to variables! It's easy to mix these up, so make sure to check your code for the right number of equal signs.

To check if two variables are **not** equal, we can use `!=`:

```java
double balance = 20000.0;
double amountToDeposit = 620;
double updatedBalance = balance + amountToDeposit;

boolean balanceHasChanged = balance != updatedBalance;
// balanceHasChanged holds true, since balance does not equal updatedBalance
```


Equals and Not Equals

How could we make sure we got paid at least the amount we expected in our paycheck? We could use greater than or equal to, `>=`, or less than or equal to, `<=`!

```java
double paycheckAmount = 620;
double calculatedPaycheck = 15.50 * 40;
System.out.println(paycheckAmount >= calculatedPaycheck);
//this will print true, since paycheckAmount equals calculatedPaycheck
```


Greater/Less Than or Equal To

We have covered a lot of built-in functionality in Java throughout this lesson. We've seen `+`, `-`, `<`, `==`, and many other operators. Most of these only work on primitives, but some work on `String`s too!

Let's say we want to print out a variable, and we want to describe it as we print it out. For our bank account example, imagine we want to tell the user:

```
Your username is: <username>
```

With the value of the variable `username` displayed.

The `+` operator, which we used for adding numbers together, can be used to _concatenate_ `String`s. In other words, we can use it to join two `String`s together!

```java
String username = "PrinceNelson";
System.out.println("Your username is: " + username);
```

This code will print:

```
Your username is: PrinceNelson
```

We can even use a primitive datatype as the second variable to concatenate, and Java will intelligently make it a `String` first:

```java
int balance = 10000;
String message = "Your balance is: " + balance;
System.out.println(message);
```

This code will print:

```
Your balance is: 10000
```

String Concatenation

If we were to place multiple operators in a single expression, what operation would the compiler evaluate first?

```java
int num = 5 * (10 - 4) + 4 / 2;
```
The order of operations dictates the order in which an expression (like the one above) is evaluated. Operators that share the same precedence are evaluated from Left-to-Right within the expression.

The order is as follows:
1. Parentheses
2. Exponents
3. Modulo/Multiplication/Division
4. Addition/Subtraction

With this new information in mind, let's dissect the expression from above so that we can find the value of `num`:
```java
5 * (10 - 4) + 4 / 2
```
`10 - 4` would be evaluated first because it is wrapped in parentheses. This value would become `6` making our expression look like this:
```java
5 * 6 + 4 / 2 
```
Next, `5 * 6` will be evaluated because of the `*` operator. This value is `30`. Our expression now looks like this:
```java
30 + 4 / 2
```
Following the order of operations, `4 / 2` will be evaluated next because the division operator `/` has higher precedence than the addition operator `+`. Our expression now resembles the following:
```java
30 + 2
``` 
`30 + 2` is `32`. This means that the value of `num` is `32`.

Order of Operations

What's the use of having variables if you can't do anything with them? We've now seen some ways you can operate on variables and compare them. The possibilities are endless!

We covered:
- Addition and subtraction, using `+` and `-`
- Multiplication and division, using `*` and `/`
- The modulo operator for finding remainders, `%`
- Compound assignment operators `+=`, `-=`, `*=`, `/=`, and `%=`.
- The order of operations: parentheses -> exponents -> multiplication, division, modulo -> addition, subtraction
- Greater than, `>`, and less than, `<`
- Equal to, `==`, and not equal to, `!=`
- Greater than or equal to, `>=`, and less than or equal to, `<=`
- `equals()` for comparing `String`s and other objects
- Using `+` to concatenate `String`s
- The `final` keyword which makes variables unchangeable


Practice some of these concepts here, to make sure you have a solid foundation for learning more complicated and exciting Java concepts!
    


Review

Sometimes, we need to adjust the value of a variable. 

Imagine we're working at a bake sale and want to keep track of how many cupcakes we have by creating a variable called `numCupcakes`:
```java
int numCupcakes = 12;
```
If we baked `8` more cupcakes, we know that we could update our variable using the `+` operator:
```java
numCupcakes = numCupcakes + 8; // Value is now 20
```
While this method works just fine, we had to write our variable `numCupcakes` twice. We can shorten this syntax by using a _compound assignment operator_. 

Compound assignment operators perform an arithmetic operation on a variable and then reassigns its value. Using the `+=` compound assignment operator, we can rewrite our previous code like so:
```java
numCupcakes += 8; // Value is now 20
```
Now we only need to reference `numCupcakes` once. 

We can use compound assignment operators for all of the arithmetic operators we've covered:
* Addition (`+=`)
* Subtraction (`-=`)
* Multiplication (`*=`)
* Division (`/=`)
* Modulo (`%=`)



Compound Assignment Operators

So far, we've only been using operations on primitive types. It doesn't make much sense to multiply `String`s, or see if one `String` is less than the other. But what if we had two users logging into a site, and we wanted to see if their usernames were the same? 

With objects, such as `String`s, we can't use the primitive equality operator. To test equality with objects, we use a built-in method called `.equals()`. When comparing objects, make sure to always use `.equals()`. `==` will work occasionally, but the reason why it sometimes works has to do with how objects are stored in memory. 

For the purposes of this lesson (as well as good practice) remember to use `.equals()` instead of `==` when comparing objects.

To use it, we call it on one `String`, by using `.`, and pass in the `String` to compare against in parentheses:
```java
String person1 = "Paul";
String person2 = "John";
String person3 = "Paul";

System.out.println(person1.equals(person2));
// Prints false, since "Paul" is not "John"

System.out.println(person1.equals(person3));
// Prints true, since "Paul" is "Paul"
```

.equals()

Let's say we are writing a program that represents a user's bank account. With variables, we know how to store a balance! We'd use a `double`, the primitive type that can hold big decimal numbers. But how would we deposit and withdraw from the account? 

Lucky for us, we have the ability to manipulate the value of our variables. We can use expressions, arithmetic operators, and more in order to change our variables' values. 

For example, Java has built-in arithmetic operations that perform calculations on numeric values:
```java
// declare initial balance
double balance = 20000.99;
// declare deposit amount
double depositAmount = 1000.00;
// store result of calculation in our original variable
balance = balance + depositAmount;
```
In the final line of the code above, we used the expression `balance + depositAmount` to determine the new value of the `balance` variable. When an expression is executed, it produces a single value. 

The data type of a variable plays a large role in the operations we can use to manipulate it. We can think of a data type as a combination of a set of values, and a set of operations on those values. For example, the `double` data type is comprised of values like `4.8` and operations like addition (`+`). For now, we'll mainly focus on the set of operations that can be used on numbers and booleans.

The data type of an expression is determined by the resulting value. For example, an expression that uses two `int` values will evaluate to an `int` value. If an expression contains a `double` value, then the resulting value will also be type `double`. 

Throughout this lesson, we will learn how to manipulate variables of different data types.

Introduction

Let's say that our employer is calculating our paycheck and depositing it to our bank account. We worked 40 hours last week, at a rate of $15.50 an hour. Java can calculate this with the multiplication operator `*`:

```java
double paycheckAmount = 40 * 15.50;
//paycheckAmount now holds 620.0
```

If we want to see how many hours our total balance represents, we use the division operator `/`:


```java
double balance = 20010.5;
double hourlyRate = 15.5;
double hoursWorked = balance / hourlyRate;
//hoursWorked now holds 1291.0
```

Division has different results with integers. The `/` operator does _integer division_, which means that any remainder is lost.

```java
int evenlyDivided = 10 / 5;
//evenlyDivided holds 2, because 10 divided by 5 is 2
int unevenlyDivided = 10 / 4;
//unevenlyDivided holds 2, because 10 divided by 4 is 2.5
```
`evenlyDivided` stores what you expect, but `unevenlyDivided` holds `2` because `int`s cannot store decimals! It's important to note that the `int` doesn't round the decimal, but floors it. Java removes the `0.5` to fit the result into an `int` type!

It's important to note that if we try to divide any number by `0`, we will get an `ArithmeticException` error as a result.

Multiplication and Division

Now, we're withdrawing money from our bank account program, and we want to see if we're withdrawing less money than what we have available.

Java has _relational operators_ for numeric datatypes that make `boolean` comparisons. These include less than (`<`) and greater than (`>`), which help us solve our withdrawal problem.

```java
double balance = 20000.01;
double amountToWithdraw = 5000.01;
System.out.print(amountToWithdraw < balance);
//this will print true, since amountToWithdraw is less than balance
```

You can save the result of a comparison as a `boolean`, which you learned about in the last lesson.

```java
double myBalance = 200.05;
double costOfBuyingNewLaptop = 1000.05;
boolean canBuyLaptop = myBalance > costOfBuyingNewLaptop;
//canBuyLaptop is false, since 200.05 is not more than 1000.05
```


Greater Than and Less Than

If we baked 10 cookies and gave them out in batches of 3, how many would we have leftover after giving out all the full batches we could?

The modulo operator `%`, gives us the **remainder** after two numbers are divided.

```java
int cookiesBaked = 10;
int cookiesLeftover = 10 % 3;
//cookiesLeftover holds 1
```
You have 1 cookie left after giving out all the batches of 3 you could!

Modulo can be a tricky concept, so let's try another example. 

Imagine we need to know whether a number is even or odd. An even number is divisible by 2.

Modulo can help! Dividing an even number by 2 will have a **remainder** of 0. Dividing an odd number by 2 will have a **remainder** of 1.

```java
7 % 2
// 1, odd!
8 % 2
// 0, even!
9 % 2
// 1, odd!
```