لطفا منتظر باشید ...
1.2 FizzBuzz
FizzBuzz is a game I learned long ago in
elementary-school French class, as a way to practice counting in that
language. The players take turns counting, starting with one and
going up. The rules are simple: when your turn arrives, you say the
next number. However, if that number is a multiple of five, you
should say the word "fizz"
(preferably with a French accent) instead. If the number is a
multiple of seven, you should say
"buzz." And if it is a multiple of
both, you should say "fizzbuzz." If
you mess up, you're out, and the game continues
without you.Example 1-2 is a Java program named
FizzBuzz that plays a version of the game.
Actually, it isn't a very interesting version of the
game because the computer plays by itself, and it
doesn't count in French! What is interesting to us
is the Java code that goes into this example. It demonstrates the use
of a for loop to count from 1 to 100 and the use
of if/else statements to decide whether to output
the number or one of the words
"fizz",
"buzz", or
"fizzbuzz". (In this case, the
if/else statement is used as an
if/elseif/elseif/else statement, as
we'll discuss shortly.) This program introduces System.out.print( ). This
method is just like System.out.println( ), except
that it doesn't terminate the line of output.
Whatever is output next appears on the same line. The example also shows another style for comments. Anything, on any
number of lines, between the characters /* and the
characters */ is a comment in Java and ignored by
the compiler. When one of these comments begins with
/**, as the one in this example does, then it is
additionally a doc comment, which means its
contents are used by the javadoc program that
automatically generates API documentation from Java source code.
Example 1-2. FizzBuzz.java
package je3.basics;
/**
* This program plays the game "Fizzbuzz". It counts to 100, replacing each
* multiple of 5 with the word "fizz", each multiple of 7 with the word "buzz",
* and each multiple of both with the word "fizzbuzz". It uses the modulo
* operator (%) to determine if a number is divisible by another.
**/
public class FizzBuzz { // Everything in Java is a class
public static void main(String[ ] args) { // Every program must have main( )
for(int i = 1; i <= 100; i++) { // count from 1 to 100
if (((i % 5) == 0) && ((i % 7) == 0)) // Is it a multiple of 5 & 7?
System.out.print("fizzbuzz");
else if ((i % 5) == 0) // Is it a multiple of 5?
System.out.print("fizz");
else if ((i % 7) == 0) // Is it a multiple of 7?
System.out.print("buzz");
else System.out.print(i); // Not a multiple of 5 or 7
System.out.print(" ");
}
System.out.println( );
}
}
The
for and if/else statements may
require a bit of explanation for programmers who have not encountered
them before. A for statement sets up a loop, so
that some code can be executed multiple times. The
for keyword is followed by three Java expressions
that specify the parameters of the loop. The syntax is:
for(initialize ; test ; update)
body
The initialize
expression does any necessary initialization. It is run once, before
the loop starts. Usually, it sets an initial value for a loop counter
variable. Often, as in this example, the loop counter is used only
within the loop, so the initialize
expression also declares the variable.The test
expression checks whether the loop should continue. It is evaluated
before each execution of the loop body. If it evaluates to
true, the loop is executed. When it evaluates to
false, however, the loop body is not executed, and
the loop terminates.The update
expression is evaluated at the end of each iteration of the loop; it
does anything necessary to set up the loop for the next iteration.
Usually, it simply increments or decrements the loop counter
variable.Finally, the
body is the Java code that is run each
time through the loop. It can be a single Java statement or a whole
block of Java code, enclosed by curly braces.This explanation should make it clear that the for
loop in Example 1-2 counts from 1 to 100.The
if/else statement is simpler than the
for statement. Its syntax is:
if (expression)
statement1
else
statement2
When Java encounters an if statement, it evaluates
the specified expression. If the
expression evaluates to true,
statement1 is executed. Otherwise,
statement2 is evaluated. That is all
if/else does; there is no looping involved, so the
program continues with the next statement following
if/else. The else clause and
statement2 that follows it are entirely
optional. If they are omitted, and the
expression evaluates to
false, the if statement does
nothing. The statements following the if and
else clauses can be either single Java statements
or entire blocks of Java code, contained within curly braces.
The thing to note about the
if/else statement (and the for
statement, for that matter) is that it can contain other statements,
including other if/else statements. This is how
the statement was used in Example 1-2, where we saw
what looked like an if/elseif/elseif/else
statement. In fact, this is simply an if/else
statement within an if/else statement within an
if/else statement. This structure becomes clearer
if the code is rewritten to use curly braces:
if (((i % 5) == 0)&& ((i % 7) == 0))
System.out.print("fizzbuzz");
else {
if ((i % 5) == 0)
System.out.print("fizz");
else {
if ((i % 7) == 0)
System.out.print("buzz");
else
System.out.print(i);
}
}
Note, however, that this sort of nested if/else
logic is not typically written out with a full set of curly braces in
this way. The else if programming construct is a
commonly used idiom that you will quickly become accustomed to. You
may have also noticed that I use a compact coding style that keeps
everything on a single line wherever possible. Thus,
you'll often see:
if (expression) statement
I do this so that the code remains compact and manageable, and
therefore easier to study in the printed form in which it appears
here. You may prefer to use a more highly structured, less compact
style in your own code.
