Variables and Data Types

Picture a video game. While you play, the game has to keep track of how many coins you have collected (1250), how fast your character is moving (4.75 squares per second), and whether the game is paused (yes or no). These are three very different kinds of information. A coin count is always a whole number. A speed can have a fractional part. “Paused” is not a number at all; it is just yes or no.

The program has to know which kind each piece of information is, for two reasons. First, it has to know which values make sense: a coin count of 2.5 is nonsense, and so is a “paused” of 17. Second, it has to know what can be done with each one: adding 50 coins to your coin count makes sense, but “adding” two yes-or-no answers does not.

Think of an online order form. The “Number of tickets” box accepts only whole numbers, and the “I agree to the terms” checkbox can only be checked or unchecked. The form also knows what to do with each field: it can multiply the number of tickets by a price, but it never tries to do math with the checkbox. Java works the same way, with one difference: the form checks your input while you type, but Java checks the code in your program before it runs, using the compiler you met in Topic 1.1.

In Java, each kind of information is described by a data type: a set of values, together with the set of operations that can be done on those values. Both halves matter. Knowing a value’s data type tells you what it could possibly be and what you are allowed to do with it.

Now change one thing: a second program keeps track of a student’s ID number, such as 40213. The values look exactly like a coin count: whole numbers. But would you ever add two ID numbers together, or find the average ID in a class? No. The answer would be meaningless. Two pieces of information can have similar-looking values and still be used in completely different ways. That is why a data type is defined by its operations as well as its values.

Java has a lot of data types. A few are built right into the language for the simplest kinds of information: numbers and yes-or-no answers. Many more exist for bigger things, such as a piece of text, a picture, or the keyboard. Java sorts all of these into two categories, and knowing the category tells you a lot about how a type behaves.

In plain words: some types hold one simple value, like a single number. Everything else is for more complex things that bundle information together.

A primitive type is a data type built into the Java language that holds a simple value: a number or a true/false answer. A reference type is any data type that is not primitive. Reference types are used to define objects, which are bundles of related information that can also do things. You will learn exactly what objects are, and why these types have the name “reference,” in Topic 1.12. For now, you need to know that the category exists and how to recognize it.

The most common reference type is String, the type for text. The message "Good morning!" that you displayed in Topic 1.1 is a String. Text is not a number or a yes/no answer, so String is not primitive.

Now change one thing: imagine a program that stores a student’s full name, "Maya Ortiz". You might think “it’s just one name, so it’s simple.” But simple to a person is not the test. The test is whether the value is a number or true/false, and text is neither, so a name is stored with the reference type String.

You have seen the three primitive type names. Now you need to know exactly which values belong to each, because Java is strict: a value belongs to exactly one type, and Java decides which one by how the value is written.

Each primitive type matches one of the kinds of information from the game in 1.2.1:

• An int value is an integer: a whole number with no decimal point, such as 1250, 0, or -7.
• A double value is a real number: a number that can have a fractional part. In code it is written with a decimal point, such as 4.75, -0.5, or 3.0.
• A boolean value is either true or false. Those are the only two values, and they are written in lowercase with no quotation marks.

The names come from math and history. “Integer” is the math word for a whole number, and int is short for it. double is short for “double precision,” a way of storing real numbers. boolean is named after George Boole, a mathematician who studied true/false logic.

Java actually has eight primitive types. The other five (long, short, byte, float, and char) are not used in this course or on the AP exam, so you will only work with int, double, and boolean.

System.out.println(42);
System.out.println(3.14);
System.out.println(true);

42
3.14
true

Now change one thing: write the same amount two ways.

System.out.println(7);
System.out.println(7.0);

7
7.0

7 and 7.0 stand for the same amount, but they are different values to Java. 7 has no decimal point, so it is an int. 7.0 has a decimal point, so it is a double, even though its fractional part is zero. Java keeps track of the difference and displays each one in its own form. The decimal point, not the size of the fraction, decides the type.

Remember from 1.2.1 that a type also comes with operations. The two number types share the arithmetic operations: add, subtract, multiply, divide, and remainder (you will use them in Topic 1.3). boolean values have different operations, which you will use in Unit 2 to make decisions. Arithmetic is not one of them.

System.out.println(true + false);

error: bad operand types for binary operator '+'
  first type:  boolean
  second type: boolean

System.out.println(-15);
System.out.println(0.5);
System.out.println(15.0);
System.out.println(false);

-15
0.5
15.0
false

So far, every value has been written straight into a println statement and then forgotten. A real game cannot work that way. It has to remember the coin count, use it later, and update it when you collect more coins. A program needs a place to keep a value.

In plain words: picture a labeled box. The label is a name, so you can find the box again. The box is made for one kind of thing: a box for whole numbers, a box for true/false, and so on. Whatever value is inside is what the program “remembers.” The analogy has a limit: a real box can hold many things at once, but this box always holds exactly one value.

