Variables and the 8 Primitive Data Types

The Purpose of a Variable (and some vocabulary)

You can think of a simple program as a list of instructions to be read and acted upon sequentially


  1. Read a value representing the radius of a circle from the standard input source/stream
  2. Compute the area of a circle with this radius
  3. Print the area to the standard output stream (i.e., the console window)

Remember: a computer will read and act upon these instructions one at a time – it is not aware of what is coming up until it gets there!

Looking at step 1 in the program above, we will need to tell the computer that it needs to remember the value it is reading in – it needs to store this value in its memory somewhere so we can use it in a computation later.

We need to tell the computer how much memory will be needed to store the value in question. Different kinds of numbers require different amounts of memory (more on this in a minute). Of course, we sometimes need to store things other than numbers. These things too, come in different sizes. For example, it will certainly take more memory to store the Declaration of Independence than it will to store a single letter (i.e., a “character”). Further, we also need to tell the computer how the value should be stored in memory (i.e., what method of "encoding" should be employed to turn the value into a string of 1's and 0's). Examples of types of encodings used include Two's Complement, IEEE 754 Form, ASCII, Unicode, etc...

The computer also needs to have some reference to where it stored the value, so it can find it again.

The concept of a variable solves all of our problems here. A variable in Java gives us a way to store values (or other kinds of information) for later use, addressing all of the aforementioned considerations.

The amount of memory allocated for a given variable and how the value of that variable should be stored in memory depends upon its type. There are 8 primitive types of data built into the Java language. These include: int, byte, short, long, float, double, boolean, and char. The first 6 allow for storage of different kinds of numbers, the last stores a single character (think “keyboard” character). We’ll talk more about the differences between these in a little bit…

Also, every variable has a name that refers to the location of that particular portion of memory (so the computer can find it again).

And of course, the value of a variable consists of whatever information currently occupies the memory referenced by its name.

Whenever we use a variable in a Java program, we must first declare the variable – that is, we specify what the type and name of the variable will be.

Then we can assign a value to the variable – that is, tell it what to remember.

When we assign a variable a value for the first time, we are said to be initializing the variable.

Of course, computers are picky about how you tell them to do something. Truth be told, they are kind of dumb. They can’t “read between the lines” or “figure out what you really meant”. Programming languages have a particular format you have to stick to when telling the computer what to do. This format is called syntax. When code is written in a way that the computer can understand, we say the code is syntactically correct. When the code is written in a way the computer cannot understand, we say there is a syntax error.

Let’s take a look at the syntax for declaring a variable:

<variableType> <variableName>;

Two Examples:

int myLuckyNumber; //Declares myLuckyNumber to be an integer variable
char myLetter;     //Declares myLetter to be a character variable

The semicolon on the end functions much like a period does in the English language. It tells the computer that the statement of what to do is complete at this point. Declare this variable of this type (that is to say: tell the computer to allocate an appropriate amount of memory for the type of variable given and reference that portion of memory by the name given), and that’s it. Now move on to the next statement…

To assign a variable a value, we use the following syntax:

<variableName> = <value or expression>;

Some Examples:

myLuckyNumber = 13;     //Assigns the variable myLuckyNumber 
                        //the value 13
myLuckyNumber = 5+8;    //Also assigns the variable myLuckyNumber 
                        //the value 13
                        //Note: expressions like the sum on the 
                        //right are evaluated before they are 
myLetter = ‘a’;         //Assigns the variable myLetter the 
                        //character ‘a’.

Note the equals sign here means something different than it does in mathematics. In fact, we don’t even call this symbol “equals”. We call it the “assignment operator” instead, or “gets” for short.

So we read the following:

myLuckyNumber = 13;

as “The variable myLuckyNumber gets the value 13.”

A Useful Shortcut -- Variable Declaration and Assignment in One Statement

Java does allow us to shorten variable declaration and initialization up a bit, syntactically. We can declare a variable and assign it a value in one step as the following examples show:

int x = 1;
double d = 1.4;
char myLetter = ‘a’;
int myLuckyNumber = 5 + 8;
double myProduct = 3.14 * (2.78 + 1.0);

When source code contains a representation of a fixed value (like 1, 1.4, and ‘a’ above) that requires no computation, we call that representation a literal.

An expression, on the other hand, (like the 5+8 or the 3.14 * (2.78 + 1.0) above) is a combination of one or more operands and operators, whose value must be calculated. The operands might be literals, variables, or some other source of data.

Variable Reassignment

Variables don’t have to have the same value throughout your entire program. Their contents can be changed over the course of the program’s execution. For example, suppose you are writing a program to count the number of stars seen in an image of the night sky taken with your digital camera. You might declare a variable named “numStarsFound”, initializing it to zero. Then upon examining the picture file, each time your program locates a new star, you might increase the value of your variable by one with the following statement:

