Reading whole numbers from the keyboard

What a life! Yesterday there were four kids in my living room, and I had 30 gumballs. Today there are six kids in my house, and I have 80 gumballs. How can I cope with all this change? I know! I’ll write a program that reads the numbers of gumballs and kids from the keyboard. The program is in Listing 7-2, and a run of the program is shown in Figure 7-2.

LISTING 7-2 A More Versatile Program for Kids and Gumballs

import java.util.Scanner;

class KeepingMoreKidsQuiet {

public static void main(String args[]) {
Scanner keyboard = new Scanner(System.in);
int gumballs;
int kids;
int gumballsPerKid;

System.out.print("How many gumballs? How many kids? ");
gumballs = keyboard.nextInt();
kids = keyboard.nextInt();

gumballsPerKid = gumballs / kids;
System.out.print("Each kid gets ");
System.out.print(gumballsPerKid);
System.out.println(" gumballs.");

keyboard.close();
}
}

You should notice a couple of things about Listing 7-2. First, you can read an int value with the nextInt method. (Refer to the table in Chapter 5.) Second, you can issue successive calls to Scanner methods. In Listing 7-2, I call nextInt twice. All I have to do is separate the numbers I type by blank spaces. In Figure 7-2, I put one blank space between my 80 and my 6, but more blank spaces would work as well.

This blank-space rule applies to many of the Scanner methods. For example, here’s some code that reads three numeric values:

gumballs = keyboard.nextInt();
costOfGumballs = keyboard.nextDouble();
kids = keyboard.nextInt();

Figure 7-3 shows valid input for these three method calls.

What you read is what you get

When you’re writing your own code, you should never take anything for granted. Suppose that you accidentally reverse the order of the gumballs and kids assignment statements in Listing 7-2:

//This code is misleading:
System.out.print("How many gumballs? How many kids? ");

kids = keyboard.nextInt();
gumballs = keyboard.nextInt();

Here, the line How many gumballs? How many kids? is misleading. Because the kids assignment statement comes before the gumballs assignment statement, the first number you type becomes the value of kids, and the second number you type becomes the value of gumballs. It doesn’t matter that your program displays the message How many gumballs? How many kids?. What matters is the order of the assignment statements in the program.

If the kids assignment statement accidentally comes first, you can get a strange answer, like the zero answer in Figure 7-4. That’s how int division works. It just cuts off any remainder. Divide a small number (like 6) by a big number (like 80), and you get 0.

Like the mad scientist in an old horror movie, try these fascinating experiments!

Finding a remainder

There’s a useful arithmetic operator called the remainder operator. The symbol for the remainder operator is the percent sign (%). When you put System.out.println(11 % 4) in your program, the computer prints 3. It does so because 4 goes into 11 who-cares-how-many times, with a remainder of 3.

Another name for the remainder operator is the modulus operator.

The remainder operator turns out to be fairly useful. After all, a remainder is the amount you have left over after you divide two numbers. What if you’re making change for $1.38? After dividing 138 by 25, you have 13 cents left over, as shown in Figure 7-5.

The code in Listing 7-3 makes use of this remainder idea.

LISTING 7-3 Making Change

import java.util.Scanner;

class MakeChange {

public static void main(String args[]) {
Scanner keyboard = new Scanner(System.in);
int quarters, dimes, nickels, cents;
int whatsLeft, total;

System.out.print("How many cents do you have? ");
total = keyboard.nextInt();

quarters = total / 25;
whatsLeft = total % 25;

dimes = whatsLeft / 10;
whatsLeft = whatsLeft % 10;

nickels = whatsLeft / 5;
whatsLeft = whatsLeft % 5;

cents = whatsLeft;

System.out.println();
System.out.println("From " + total + " cents you get");
System.out.println(quarters + " quarters");
System.out.println(dimes + " dimes");
System.out.println(nickels + " nickels");
System.out.println(cents + " cents");

keyboard.close();
}
}

A run of the code in Listing 7-3 is shown in Figure 7-6. You start with a total of 138 cents. The statement

quarters = total / 25;

divides 138 by 25, giving 5. That means you can make 5 quarters from 138 cents. Next, the statement

whatsLeft = total % 25;

divides 138 by 25 again, and puts only the remainder, 13, into whatsLeft. Now you’re ready for the next step, which is to take as many dimes as you can out of 13 cents.

You keep going like this until you’ve divided away all the nickels. At that point, the value of whatsLeft is just 3 (meaning 3 cents).

The code in Listing 7-3 makes change in U.S. currency with the following coin denominations: 1 cent, 5 cents (one nickel), 10 cents (one dime), and 25 cents (one quarter). With these denominations, the MakeChange program gives you more than simply a set of coins adding up to 138 cents. The MakeChange class gives you the smallest number of coins that add up to 138 cents. With some minor tweaking, you can make the code work in any country’s coinage. You can always get a set of coins adding up to a total. But, for the denominations of coins in some countries, you won’t always get the smallest number of coins that add up to a total. In fact, I’m looking for examples. If your country’s coinage prevents MakeChange from always giving the best answer, please, send me an email ([email protected]), tweet to @allmycode, or post on Facebook at /allmycode. Thanks.

When two or more variables have similar types, you can create the variables with combined declarations. For example, Listing 7-3 has two combined declarations — one for the variables quarters, dimes, nickels, and cents (all of type int); another for the variables whatsLeft and total (both of type int). But to create variables of different types, you need separate declarations. For example, to create an int variable named total and a double variable named amount, you need one declaration int total; and another declaration double amount;.

