Assignment Statements and Input

In Topic 1.2 you declared variables: int tickets; sets aside a storage location named tickets that can hold one int. But a declaration only creates the box. It does not put anything in it, and a program that tracks tickets, scores, or prices needs to store values there and change them as things happen. A movie theater’s program must record that you bought 3 tickets, then record 8 when your friends join.

The tool for that is a statement that says “put this value into that variable.” An assignment statement stores a value in a variable. It uses the assignment operator, the single equals sign =. The variable goes on the left, the value goes on the right, and the statement ends with a semicolon:

tickets = 3;

Read it as “tickets gets 3” or “store 3 in tickets,” not as “tickets equals 3.” That wording matters. In math, = states a fact that is always true. In Java, = is an action that happens once, at the moment that line runs.

The first time a variable is assigned a value, the variable is initialized. You can initialize a variable on a later line, as above, or in the declaration itself, as in int lives = 3;. Any assignment after that changes the value: the new value replaces the old one, and the old one is gone. A variable holds exactly one value at a time.

int tickets;
tickets = 3;
System.out.println(tickets);
tickets = 8;
System.out.println(tickets);

3
8

Now change one thing: initialize the variable in its declaration instead of on its own line.

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

3
2

Line 1 declares lives and initializes it to 3 in one statement. Line 3 is an ordinary assignment with no type in front, because lives already exists. Writing the type only belongs in the declaration; the type tells Java to create a new variable, and you create each variable once.

int score = 0;
10 = score;

error: unexpected type
  required: variable
  found:    value

int laps = 2;
laps = 6;
laps = 4;
System.out.println(laps);

int highScore = 0;
100 = highScore;
System.out.println(highScore);

So far the right side of every assignment has been a single number. But programs usually need to compute the new value, often from the variable’s own current value. A game adds 5 points to a score; a store multiplies a price by a quantity. In Topic 1.3 you wrote arithmetic expressions such as 4 * 3 and printed their results. Now you can store those results.

An expression is any piece of code that produces a value: a literal such as 5, a variable such as points, or a combination of them with operators, such as points + 5. When an expression is evaluated, it produces one single value. That is exactly what an assignment needs.

Java carries out every assignment in two steps, always in this order:

1. Evaluate the whole expression on the right, using the values the variables hold right now, to get one value.
2. Store that value in the variable on the left.

Because the right side is finished before anything is stored, a variable can appear on both sides. The right side uses the old value, and only then does the new value replace it.

int points = 10;
points = points + 5;
System.out.println(points);

15

Now vary the right side so it is a different variable. When the expression is just a variable, its value is copied into the variable on the left. After that, the two variables are separate boxes that happen to hold the same number.

int monday = 12;
int tuesday = monday;
monday = 20;
System.out.println(monday);
System.out.println(tuesday);

20
12

Line 3 changes only monday. Line 2 copied the value 12 into tuesday; it did not link the two variables, so tuesday keeps 12.

int price = 4;
int quantity = 3;
int total = price * quantity;
quantity = 5;
System.out.println(total);

12

int price = 4;
int quantity = 3;
int total = price * quantity;
quantity = 5;
total = price * quantity;
System.out.println(total);

20

int home = 5;
int away = home;
home = home + 3;
away = away * 2;
System.out.println(home);
System.out.println(away);

8
10

int width = 4;
int area = width * 3;
width = 10;
System.out.println(area);

Every variable has a type, chosen when it is declared. Every value has a type too. So when an assignment stores the value of an expression, Java has to know: is that value an int, a double, or a boolean? And does it fit the variable?

The answer is that the value of an expression has a type, and that type comes from how the expression is evaluated. You already know the rules from Topic 1.3. An operation on two int values produces an int; an operation with at least one double produces a double. Java applies those rules one operation at a time, following the order of operations, and the type of the last operation’s result is the type of the whole expression.

The value you store must come from a compatible type: one the variable’s type accepts. An int variable accepts int values, a double variable accepts double values, and a boolean variable accepts true or false. (Topic 1.5 shows a few cases where Java converts a value from one type to another for you.) Why is Java strict about this? Because a variable’s type decides how much memory it uses and what it can hold. An int variable has no place to keep the .33 of 84.33, so Java will not silently throw it away.