A variable is a storage location that holds a value. Every variable has a name and a data type. A variable of a primitive type holds one value from that type: an int variable holds an int value, and so on.

Before you can use a variable, you must declare it: write a statement that tells Java the variable’s type and name, so Java can set aside the storage. A variable declaration looks like this:

int coins;

Most of the time you also give the new variable a starting value in the same statement:

int coins = 1250;

The = stores the value on its right, 1250, in the new variable on its left. The = symbol is called the assignment operator; you will learn all of its rules in Topic 1.4. A variable declared with no starting value, like int coins;, cannot be used until it is given a value, which is also part of Topic 1.4.

Naming a variable

Java has rules for names, and programmers follow a few conventions on top of them:

• A name has no spaces. In this course, build names from letters and digits, starting with a letter. (Java allows a couple of other symbols too, but you will not need them.)
• A name cannot be a word Java already uses, such as int, double, or boolean.
• Names are case-sensitive: coins and Coins are two different names.
• By convention, a variable’s name starts with a lowercase letter, and each new word inside it starts with a capital: highScore, milesWalked. This style is called camel case, because the capitals stick up like a camel’s humps.
• Choose a name that says what the value means. coins tells a reader much more than c or x.

public class GameStats
{
    public static void main(String[] args)
    {
        int coins = 1250;
        double speed = 4.75;
        boolean paused = false;
        System.out.println(coins);
        System.out.println(speed);
        System.out.println(paused);
    }
}

1250
4.75
false

Now change one thing: store the same amount in an int variable and in a double variable.

int wholeLaps = 5;
double exactLaps = 5.0;
System.out.println(wholeLaps);
System.out.println(exactLaps);

5
5.0

Both variables hold “five,” but wholeLaps is an int variable holding the int value 5, and exactLaps is a double variable holding the double value 5.0. The variable’s type decides what kind of value lives inside, and the value is displayed in that type’s form. (In this chapter, a double variable always gets a value written with a decimal point. What Java does when you store a whole number in a double variable is part of Topic 1.5.)

coins = 1250;
System.out.println(coins);

error: cannot find symbol
  symbol:   variable coins

int high score = 980;
System.out.println(high score);

int highScore = 980;
System.out.println(highScore);

int books = 4;
double weight = 7.5;
boolean zipped = true;
System.out.println(weight);
System.out.println(books);
System.out.println(zipped);

7.5
4
true

The word “variable” means “able to vary.” In the game, the coin count is not stuck at 1250 forever; every coin you pick up changes it. That is the whole point of storing it in a variable rather than writing 1250 everywhere.

A variable’s value can change while the program is running. The box keeps its name and its type for the whole program; only the value inside changes. And because the box holds exactly one value, putting a new value in replaces the old one. The old value is gone.

To change a variable’s value, write its name, =, and the new value. There is no type in front this time, because the variable already exists. (This kind of statement is an assignment statement, taught fully in Topic 1.4.)

int coins = 1250;
System.out.println(coins);
coins = 1300;
System.out.println(coins);
coins = 40;
System.out.println(coins);

1250
1300
40

Now change one thing: use a boolean variable instead of a number.

boolean paused = false;
System.out.println(paused);
paused = true;
System.out.println(paused);

false
true

The rule does not depend on the type. paused starts as false, then line 3 replaces it with true. It is still a boolean variable, and it still holds one value at a time.

int coins = 1250;
int coins = 1300;
System.out.println(coins);

error: variable coins is already defined in method main(String[])

int lives = 3;
System.out.println(lives);
lives = 2;
lives = 5;
System.out.println(lives);
lives = 0;
System.out.println(lives);

3
5
0

You know that a variable’s value can change. Can it change to anything at all? What if a program tries to put 3.5 into an int variable?

Go back to 1.2.1: a data type is a set of values. An int variable promises that the value inside is always an integer, so the rest of the program can rely on that. If a decimal value could sneak in, the promise would be broken. So Java enforces a rule: a variable of a primitive type can hold only a value from its own type. Because the variable’s type is written in the code, the compiler can check every value you try to store before the program runs, just as it checks for missing semicolons.

int pizzaSlices = 3.5;
System.out.println(pizzaSlices);

error: incompatible types: possible lossy conversion from double to int

double pizzaEaten = 3.5;
System.out.println(pizzaEaten);

3.5

Now change one thing: put a number into a boolean variable.

boolean lightsOn = 1;
System.out.println(lightsOn);

error: incompatible types: int cannot be converted to boolean

1 is an int, and the only values in the boolean set are true and false. In Java, 1 does not mean “true.” The fix is boolean lightsOn = true;. Notice that the message is a little different from the pizza one (there is no “lossy” this time), but the first part, incompatible types, is the same: a value from one type cannot go into a variable of another.