numStarsFound = numStarsFound + 1;

Then when you are done, the variable numStarsFound will reflect the number of stars found in the entire picture.

Be aware, you must declare a variable before you can assign a value to it, but you should only declare a variable once within a given scope. (We’ll talk more about scope later.)

Printing the Value of a Variable

As seen in the "Hello World" program, we can use System.out.println() to print things to the console. The "things" that can be printed include text, variable values, or the value of any valid expression. As an example, suppose one wants to print the value of a previously declared and initialized variable named myVar. The following would do the trick:


Technically, the code above does a little bit more than just printing the value of myVar -- it also prints a line-feed character immediately afterwards. The effect of this is similar to hitting the "return" key on a keyboard, it moves the cursor down a line. As such, if anything is printed to the console after this statement, it will be printed on a different line.

If you wanted to avoid printing the extra line-feed character, you could opt for System.out.print() instead, as the example below suggests.

int a = 1;
int b = 2;

The above code snippet would print the following to the console:


Here's an example that mixes in some re-assignments and also prints variable values of different types. Note in particular how the double z gets printed as a decimal, despite it not having a fractional part...

int x = 1;             //an integer variable x is declared 
                       //and initialized to 1

int y = 2;             //an integer variable y is declared 
                       //and initialized to 2

double z = 3;          //a double variable z is declared
                       //and initialized to 3.0

x = y + 3;             //x is now 5
y = x * 4;             //y is now 20
x = x + 1;             //x is now 6

System.out.print(x);   //prints 6 to the console
System.out.println(y); //prints 20 to the console
System.out.println(z); //prints 3.0 to the console

Here's what we would see on the console when the above code is executed:


The Names of Variables...

The name of a variable is formally called an identifier.

  • Identifiers are sequences of characters, consisting only of letters, digits, underscores (_), and/or dollar signs($).
  • An identifier must start with a letter, an underscore (_), or a dollar sign ($). It must not start with a digit.
  • Identifier names are case sensitive!!! (mynumber is different than myNumber)
  • An identifier may not be a reserved word, or the words: true, false, or null.
    • Here's a list of the reserved words in the Java programming language. The keywords const and goto are reserved, even though they are not currently used. true, false, and null might seem like reserved, but they are actually literals (i.e., values like 0, 3.14, or ’a’); you cannot use them as identifiers in your programs either.

abstract continue for new switch
assert*** default goto* package synchronized
boolean do if private this
break double implements protected throw
byte else import public throws
case enum**** instanceof return transient
catch extends int short try
char final interface static void
class finally long strictfp** volatile
const* float native super while

(* not used; ** added in Java 1.2; *** added in Java 1.4; **** added in Java 5)

Conventions for Identifiers

The computer doesn’t care about the following rules, but your instructor and any other programmer (including you) that has to read your code will!

  • Variable names should start with a lowercase letter
  • Class names (which also have identifiers that follow the same syntactical guidelines should start with an uppercase letter
  • Meaningful names should be used
  • If an identifier is to be made up of more than one word, CamelCase should be used (e.g., “myLuckyNumber”)

The 8 Primitive Variable Types

Depending on the nature of the information one wishes to store in a variable, and -- in the case of numerical information -- depending the size and precision required, one can use any of the following eight primitive types in Java:

byte, short, int, long,float,double,char,boolean.

For the 6 numerical types, we have the following ranges, storage size, and encoding methods:

Name Range Storage Size (and Method)
byte ‐128 to 127
(i.e., ‐27 to 27 – 1)
8 bits (Two’s Complement)
short ‐32768 to 32767
(i.e., ‐215 to 215 – 1)
16 bits (Two’s Complement)
int ‐2147483648 to 2147483647
(i.e., ‐231 to 231 – 1)
32 bits (Two’s Complement)
long ‐9223372036854775808 to 9223372036854775807
(i.e., -263 to 263 – 1)
64 bits (Two’s Complement)
float Negative range: ‐3.4028235E+38 to ‐1.4E‐45
Positive range: 1.4E‐45 to 3.4028235E+38
32 bits (IEEE 754 Notation)
double Negative range: ‐1.7976931348623157E+308 to ‐4.9E‐324
Positive range: 4.9E‐324 to 1.7976931348623157E+308
64 bits (IEEE 754 Notation)

Note: float and double number types are stored in IEEE 754 format, and thus not stored with complete accuracy due to approximations. To convince yourself of this, try the following

System.out.println(1.0 - 0.1 - 0.1 - 0.1 - 0.1 - 0.1);


System.out.println(1.0 - 0.9);