int total = 85 + 90 + 78;
double average = total / 3.0;
int roughAverage = total / 3;
System.out.println(total);
System.out.println(average);
System.out.println(roughAverage);

253
84.33333333333333
84

The type comes from the operations, not from how the answer looks. 10 / 4 * 2.0 ends up as 4.0, a double, even though 4 is a whole number: 10 / 4 is the int 2, and then 2 * 2.0 involves a double, so the result is the double 4.0.

int total = 253;
int average = total / 3.0;

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

int half = 9 / 2.0;
System.out.println(half);

A declaration creates a variable with no value in it. What should happen if a program tries to use that variable before anything has been stored there? Back in 1.4.1, the trace table showed (nothing) for a variable that was only declared. An expression cannot compute 50 + nothing.

Java’s rule: every variable must be assigned a value before it is used in an expression. The compiler checks this before the program ever runs. It looks at each place a variable is used and asks: on every path to this line, has the variable already been assigned? If not, it refuses to compile.

Why not just use 0? Because 0 might be wrong. A bonus of 0, a price of 0, a temperature of 0: each is a real value that would quietly produce a believable but wrong answer, a logic error that is hard to find. A compile error forces you to decide what the starting value should be.

int steps;
steps = 4000;
int goal = steps + 1000;
System.out.println(goal);

5000

Now remove the assignment and see what changes:

int bonus;
int total = 50 + bonus;
System.out.println(total);

This does not compile. Java reports something like:

error: variable bonus might not have been initialized

Line 2 uses bonus in the expression 50 + bonus, but no line before it ever stored a value in bonus. The fix is to initialize it first, for example int bonus = 0;, if 0 really is the bonus you mean.

Everything so far has used primitive types: int, double, and boolean. Recall from Topic 1.2 that any other type is a reference type, and that reference types are used for objects, bundles of related information such as a piece of text. String, the type for text such as "Ada", is a reference type. A variable of a reference type does not hold a number or true/false. It is connected to an object. Topics 1.12 and 1.13 explain objects and that connection in detail. For this chapter, two facts are enough: a reference variable can be assigned an object (you have already seen string literals, and in 1.4.6 you will create a new object for reading input), or it can be assigned the special value null.

Why would you need a special value? Sometimes a program needs a reference variable before it has anything to connect it to. A sign-up form asks for a nickname, but a player may not have one yet. The program must still initialize the variable (1.4.4), and it should say clearly “no nickname yet” rather than invent one.

The literal null is a special value meaning that a reference variable is not connected to any object. Like 3 or true, it is a literal: a fixed value written directly in the code. It is not text, so it has no double quotes.

String nickname = null;
System.out.println(nickname);
nickname = "Ace";
System.out.println(nickname);

null
Ace

Now vary the type. null belongs only to reference types. A primitive variable always holds an actual number or true/false, so “no object” makes no sense for it:

int age = null;

This does not compile. Java reports something like:

error: incompatible types: <null> cannot be converted to int

This is the compatible-type rule from 1.4.3 again: null is not a value an int can hold. If you need “no age entered yet” for an int, pick a real starting value, such as 0, and be clear about what it means.

String team = null;
System.out.println(team);
team = "Hawks";
System.out.println(team);
team = null;
System.out.println(team);

null
Hawks
null

Every program so far has had its values written into the code. The quiz scores, the ticket counts, the nickname: to change any of them, you would have to edit the program and run it again. Real programs take in information while they run. Input is data a program receives from outside itself.

Input comes in many forms:

This course works with text input. In Java, one way to get text that the user types on the keyboard is the Scanner class: a ready-made part of Java whose job is reading text and turning it into values your program can store. (Exactly what kind of input a particular program accepts is up to its designer, and the AP exam does not test any particular one; you will use Scanner in class programs and again in Topics 1.13 and 1.14.)

Here is a complete program that asks for the user’s age and stores it:

import java.util.Scanner;

public class AgeFromKeyboard
{
    public static void main(String[] args)
    {
        Scanner input = new Scanner(System.in);
        System.out.print("How old are you? ");
        int age = input.nextInt();
        System.out.print("Age: ");
        System.out.println(age);
    }
}

Take it apart one new piece at a time:

