What is a Variable?

You can store information in a program using a variable.  A variable has a name and a type.  Consider the following examples:

int testScore;

double percentOfVoters;

char isAlive;

The first word refers to the type of the variable, which tells you what it stores.  For example, int means that this variable holds an integer.  The name of the variable allows you to reference it.

We always name variables using a system called camelCase.  When using camelCase, you start out a variable’s name with a lowercase value and each subsequent word is capitalized.

Declaring Initializing and Assigning

In order to use a variable, you first need to declare it.  To do so, you simply state the type of the variable and then the name you’d like to use.

int testScore;

Often you will want to start a variable out with a set value.  This is called initializing the variable.

int testScore = 5;

After you’ve created a variable, you won’t need to keep referencing its type.  You can simply refer to it by its name.  You can assign a new value to a variable at any time by using the assignment operator, the equal sign.  

testScore = 7;         // this changes the value of test score to 7

Note that when you assign a variable a new value, the old one is lost.  When you use the assignment operator, the left hand side always takes on the value of the right hand side.   You can even take the value of one variable and assign it to another.

int scoreOne = 2;

int scoreTwo = 5;

scoreTwo = scoreOne;    // scoreTwo now has a value of 2

Memory

A variable is stored in your computer’s memory.  When we talk about memory in programming, we’re usually talking about random access memory, or RAM.  This is your computer’s “short-term memory.”  Don’t confuse this with your computer’s hard drive or a network drive, which can store a lot more data but is slow to access.

A bit is the smallest unit of data you can store; it is a 0 or a 1.

A byte is a collection of 8 bits.

Primitive Types

There are two main categories of variables:  primitive types and objects.   We’re going to wait on discussing exactly what objects are.  For now, think of them as more complicated, customizable variables with special features.   There are exactly eight primitive types.

Name Description Size

byte Stores very small integers 8 bit

short Stores small integers 16 bit 

int Stores normal integers 32 bit 

long Stores big integers 64 bit 

float Stores less precise decimal values 32 bit

double Stores more precise decimal values 64 bit

boolean Stores a true or false value 1 bit*

char Stores a single character 16 bit

In this course, you’ll be using the following types most commonly:

• An int can store any integer value between -231 and 231 -1

• A double can store non-integer values with up to 15 decimal places of precision.

• A boolean can hold two values:  true or false.

• A char stores a single character like ‘a’, ‘Z’, or ‘$.’

double tacoPrice = 1.95;

int numTacos = 3;

char firstLetter = ‘t’;

boolean isHungry = true;

*A boolean actually takes up one byte of memory in Java, despite only representing 1 bit of memory.  This is because memory is addressed in 1-byte chunks. 

ASCII

ASCII stands for the American Standard for Information Interchange.   This is a list of 256 characters, each of which correspond to a numerical value.  You can find the full table here.  

Consider that a capital “A” is 65, and a capital “B” is 66.  This pattern continues through the alphabet. You can sometimes use patterns on the ASCII table to modify the values of letters, for example:

char myLetter = ‘A’;                 // Notice that chars use single quotes

myLetter = (char) (myLetter + 2);    // myLetter is now ‘C’

The last line in the example converts the ASCII back to a char.  We’ll talk more about this in the next section.

Explicit Casting

The first way to cast a variable is through an explicit cast.  This means you're specifically saying, "I want you to convert this thing to a different type."  

int a = 2;

double b = 3.5;

int c = a + (int) b;

Walking through the assignment statement, we see that c is assigned the value 5.

2 + (int) (3.5)

2 + 3 3 is truncated to an integer

5

Implicit Casting

The second way this happens an explicit cast and happens when we use a mixture of types.  This is called mixed-mode arithmetic.  A smaller data type will be converted to the larger data type temporarily for the math to work. 

int a = 9;

double b = 2.0;

double d = b / a;        

Walking through the assignment statement, we see that d is assigned the value 4.5.

9 / 2.0

9.0 / 2.0 9 is widened to a double

4.5