Basic Data Storage 2

Variables

The language is broadly divided into 'variables' and 'statements'.
Variables are places in which you store stuff you want to use...
- e.g., words, numbers, data.
- They are usually represented by names.
Statements are what you want to do...
- e.g., print a word, add two numbers.

Let's imagine we need to use an x coordinate a number of times in a program.
We could 'hardwire' or 'hardcode' values in:
```
System.out.println("x value is 100.0");
```
Say we use this value of x a thousand times in the program. What if we want to change the x location?
What we need is to attach the value to a name, and use the name instead - if we want to change the value, we just change the value the name points at.
This is what a variable is for.

The computer usually needs to know what kind of thing they are before they can be used, so they can be stored efficiently.
There are several simple types (primitives), including:

int : an whole number between ~+/- 2,000,000,000

double : a decimal number between +/- 10^+/-38

boolean : either true or false

char : a single character

To tell the computer what type of variable you are using you must declare it, usually before you use it. The syntax for doing this is:
```
	type variableName;
```
For example:
```
	
double x;
```
This variable declaration tells the computer to make a name-tag in memory in preparation for an double and call it 'x'.
Note that variables should start with a lowercase letter and describe the value inside them.

It's then usual to 'assign' a value to the variable. The computer makes an double-shaped space in memory containing the value and attaches the name-tag to it, e.g.,
```
	
x = 100.0;
```
You can do both at once, e.g.,
```
	
double x = 100.0;
```
Infact, this is quite usual during initialisation (the first time you use a variable). After that, you don't do the label creation bit again.

You can then use the variables:

e.g., make another variable and use it to store some answer involving the variable:
```
	
double nearX = x + 1.0;
```
e.g. print it out:
```
	
System.out.println("x = " + x);
```
which prints x = 100.0; note that "+" joins two things for printing if one is text, and the difference between "x = " which is in quotes, so is text, and x, which isn't, and is therefore a variable, the value of which is printed.

Operators for manipulating variables:

Operators have a definite order in which things are done. For example,
```
	
i = 6 + 6 / 3;
```
will give i as 8, not 4.
Always best to put equations in parentheses to make it clear what you're after. In this case,
```
	
i = (6 + 6) / 3;
```

Casting is the conversion of one type of variable to another.
Casting can be done implicitly with some types...
```
	
int m = 3;
double i = m;
```
gives i as 3.0.
Implicit casting is usually possible with primitive types where there is no loss of precision.

Syntax is...

	
(target type) variable;

for example,

	
int numberOfPokemon = 150;
byte number;

number = (byte)numberOfPokemon;

To stop this, always give figures with decimal points, e.g.

	
double d = 3.0 / 2.0;

not

	
double d = 3 / 2;