Two pieces use ideas taught later. new Scanner(System.in) creates an object, which Topic 1.13 explains fully; for now, use this line as a pattern whenever you need keyboard input. input.nextInt() asks the Scanner named input for its next whole number; Topic 1.14 explains this kind of call, so for now read it as “ask input for the next whole number.” Notice that int age = input.nextInt(); is still an ordinary assignment from 1.4.2: the right side produces one int value, and it is stored in age.

A program that waits for typing gives different output every time it runs, depending on what someone types. To make examples you can trace exactly, this guide gives the Scanner its input as a string instead of the keyboard: new Scanner("16") reads from the text 16 exactly as if a user had typed it. Everything else, including nextInt(), works the same way.

import java.util.Scanner;

public class AgeFromText
{
    public static void main(String[] args)
    {
        Scanner input = new Scanner("16");
        int age = input.nextInt();
        System.out.print("Age: ");
        System.out.println(age);
    }
}

Age: 16

public class NoImport
{
    public static void main(String[] args)
    {
        Scanner input = new Scanner("16");
        int age = input.nextInt();
        System.out.println(age);
    }
}

error: cannot find symbol
  symbol:   class Scanner

Most programs need more than one input, and not all of them are whole numbers. An order form needs a customer’s name (text), a quantity (a whole number), and a price (a decimal). A Scanner has a different reading call for each type, and each call produces one value you can assign to a variable of that type.

Picture the input as a line of text with a marker showing where the Scanner will read next. Every read takes the next piece from the marker onward, and the marker moves past it. Pieces are separated by spaces or line breaks.

nextInt() and nextDouble() skip over any spaces or line breaks before their piece. nextLine() returns the rest of the line without the line break itself, and moves the marker to the start of the next line.

import java.util.Scanner;

public class OrderReader
{
    public static void main(String[] args)
    {
        Scanner input = new Scanner("Ada Lovelace\n3 2.5");
        String customer = input.nextLine();
        int quantity = input.nextInt();
        double price = input.nextDouble();
        double cost = quantity * price;
        System.out.println(customer);
        System.out.print("Cost: ");
        System.out.println(cost);
    }
}

Ada Lovelace
Cost: 7.5

Now change only the input text, spreading the numbers over extra lines and spaces:

import java.util.Scanner;

public class OrderReaderLines
{
    public static void main(String[] args)
    {
        Scanner input = new Scanner("Ada Lovelace\n3\n\n   2.5");
        String customer = input.nextLine();
        int quantity = input.nextInt();
        double price = input.nextDouble();
        double cost = quantity * price;
        System.out.println(customer);
        System.out.print("Cost: ");
        System.out.println(cost);
    }
}

Ada Lovelace
Cost: 7.5

The output is identical. nextInt() and nextDouble() skip the line breaks and spaces to find their pieces, so what matters is the order of the pieces, not how they are spaced. The order of the reading calls must match the order of the input.

import java.util.Scanner;

public class WrongInput
{
    public static void main(String[] args)
    {
        Scanner input = new Scanner("three 2.5");
        System.out.println("Reading the quantity...");
        int quantity = input.nextInt();
        System.out.println(quantity);
    }
}

Reading the quantity...
Exception in thread "main" java.util.InputMismatchException

import java.util.Scanner;

public class ReadsInOrder
{
    public static void main(String[] args)
    {
        Scanner input = new Scanner("8 2.5 6");
        int first = input.nextInt();
        double second = input.nextDouble();
        int third = input.nextInt();
        int sum = first + third;
        System.out.println(sum);
        System.out.println(second);
    }
}

14
2.5

This program estimates the fuel cost of a trip. It reads the trip’s name, the distance in miles, the car’s miles per gallon, and the price of one gallon, then computes the cost.

import java.util.Scanner;

public class TripCost
{
    public static void main(String[] args)
    {
        Scanner input = new Scanner("Beach day\n240 30\n3.5");
        String tripName = input.nextLine();
        int miles = input.nextInt();
        int milesPerGallon = input.nextInt();
        double pricePerGallon = input.nextDouble();
        int gallons = miles / milesPerGallon;
        double cost = gallons * pricePerGallon;
        System.out.println(tripName);
        System.out.print("Gallons: ");
        System.out.println(gallons);
        System.out.print("Cost: ");
        System.out.println(cost);
        miles = miles + 60;
        System.out.print("Gallons still stored: ");
        System.out.println(gallons);
    }
}

