The anatomy of a for statement

A typical for statement looks like this:

for (Initialization; Condition; Update) {
Statements
}

After the word for, you put three things in parentheses: an initialization, a condition, and an update.

Each of the three items in parentheses plays its own, distinct role:

• Initialization: The initialization is executed once, when the run of your program first reaches the for statement.
• Condition: The condition is tested several times (at the start of each iteration).
• Update: The update is also evaluated several times (at the end of each iteration).

If it helps, think of the loop as though its text is shifted all around:

//This is NOT real code
int count = 0
for count < 0 {
out.print("I’ve chewed ");
out.print(count);
out.println(" time(s).");
count++;
}

You can’t write a real for statement this way. (The compiler would throw code like this right into the garbage can.) Even so, this is the order in which the parts of the for statement are executed.

The first line of a for statement (the word for followed by stuff in parentheses) isn’t a complete statement. So you almost never put a semicolon after the stuff in parentheses. If you make a mistake and type a semicolon, like this:

// DON’T DO THIS:
for (int count = 0; count < 10; count++) ; {

you usually put the computer into a do-nothing loop. The computer counts to itself from 0 to 9. After counting, the computer executes whatever statements come immediately after the open curly brace. (The loop ends at the semicolon, so the statements after the open curly brace aren’t inside the loop.)

Initializing a for loop

Look at the first line of the for loop in Listing 15-1 and notice the declaration int count = 0. That’s something new. When you create a for loop, you can declare a variable (like count) as part of the loop initialization.

If you declare a variable in the initialization of a for loop, you can’t use that variable outside the loop. For example, in Listing 15-1, try putting out.println(count) after the end of the loop:

//This code does not compile.
for (int count = 0; count < 10; count++) {
out.print("I’ve chewed ");
out.print(count);
out.println(" time(s).");
}

out.print(count); //The count variable doesn’t exist here.

With this extra reference to the count variable, the compiler gives you an error message. You can see the message in Figure 15-3. If you’re not experienced with for statements, the message may surprise you — “Whadaya mean ‘count cannot be resolved to a variable’? There’s a count variable declaration just four lines above that statement.” Ah, yes. But the count variable is declared in the for loop’s initialization. Outside the for loop, that count variable doesn’t exist.

To use a variable outside of a for statement, you have to declare that variable outside the for statement. You can even do this with the for statement’s counting variable. Listing 15-2 has an example.

LISTING 15-2 Using a Variable Declared Outside of a for Loop

import static java.lang.System.out;

class AuntEdnaDoesItAgain {

public static void main(String args[]) {
int count;

for (count = 0; count < 10; count++) {
out.print("I’ve chewed ");
out.print(count);
out.println(" time(s).");
}

out.print(count);
out.println(" times! Hooray!");
out.println("I can swallow!");
}
}

A run of the code in Listing 15-2 looks exactly like the run for Listing 15-1. The run is pictured in Figure 15-1. Unlike its predecessor, Listing 15-2 enjoys the luxury of using the count variable to display the number 10. It can do this because in Listing 15-2, the count variable belongs to the entire main method and not to the for loop alone.

Notice the words for (count = 0 in Listing 15-2. Because count is declared before the for statement, you don’t declare count again in the for statement’s initialization. I tried declaring count twice, as in the following code:

//This does NOT work:
int count;

for (int count = 0; count < 10; count++) {
… etc.

And Eclipse told me to clean up my act:

Duplicate local variable count ^

Getting a trustworthy response

Consider a program that deletes a file. Before deleting the file, the program asks for confirmation from the user. If the user types Y, delete; if the user types N, don’t delete. Of course, deleting a file is serious stuff. Mistaking a bad keystroke for a “yes” answer can delete the company’s records. (And mistaking a bad keystroke for a “no” answer can preserve the company’s incriminating evidence.) If there’s any doubt about the user’s response, the program should ask the user to respond again.

Pause a moment to think about the flow of actions — what should and shouldn’t happen when the computer executes the loop. A loop of this kind doesn’t need to check anything before getting the user’s first response. Indeed, before the user gives the first response, the loop has nothing to check. The loop shouldn’t start with “as long as the user’s response is invalid, get another response from the user.” Instead, the loop should just leap ahead, get a response from the user, and then check the response to see whether it made sense. The code to do all of this is in Listing 15-4.

LISTING 15-4 Repeat Before You Delete

/*
* DISCLAIMER: Neither the author nor John Wiley & Sons,
* Inc., nor anyone else even remotely connected with the
* creation of this book, assumes any responsibility
* for any damage of any kind due to the use of this code,
* or the use of any work derived from this code,
* including any work created partially or in full by
* the reader.
*
* Sign here:_______________________________
*/

import java.io.File;
import java.util.Scanner;

class IHopeYouKnowWhatYoureDoing {

public static void main(String args[]) {

Scanner keyboard = new Scanner(System.in);
char reply;

do {

System.out.print("Reply with Y or N…");
System.out.print(" Delete the importantData file? ");
reply = keyboard.findWithinHorizon(".", 0).charAt(0);

} while (reply != ’Y’ && reply != ’N’);

if (reply == ’Y’) {
new File("importantData.txt").delete();
System.out.println("Deleted!");
} else {
System.out.println("No harm in asking!");
}

keyboard.close();
}
}

Deleting a file

A run of the Listing 15-4 program is shown in Figure 15-6. Before deleting a file, the program asks the user whether it’s okay to do the deletion. If the user gives one of the two expected answers (Y or N), the program proceeds according to the user’s wishes. But if the user enters any other letter (or any digit, punctuation symbol, or whatever), the program asks the user for another response.

In Figure 15-6, the user hems and haws for a while, first with the letter U, and then with the digit 8, and then with lowercase letters. Finally, the user enters Y, and the program deletes the importantData.txt file. If you compare the files on your hard drive (before and after the run of the program), you’ll see that the program trashes the file named importantData.txt.

If you use Eclipse, here’s how you can tell that a file is being deleted:

1. Create a Java project containing the code in Listing 15-4.

   If you followed the steps in Chapter 2 for importing this book’s examples, you can skip this create-a-project step and use the existing 15-04 project.

2. In the Package Explorer, select the project.

   Don’t select any of the project’s subfolders. (For example, don’t select the project’s src folder.) Instead, select the project’s root. For more info about a project’s root, see Chapter 13.

3. In Eclipse’s main menu, choose File ⇒ New ⇒ File.

   Eclipse’s New File dialog box appears.

   In the New File dialog box, make sure that the name of your project’s root folder is in the box’s Enter or Select the Parent Folder field. For example, if you followed the steps in Chapter 2 for importing this book’s examples, make sure that 15-04 (and no other text) appears in the Enter or Select the Parent Folder field.

4. In the dialog box’s File Name field, type the name of your new file.

   Type importantData.txt.

5. Click Finish.

6. Observe that the file’s name appears in Eclipse’s Package Explorer.

   The name is in the 15-04 project’s root directory. You put it in the root directory because, in Listing 15-4, the name importantData.txt (with no slashes or backslashes) refers only to a name in the project’s root directory. The program’s run has no effect on any files outside of the root directory, even if any of those files has the name importantData.txt.

   To find out how to refer to files outside of the project’s root directory, refer to Chapter 13.

   For this experiment, you don’t have to add any text to the file. The file exists only to be deleted.

7. Run the program.

   When the program runs, type Y to delete the importantData.txt file.

   After running the program, you want to check to make sure that the program deleted the importantData.txt file.

8. In the Package Explorer, select the project’s root (again, for good measure).

9. On Eclipse’s main menu, choose File ⇒ Refresh.

   Eclipse takes another look at the project directory and lists the directory’s files in the Package Explorer’s tree. Assuming that the program did its job correctly, the file named importandData.txt no longer appears in the tree.

In Listing 15-4, the statement

new File("importantData.txt").delete();

is tricky. At first glance, you seem to be creating a new file, only to delete that file in the same line of code! But in reality, the words new File create only a representation of a file inside your program. To be more precise, the words new File create, inside your program, a representation of a disk file that may or may not already exist on your computer’s hard drive. Here’s what the new File statement really means:

"Let new File("importantData.txt") refer to a file named importantData.txt. If such a file exists, then delete it."

Yes, the devil is in the details. But smiles are in the subtleties and nobility is in the nuance.

Using Java’s do statement

To write the program in Listing 15-4, you need a loop — a loop that repeatedly asks the user whether the importantData.txt file should be deleted. (The action of the loop in Listing 15-4 is illustrated in Figure 15-7.) The loop continues to ask until the user gives a meaningful response. The loop tests its condition at the end of each iteration, after each of the user’s responses.

That’s why the program in Listing 15-4 has a do loop (also known as a do … while loop). With a do loop, the program jumps right in, executes some statements, and then checks a condition. If the condition is true, the program goes back to the top of the loop for another go-around. If the condition is false, the computer leaves the loop (and jumps to whatever code comes immediately after the loop).

A closer look at the do statement

The format of a do loop is

do {
Statements
} while (Condition)

Writing the Condition at the end of the loop reminds me that the computer executes the Statements inside the loop first. After the computer executes the Statements, the computer goes on to check the Condition. If the Condition is true, the computer goes back for another iteration of the Statements.

With a do loop, the computer always executes the statements inside the loop at least once:

//This code prints something:
int twoPlusTwo = 2 + 2;
do {
System.out.println("Are you kidding?");
System.out.println("2+2 doesn’t equal 5.");
System.out.print ("Everyone knows that");
System.out.println(" 2+2 equals 3.");
} while (twoPlusTwo == 5);

This code displays Are you kidding? 2+2 doesn’t equal 5 … and so on and then tests the condition twoPlusTwo == 5. Because twoPlusTwo == 5 is false, the computer doesn’t go back for another iteration. Instead, the computer jumps to whatever code comes immediately after the loop.

Get some practice using Java’s do statement.

Creating an enhanced for loop

When you play my simplified slot machine, you can spin any one of over 60 combinations — cherry+cherry+kumquat, rutabaga+rutabaga+rutabaga, or whatever. This chapter’s goal is to list all possible combinations. But first, I show you another kind of loop. Listing 15-5 defines an enum type for a slot machine’s symbols and displays a list of the symbols. (For an introduction to enum types, see Chapter 10.)

LISTING 15-5 Slot Machine Symbols

import static java.lang.System.out;

class ListSymbols {

enum Symbol {
cherry, lemon, kumquat, rutabaga
}

public static void main(String args[]) {
for (Symbol leftReel : Symbol.values()) {
out.println(leftReel);
}
}
}

Listing 15-5 uses Java’s enhanced for loop. The word enhanced means “enhanced compared with the loops in earlier versions of Java.” The enhanced for loop was introduced in Java version 5.0. If you run Java version 1.4.2 (or something like that), you can’t use an enhanced for loop.

Here’s the format of the enhanced for loop:

for (TypeName variableName : RangeOfValues) {
Statements
}

Here’s how the loop in Listing 15-5 follows the format:

• In Listing 15-5, the word Symbol is the name of a type.

  The int type describes values like –1, 0, 1, and 2. The boolean type describes the values true and false. And (because of the code in Listing 15-5) the Symbol type describes the values cherry, lemon, kumquat, and rutabaga. For more information on enum types like Symbol, see Chapter 10.

• In Listing 15-5, the word leftReel is the name of a variable.

  The loop in Listing 15-1 defines count to be an int variable. Similarly, the loop in Listing 15-5 defines leftReel to be a Symbol variable. So, in theory, the variable leftReel can take on any of the four Symbol values.

  By the way, I call this variable leftReel because the code lists all symbols that can appear on the leftmost of the slot machine’s three reels. Because all three of the slot machine’s reels have the same symbols, I may also have named this variable middleReel or rightReel. But on second thought, I’ll save the names middleReel and rightReel for a later example.

• In Listing 15-5, the expression Symbol.values() stands for the four values in Listing 15-5.

  To quote myself from the previous bullet, “in theory, the variable leftReel can take on any of the four Symbol values.” Well, the RangeOfValues part of the for statement turns theory into practice. This third item inside the parentheses says, “Have as many loop iterations as there are Symbol values, and have the leftReel variable take on a different Symbol value during each of the loop’s iterations.”

  So the loop in Listing 15-5 undergoes four iterations: an iteration in which leftReel has value cherry, another iteration in which leftReel has value lemon, a third iteration in which leftReel has value kumquat, and a fourth iteration in which leftReel has value rutabaga. During each iteration, the program prints the leftReel variable’s value. The result is in Figure 15-8.

In general, a someEnumTypeName.values() expression stands for the set of values that a particular enum type’s variable can have. For example, back in Listing 10-7 in Chapter 10, you can use the expression WhoWins.values() to refer to the home, visitor, and neither values.

The difference between a type’s name (like Symbol) and the type’s values (as in Symbol.values()) is really subtle. Fortunately, you don’t have to worry about the difference. As a beginning programmer, you can just use the .values() suffix in an enhanced loop’s RangeOfValues part.

Nesting the enhanced for loops

Listing 15-5 solves a simple problem in an elegant way. After reading about Listing 15-5, you may ask about more complicated problems: “Can I list all possible 3-reel combinations of the slot machine’s four symbols?” Yes, you can. Listing 15-6 shows you how to do it.

LISTING 15-6 Listing the Combinations

import static java.lang.System.out;

class ListCombinations {

enum Symbol {
cherry, lemon, kumquat, rutabaga
}

public static void main(String args[]) {

for (Symbol leftReel : Symbol.values()) {
for (Symbol middleReel : Symbol.values()) {
for (Symbol rightReel : Symbol.values()) {
out.print(leftReel);
out.print(" ");
out.print(middleReel);
out.print(" ");
out.println(rightReel);
}
}
}
}
}

When you run the program in Listing 15-6, you get 64 lines of output. Some of those lines (from the middle of a run) are shown in Figure 15-9.

Like the code in Listing 15-3, the program in Listing 15-6 contains a loop within a loop. In fact, Listing 15-6 has a loop within a loop within a loop. Here’s the strategy in Listing 15-6:

for (each of the 4 symbols that can appear on the left reel),
for (each of the 4 symbols that can appear on the middle reel),
for (each of the 4 symbols that can appear on the right reel),
display the three reels’ symbols.

You start the outer loop with the cherry symbol. Then you march on to the middle loop and begin that loop with the cherry symbol. Then you proceed to the inner loop and pick the cherry (pun intended). At last, with each loop tuned to the cherry setting, you display the cherry cherry cherry combination. (See Figure 15-10.)

After displaying cherry cherry cherry, you continue with other values of the innermost loop. That is, you change the right reel’s value from cherry to lemon. (See Figure 15-11.) Now the three reels’ values are cherry cherry lemon, so you display these values on the screen.

After exhausting the four values of the innermost (right reel) loop, you jump out of that innermost loop. But the jump puts you back to the top of the middle loop, where you change the value of middleReel from cherry to lemon. Now the values of leftReel and middleReel are cherry and lemon, respectively. (See Figure 15-12.)

Having changed to lemon on the middle loop, you go barreling again into the innermost loop. As if you’d never seen this inner loop, you set the loop’s variable to cherry. (See Figure 15-13.)

After displaying the tasty cherry lemon cherry combination, you start changing the values of the innermost loop. (See Figure 15-14.)

The loop keeps going until it displays all 64 combinations. Whew!

To finish off this chapter, you write code for the paper-scissors-stone game.