Listing 7-3 has a call to System.out.println() with nothing in the parentheses. When the computer executes this statement, the cursor jumps to a new line on the screen. (I often use this statement to put a blank line in a program’s output.)

The increment and decrement operators

Java has some neat little operators that make life easier (for the computer’s processor, for your brain, and for your fingers). Altogether, there are four such operators — two increment operators and two decrement operators. The increment operators add one, and the decrement operators subtract one. To see how they work, you need some examples.

Using preincrement

The first example is in Figure 7-7.

A run of the program in Figure 7-7 is shown in Figure 7-8. In this horribly uneventful run, the count of gumballs is displayed three times.

The double plus sign goes under two different names, depending on where you put it. When you put the ++ before a variable, the ++ is called the preincrement operator. In the word preincrement, the pre stands for before. In this setting, the word before has two different meanings:

• You’re putting ++ before the variable.
• The computer adds 1 to the variable’s value before the variable is used in any other part of the statement.

Figure 7-9 has a slow-motion, instant replay of the preincrement operator’s action. In Figure 7-9, the computer encounters the System.out.println(++gumballs) statement. First, the computer adds 1 to gumballs (raising the value of gumballs to 29). Then the computer executes System.out.println, using the new value of gumballs (29).

Using postincrement

An alternative to preincrement is postincrement. With postincrement, the post stands for after. The word after has two different meanings:

• You put ++ after the variable.
• The computer adds 1 to the variable’s value after the variable is used in any other part of the statement.

Figure 7-10 shows a close-up view of the postincrement operator’s action. In Figure 7-10, the computer encounters the System.out.println(gumballs++) statement. First, the computer executes System.out.println, using the old value of gumballs (28). Then the computer adds 1 to gumballs (raising the value of gumballs to 29).

Look at the bold line of code in Figure 7-11. The computer prints the old value of gumballs (28) on the screen. Only after printing this old value does the computer add 1 to gumballs (raising the gumballs value from 28 to 29).

With System.out.println(gumballs++), the computer adds 1 to gumballs after printing the old value that gumballs already had.

A run of the code in Figure 7-11 is shown in Figure 7-12. Compare Figure 7-12 with the run in Figure 7-8.

• With preincrement in Figure 7-8, the second number that’s displayed is 29.

• With postincrement in Figure 7-12, the second number that’s displayed is 28.

  In Figure 7-12, the number 29 doesn’t show up on the screen until the end of the run, when the computer executes one last System.out.println(gumballs).

Are you trying to decide between using preincrement or postincrement? Ponder no longer. Most programmers use postincrement. In a typical Java program, you often see things like gumballs++. You seldom see things like ++gumballs.

In addition to preincrement and postincrement, Java has two operators that use --. These operators are called predecrement and postdecrement:

• With predecrement (--gumballs), the computer subtracts 1 from the variable’s value before the variable is used in the rest of the statement.
• With postdecrement (gumballs--), the computer subtracts 1 from the variable’s value after the variable is used in the rest of the statement.

EXPLORE PREINCREMENT AND POSTINCREMENT USING JSHELL

Type the boldface text, one line after another, into JShell, and see how JShell responds:

jshell> int i = 8

jshell> i++

jshell> i

jshell> i

jshell> i++

jshell> i

jshell> ++i

jshell> i

EXPLORE PREINCREMENT AND POSTINCREMENT IN A JAVA PROGRAM

Before you run the following code, try to predict what the code’s output will be. Then run the code to find out whether your prediction is correct:

public class Main {

public static void main(String[] args) {
int i = 10;
System.out.println(i++);
System.out.println(--i);
--i;
i--;
System.out.println(i);
System.out.println(++i);
System.out.println(i--);
System.out.println(i);
}
}

Assignment operators

If you’ve read the previous section — the section about operators that add 1 — you may be wondering whether you can manipulate these operators to add 2, or add 5, or add 1000000. Can you write gumballs++++ and still call yourself a Java programmer? Well, you can’t. If you try it, Eclipse will give you an error message:

Invalid argument to operation ++/--

If you don’t use Eclipse, you may see a different error message:

unexpected type
required: variable
found : value
gumballs++++;
^

Eclipse or no Eclipse, the bottom line is the same: Namely, your code contains an error, and you have to fix it.

How can you add values other than 1? As luck would have it, Java has plenty of assignment operators you can use. With an assignment operator, you can add, subtract, multiply, or divide by anything you want. You can do other cool operations, too.

For example, you can add 1 to the kids variable by writing

kids += 1;

Is this better than kids++ or kids = kids + 1? No, it’s not better. It’s just an alternative. But you can add 5 to the kids variable by writing

kids += 5;

You can’t easily add 5 with preincrement or postincrement. And what if the kids get stuck in an evil scientist’s cloning machine? The statement

kids *= 2;

multiplies the number of kids by 2.

With the assignment operators, you can add, subtract, multiply, or divide a variable by any number. The number doesn’t have to be a literal. You can use a number-valued expression on the right side of the equal sign:

double amount = 5.95;
double shippingAndHandling = 25.00, discount = 0.15;
amount += shippingAndHandling;
amount -= discount * 2;

The preceding code adds 25.00 (shippingAndHandling) to the value of amount. Then the code subtracts 0.30 (discount * 2) from the value of amount. How generous!

If the word literal doesn’t ring any bells for you, refer to Chapter 4.