Learn about variables, a powerful abstraction technique. By the end of the lesson, you will be able to create variables of different types and assign values to them. 

Learn Java: Variables

Let's say we need a program that connects a user with new jobs. We need the user's name, their salary, and their employment status. All of these pieces of information are stored in our program.

We store information in [_variables_](https://www.codecademy.com/resources/docs/java/variables?page_ref=catalog), named locations in memory.

Naming a piece of information allows us to use that name later, accessing the information we stored. 

Variables also give context and meaning to the data we're storing. The value `42` could be someone's age, a weight in pounds, or the number of orders placed. With a name, we **know** the value `42` is `age`, `weightInPounds`, or `numOrdersPlaced`.

In Java, we specify the type of information we're storing. [_Primitive data types_](https://www.codecademy.com/resources/docs/java/data-types?page_ref=catalog) are types of data built-in to the Java system. The three main primitive types we'll cover are `int`, `double`, and `boolean`; this lesson will introduce these built-in types and more.

We must _declare_ a variable to reference it within our program. Declaring a variable requires that we specify the type and name:

```java
// datatype variableName
int age;
double salaryRequirement;
boolean isEmployed;
``` 
The names of the variables above are `age`, `salaryRequirement`, and `isEmployed`. 

These variables don't have any associated value. To assign a value to a variable, we use the assignment operator `=`:

```java
age = 85;
```
Now, `age` has a value of `85`. When code is used to represent a fixed value, like `85`, it is referred to as a _literal_. 

It's also common to declare a variable and assign it a value in one line! 

For example, to assign `2011` to a variable named `yearCodecademyWasFounded` of type `int`, we write:
 
```java
int yearCodecademyWasFounded = 2011;
```


Introduction

How do we answer questions like: What grade did you get on the test? What letter does your name start with? 

The `char` data type can hold any character, like a letter, space, or punctuation mark.

It must be surrounded by single quotes, `'`.

For example:
```java
char grade = 'A';
char firstLetter = 'p';
char punctuation = '!';
```

char

The first type of data we will store is the whole number. Whole numbers are very common in programming. You often see them used to store ages, or maximum sizes, or the number of times some code has been run, among many other uses.

In Java, whole numbers are stored in the _int_ primitive data type.

`int`s hold positive numbers, negative numbers, and zero. They do not store fractions or numbers with decimals in them.

The `int` data type allows values between -2,147,483,648 and 2,147,483,647, inclusive.

To declare a variable of type `int`, we use the `int` keyword before the variable name:

```java
// int variable declaration
int yearJavaWasCreated;
// assignment
yearJavaWasCreated = 1996;
// declaration and assignment
int numberOfPrimitiveTypes = 8;
```


ints

Creating and filling variables is a powerful concept that allows us to keep track of all kinds of data in our program. 

In this lesson, we learned how to create and print several different data types in Java, which you'll use as you create bigger and more complex programs.

We covered:

- `int`, which stores whole numbers.
- `double`, which stores bigger whole numbers and decimal numbers.
- `boolean`, which stores `true` and `false`.
- `char`, which stores single characters using single quotes.
- `String`, which stores multiple characters using double quotes.
- _Static typing_, which is one of the safety features of Java.
- Variable naming conventions.

Practice declaring variables and assigning values to make sure you have a solid foundation for learning more complicated and exciting Java concepts!

Review

So far, we have learned primitive data types, which are the simplest types of data with no built-in behavior. Our programs will also use [`String`](https://www.codecademy.com/resources/docs/java/strings?page_ref=catalog)s, which are _objects_, instead of primitives. Objects have built-in behavior.

`String`s hold sequences of characters. We've already seen instances of a `String`, for example, when we printed out `"Hello World"`. There are two ways to create a `String` object: using a `String` literal or calling the `String` class to create a new `String` object.

A _String literal_ is any sequence of characters enclosed in double-quotes (`""`). Like primitive-type variables, we declare a `String` variable by specifying the type first: 
```java
String greeting = "Hello World";
```
We could also create a _new String object_ by calling the `String` class when declaring a `String` like so:
```java
String salutations = new String("Hello World");
```

There are subtle differences in behavior depending on whether you create a `String` using a `String` literal or a new `String` object. We'll dive into those later, but for now, we'll almost always be using `String` literals. 


**Keep Reading: AP Computer Science A Students**

Certain symbols, known as escape sequences, have an alternative use in Java print statements. Escape sequences are interpreted differently by the compiler than other characters. Escape characters begin with the character `\`. 

There are three escape sequences to be aware of for the AP exam.

The `\"` escape sequence allows us to add quotation marks `"` to a `String` value. :
```java
System.out.println("\"Hello World\"");
// Prints: "Hello World"
```
If we didn't use an escape sequence, then Java would think we're using `"` to end the String!

Using the `\\` escape sequence allows us to place backslashes in our `String` text:
```java
System.out.println("This is the backslash symbol: \\");
// Prints: This is the backslash symbol: \
```
This is similar to the last example - just like `"`, `\` usually has a special meaning. In this case, `\` is used to start an escape sequence. Well, if we don't want to start an escape sequence and just want a `\` in our String, then we'll use `\\` &mdash; we're using an escape sequence to say that we don't want `\` to be interpreted as the start of an escape sequence. It's a little mind-bending!


Finally, if we place a `\n` escape sequence in a `String`, the compiler will output a new line of text:
```java
System.out.println("Hello\nGoodbye");
/*
Prints:
Hello
Goodbye
*/
``` 
You can think of `\n` as the escape sequence for "newline".

String

Whole numbers don't accomplish what we need for every program. What if we wanted to store the price of something? We need a decimal point. What if we wanted to store the world's population? That number would be larger than the `int` type can hold.

The `double` primitive data type can help. `double` can hold decimals as well as very large and very small numbers. The maximum value is 1.797,693,134,862,315,7 E+308, which is approximately 17 followed by 307 zeros. The minimum value is 4.9 E-324, which is 324 decimal places!

To declare a variable of type `double`, we use the `double` keyword in the declaration:

```java
// doubles can have decimal places:
double price = 8.99;
// doubles can have values bigger than what an int could hold:
double gdp = 12237700000;
```


doubles

Often our programs face questions that can only be answered with yes or no.

Is the oven on? Is the light green? Did I eat breakfast?

These questions are answered with a _boolean_, a type that references one of two values: `true` or `false`.

We declare boolean variables by using the keyword `boolean` before the variable name.

```java
boolean javaIsACompiledLanguage = true;
boolean javaIsACupOfCoffee = false;
```

In future lessons, we'll see how `boolean` values help navigate decisions in our programs.
  


booleans

Let's imagine we're storing a user's name for their profile. Which code example do you think is better?

```java
String data = "Delilah";
```

or
```java
String nameOfUser = "Delilah";
```

While both of these will compile, the second example is much easier to understand. Readers of the code will know the purpose of the value: `"Delilah"`. 

Naming variables according to convention leads to clear, readable, and maintainable code. When someone else, or our future self, reads the code, there is no confusion about the purpose of a variable.

In Java, variable names are case-sensitive. `myHeight` is a different variable from `myheight`. The length of a variable name is unlimited, but we should keep it concise while keeping the meaning clear.

A variable starts with a valid letter, or a `$`, or a `_`. No other symbols or numbers can begin a variable name. `1stPlace` and `*Gazer` are not valid variable names.

Variable names of only one word are spelled in all lowercase letters. Variable names of more than one word have the first letter lowercase while the beginning letter of each subsequent word is capitalized. This style of capitalization is called _camelCase_.

```java
// good style
boolean isHuman;

// bad styles
// no capitalization for new word
boolean ishuman;
// first word should be lowercase
boolean IsHuman;
// underscores don't separate words
boolean is_human;
```


Naming


The Java programming language has [_static typing_](https://www.codecademy.com/resources/docs/java/data-types?page_ref=catalog). Java programs will not compile if a variable is assigned a value of an incorrect type. This is a _bug_, specifically a type declaration bug.

Bugs are dangerous! They cause our code to crash, or produce incorrect results. Static typing helps because bugs are caught during programming rather than during execution of the code.

The program will not compile if the declared type of the variable does not match the type of the assigned value:

```java
int greeting = "Hello World";
```
The String `"Hello World"` cannot be held in a variable of type `int`.

For the example above, we see an error in the console at compilation:

```
error: incompatible types: String cannot be converted to int
    int greeting = "Hello World";
```

When bugs are not caught at compilation, they interrupt execution of the code by causing [_runtime errors_](https://www.codecademy.com/resources/docs/java/errors?page_ref=catalog). The program will crash.

Java's static typing helps programmers avoid runtime errors, and thus have much safer code that is free from bugs.