First, the reads (the ▸ marks where input will read next):

Then the computations. For each right side, evaluate first, check the type, then store:

Lines 14 to 18 print the name and the two results. Line 19 changes miles, but line 12 ran long before and stored the single value 8 in gallons, so lines 20 and 21 still print 8:

Beach day
Gallons: 8
Cost: 28.0
Gallons still stored: 8

Every idea from the chapter appears. The Scanner is a new object assigned to a reference variable and needs the import on line 1. Each reading call produces one value of its type, stored with an ordinary assignment, and the calls read in order. Each right side is evaluated to one value whose type must be compatible with its variable: cost must be a double because gallons * pricePerGallon is a double. Every variable is initialized before it is used. And an assignment stores a value, not a formula, so changing miles does not change gallons.

The compiler messages from this chapter, collected for quick lookup. Wording can vary slightly between Java versions.

• An assignment statement uses = to store the value on its right in the variable on its left. The first assignment initializes the variable; later ones replace its value.
• Java evaluates the whole right side to one value first, using the variables’ current values, then stores it. The variable holds that value, not a formula, so later changes to other variables do not update it.
• Every expression’s value has a type that comes from its operations. That value can be stored only in a variable of a compatible type, and a variable must be initialized before it is used in an expression.
• A reference variable, such as a String, can be assigned an object or null, which means “no object.” Primitive variables cannot hold null.
• Input can be tactile, audio, visual, or text. A Scanner (imported from java.util) reads text, from the keyboard with System.in or from a string, and its nextInt, nextDouble, and nextLine calls read the input in order.

double result = 11 / 4 * 2.0 + 1;
System.out.println(result);

int first = 5;
int second = 9;
first = second;
second = first;
first = first + 1;
System.out.println(first);
System.out.println(second);

10
9

String motto;
System.out.println(motto);

String motto = null;
System.out.println(motto);

import java.util.Scanner;

public class QuizScores
{
    public static void main(String[] args)
    {
        Scanner input = new Scanner("Unit 1 quiz\n17 20");
        String quizName = input.nextLine();
        int myScore = input.nextInt();
        int maxPoints = input.nextInt();
        int bonus = null;
        int percent = (myScore + bonus) * 100.0 / maxPoints;
        System.out.println(quizName);
        System.out.println(percent);
    }
}

import java.util.Scanner;

public class QuizScoresFixed
{
    public static void main(String[] args)
    {
        Scanner input = new Scanner("Unit 1 quiz\n17 20");
        String quizName = input.nextLine();
        int myScore = input.nextInt();
        int maxPoints = input.nextInt();
        int bonus = 0;
        double percent = (myScore + bonus) * 100.0 / maxPoints;
        System.out.println(quizName);
        System.out.println(percent);
    }
}

Unit 1 quiz
85.0

import java.util.Scanner;

public class MovingBoxes
{
    public static void main(String[] args)
    {
        Scanner input = new Scanner("Maple Street\n14 4 2.5");
        String street = input.nextLine();
        int boxes = input.nextInt();
        int helpers = input.nextInt();
        double poundsPerBox = input.nextDouble();
        int boxesEach = boxes / helpers;
        int leftOver = boxes % helpers;
        double totalPounds = boxes * poundsPerBox;
        System.out.println(street);
        System.out.println(boxesEach);
        System.out.println(leftOver);
        System.out.println(totalPounds);
    }
}

Maple Street
3
2
35.0

import java.util.Scanner;

public class HalfInput
{
    public static void main(String[] args)
    {
        Scanner input = new Scanner("4.5");
        int hours = input.nextInt();
        System.out.println(hours);
    }
}

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

• I can use = to initialize a variable or change its value, and say what it holds afterward. Reread
• I can explain why the right side is evaluated before anything is stored, and why an assignment is not a formula. Reread
• I can find the type of an expression and decide whether it can be stored in a variable. Reread
• I can explain why a variable must be initialized before it is used in an expression. Reread
• I can explain what null means and which variables can hold it. Reread
• I can name forms of input and set up a Scanner, including its import line. Reread
• I can trace nextInt, nextDouble, and nextLine reading input in order. Reread