boolean lightsOn = True;
System.out.println(lightsOn);

error: cannot find symbol
  symbol:   variable True

int seats = 30.0;
System.out.println(seats);

int seats = 30;

Every time you declare a variable, you must pick its type, and the compiler will hold you to that choice from then on. How do you decide? The type should fit every value the information could ever have, and no values it could never have.

Use the three primitive types and String from 1.2.2 to 1.2.3, and ask these questions in order:

1. Is the information a yes-or-no answer? Use boolean.
2. Is it a number that can only ever be whole, such as a count of things? Use int.
3. Is it a number that can have a fractional part, such as a measurement or a price? Use double.
4. Is it text, or anything else that is not a number or true/false? It needs a reference type, such as String for text.

Why not just use double for every number, since a double can hold 5.0 too? Because the type’s set of values is a safety net. If the number of students in a class is an int, then 24.5 students cannot be stored; the compiler would stop it, as you saw in 1.2.6. A well-chosen type makes impossible values impossible, and it tells anyone reading the code what kind of information the variable holds.

Now change one thing: the temperature. If the program is for a thermostat whose screen shows only whole degrees, and the setting can only be changed one degree at a time, then every possible value is a whole number and int fits. If the program is a weather station that measures 68.5°, it needs double. The same kind of information can need a different type, because what decides the type is the set of values the program must store.

A fitness app tracks a walker’s day. It needs three pieces of information: the number of steps taken, the miles walked, and whether the daily goal has been reached. Here is a program that stores them, displays some of them, updates them in the afternoon, and displays them again.

Choosing the types (1.2.3, 1.2.7). Steps are counted one at a time, so they are always whole: int. Miles can be fractional, like 1.9: double. “Goal reached?” is yes or no: boolean. All three are primitive types (1.2.2).

public class StepTracker
{
    public static void main(String[] args)
    {
        int steps = 4200;
        double milesWalked = 1.9;
        boolean goalReached = false;
        System.out.println(steps);
        System.out.println(goalReached);
        steps = 10350;
        milesWalked = 4.7;
        goalReached = true;
        System.out.println(steps);
        System.out.println(milesWalked);
        System.out.println(goalReached);
    }
}

Declaring (1.2.4). Lines 5 to 7 declare the three variables. Each declaration has the type, the name, and a starting value from that type: 4200 is an integer, 1.9 has a decimal point, and false is a boolean value. All three names use camel case.

Changing values (1.2.5). Lines 10 to 12 store new values. They have no type in front, because the variables already exist. Each new value matches its variable’s type (1.2.6), so the program compiles.

The complete output:

4200
false
10350
4.7
true

milesWalked held 1.9 at first, but it was never displayed before line 11 replaced it, so 1.9 never appears in the output. And if line 10 had been steps = 10350.5;, the compiler would have reported incompatible types: possible lossy conversion from double to int, just like the pizza example in 1.2.6, and the program would not have run at all.

• A data type is a set of values plus the operations that work on them. Two kinds of information can look alike and still need different types because of what you do with them.
• Every type is either primitive (built in; simple number or true/false values) or reference (everything else, used for objects, such as String).
• This course uses three primitive types: int for integers, double for real numbers written with a decimal point, and boolean for true or false. Java’s other five primitive types are not part of the course.
• A variable is a named storage location with a type. You declare it once, with its type and name. Its value can change while the program runs, but it holds one value at a time.
• A variable holds only values of its own type, and the compiler enforces this. Choose the type whose values match every value the information could ever have.

double roomTemp = 68.5;
int fanSpeed = 2;
boolean heatOn = false;
System.out.println(roomTemp);
roomTemp = 70.0;
heatOn = true;
fanSpeed = 3;
System.out.println(fanSpeed);
System.out.println(roomTemp);
System.out.println(heatOn);

68.5
3
70.0
true

public class Concert
{
    public static void main(String[] args)
    {
        int ticketsSold = 212;
        double ticketPrice = 15.5;
        boolean soldOut = 0;
        int ticketsSold = 250;
        System.out.println(ticketsSold);
        System.out.println(soldOut);
    }
}

boolean soldOut = false;
ticketsSold = 250;

Check each statement. If the answer is “not yet,” reread the linked subsection.

• I can explain that a data type is a set of values plus the operations on them. Reread
• I can tell whether a type is primitive or reference, and say why String is a reference type. Reread
• I can name the three primitive types in this course and tell which type a value like 7, 7.0, or true has. Reread
• I can declare a variable with a type and a meaningful camel-case name. Reread
• I can trace a variable whose value changes, knowing it holds one value at a time. Reread
• I can explain why a value of the wrong type cannot be stored in a variable, and read the compiler message. Reread
• I can choose the most appropriate data type for a piece of information. Reread