笨办法学 Java（二）（2）-阿里云开发者社区

笨办法学 Java（二）（1）https://developer.aliyun.com/article/1481894

你应该看到什么

（再次强调，你看不到这一点。这些数字将是随机的。）

在第 7 到 11 行，我们选择了五个随机数。每个数字都乘以 10 并转换为整数以截断它（因此每个随机数是 10 个数字之一：0 到 9）。然后对每个数字加 1，所以变量 a 到 e 每个都得到 1 到 10 的随机数。

在第 15 到 19 行，我们再次选择了五个随机数。每个数字都乘以一

百分之一并转换为整数以截断它（因此每个随机数是 100 个数字之一：0 到 99）。然后对每个数字加 1，所以变量 a 到 e 每个都得到 1 到 100 的随机数。

在第 23 到 27 行，我们选择了另外五个随机数。每个数字都乘以 31 并转换为整数以截断它（因此每个随机数是 31 个数字之一：0 到 30）。然后每个数字都加上 70。0加上70得到 70。1加上70得到 71。23加上70得到 93。30（最大值）加上70得到 100。因此，变量 a 到 e 每个都得到 70 到 100 的随机数。

因此，一般公式是这样的：

int a = low + (int)(Math.random() * range);

low是我们想要的最小可能数字。range是范围内应该有多少个随机数。如果你知道你的最小可能数字和最大可能数字，但不知道有多少数字，那么公式是：

int range = high  low + 1;

如果我想要的最小随机数是1，最大随机数是5，那么范围是五。5 减 1 是 4，然后加 1 来解决减法给出的两个数字之间的距离，而不是沿途停止点的计数。 8

你甚至可以这样写公式：

int a = low + (int)(Math.random()*(highlow+1));

这将使计算机从low到high中选择一个随机数。这正是我们在第 34 到 38 行所做的。

学习演练

更改第 31 行和第 32 行的low和high的值为其他值。编译并运行程序多次，以确认您总是在该范围内获得随机数。
编程中常见的逻辑错误是，如果您意外地计算距离而不是停止，就会发生“栅栏问题”。这个名字来自以下脑筋急转弯：如果我需要用一堆略长于一米的木板建造五米长的栅栏，我需要多少栅栏柱？你需要五块木板，但需要六根栅栏柱。

练习 26：使用 while 循环重复自己

这是我最喜欢的练习之一，因为你将学会如何使代码块重复。如果你能做到这一点，你就能写出各种有趣的东西。

1 import java.util.Scanner;
 2 
 3 public class EnterPIN
 4 {
 5     public static void main( String[] args )
 6     {
 7         Scanner keyboard = new Scanner(System.in);
 8         int pin, entry;
 9 
10         pin = 12345;
11 
12         System.out.println("WELCOME TO THE BANK OF JAVA.");
13         System.out.print("ENTER YOUR PIN: ");
14         entry = keyboard.nextInt();
15 
16         while ( entry != pin )
17         {
18             System.out.println("\nINCORRECT PIN. TRY AGAIN.");
19             System.out.print("ENTER YOUR PIN: ");
20             entry = keyboard.nextInt();
21         }
22 
23         System.out.println("\nPIN ACCEPTED. YOU NOW HAVE ACCESS TO YOUR 
ACCOUNT.");
24     }
25 }

你应该看到什么

WELCOME TO THE BANK OF JAVA. ENTER YOUR PIN: 123
INCORRECT PIN. TRY AGAIN. ENTER YOUR PIN: 1234
INCORRECT PIN. TRY AGAIN. ENTER YOUR PIN: 12345
PIN ACCEPTED. YOU NOW HAVE ACCESS TO YOUR ACCOUNT.

在第 16 行，您首次看到while循环。while循环类似于if语句。它们都有括号中的条件，用于检查其真假。如果条件为假，则while循环和if语句都将跳过主体中的所有代码。当条件为真时，while循环和if语句都将执行其主体中的所有代码一次。

唯一的区别是，if语句为真时将执行大括号中的所有代码一次。while循环为真时将执行大括号中的所有代码一次，然后返回并再次检查条件。如果条件仍然为真，则再次执行主体中的所有代码。然后再次检查条件，如果条件仍然为真，则再次运行主体。

实际上，你可以说while循环会执行其主体中的所有代码，只要在检查时条件为真。

最终，当检查条件时，条件将为假。然后while循环将跳过其主体中的所有代码，程序的其余部分将继续。一旦while循环的条件为假，它就不会再次被检查。

循环是如此伟大，因为我们终于可以做一些事情不止一次，而不必多次输入代码！事实上，程序员有时会说“保持你的代码 DRY：不要重复自己。”一旦你学会了编程并完成了本书中的所有练习，如果你发现自己在程序中多次输入（或复制粘贴）完全相同的代码，你会开始怀疑。

练习 27：一个猜数字游戏

现在你知道如何使用while循环重复某些内容，我们将编写一个实际上另一个人可能会喜欢运行的程序？你对此和我一样兴奋吗？

1 import java.util.Scanner;
 2 
 3 public class HighLow
 4 {
 5     public static void main( String[] args )
 6     {
 7         Scanner keyboard = new Scanner(System.in);
 8         int secret, guess;
 9 
10         secret = 1 + (int)(Math.random()*100);
11 
12         System.out.println( "I'm thinking of a number between 1100. Try to 
guess it." );
13         System.out.print( "> " );
14         guess = keyboard.nextInt();
15 
16         while ( secret != guess )
17         {
18             if ( guess < secret )
19             {
20                 System.out.println( "Sorry, your guess is too low. Try again."
);
21             }
22             if ( guess > secret )
23             {
24                 System.out.println( "Sorry, your guess is too high. Try 
again." );
25             }
26             System.out.print( "> " );
27             guess = keyboard.nextInt();
28         }
29 
30         System.out.println( "You guessed it! What are the odds?!?" );
31     }
32 }

你应该看到什么

I'm thinking of a number between 1100\. Try to guess it.
> 50
Sorry, your guess is too high. Try again.
> 25
Sorry, your guess is too high. Try again.
> 13
Sorry, your guess is too low. Try again.
> 20
Sorry, your guess is too high. Try again.
> 16
Sorry, your guess is too high. Try again.
> 18
Sorry, your guess is too high. Try again.
> 14
Sorry, your guess is too low. Try again.
> 15
You guessed it! What are the odds?!?

所以在第 10 行，计算机从 1 到 100 中选择一个随机数，并将其存储到变量secret中。我们让人类猜测。

第 16 行有一个while循环。它说“只要变量 secret 的值与变量 guess 的值不同…运行以下代码块。”第 17 行到第 28 行是循环的主体。每当条件为真时，这十二行代码都会被执行。

在循环体内，我们有几个if语句。我们已经知道人类的猜测与秘密数字不同，否则我们就不会一开始就进入while循环！但我们不知道猜测是错误是因为它太低还是因为它太高，所以这些if语句找出来并显示适当的错误消息。

然后在显示错误消息后，第 27 行我们允许他们再次猜测。人类（希望）输入一个数字，然后存储到变量guess中，覆盖该变量中的先前猜测。

然后程序循环回到第 16 行并再次检查条件。如果条件仍然为真（他们的猜测仍然不等于秘密数字），则整个循环体将再次执行。如果条件现在为假（他们猜中了），则整个循环体将被跳过，程序将跳到第 29 行。

如果循环结束，我们知道条件为假。所以我们不需要在这里加一个新的if语句；安全地打印“你猜对了”。

练习 28：无限循环

有时让学生感到惊讶的是，制作一个重复“永远”的循环是多么容易。这些被称为“无限循环”，有时我们故意制造它们，但通常它们是逻辑错误的结果。这里有一个例子：

1 import java.util.Scanner;
 2 
 3 public class KeepGuessing
 4 {
 5     public static void main( String[] args )
 6     {
 7         Scanner keyboard = new Scanner(System.in);
 8         int secret, guess;
 9 
10         secret = 1 + (int)(Math.random()*10);
11 
12         System.out.println( "I have chosen a number between 1 and 10. Try to 
guess it." );
13         System.out.print( "Your guess: " );
14         guess = keyboard.nextInt();
15 
16         while ( secret != guess )
17         {
18             System.out.println( "That is incorrect. Guess again." );
19             System.out.print( "Your guess: " );
20         }
21 
22         System.out.println( "That's right! You're a good guesser." );
23     }
24 }

你应该看到什么

I have chosen a number between 1 and 10. Try to guess it.
Your guess: 4
That is incorrect. Guess again.
Your guess: That is incorrect. Guess again.
Your guess: That is incorrect. Guess again.
Your guess: That is incorrect. Guess again.
Your guess: That is incorrect. Guess again.
Your guess: That is incorrect. Guess again.
Your guess: That is incorrect. Guess again.
Your guess: That is incorrect. Guess again.
Your guess: That is incorrect. Guess again.
Your guess: That is incorrect. Guess again.
Your guess: That is incorrect. Guess again.
Your guess: That is incorrect. Guess again.
Your guess: That is incorrect. Guess again.
Your guess: That is incorrect. Guess again.
Your guess: That is incorrect. Guess again.
Your guess: That is incorrect. Guess again.
Your guess: That is incorrect. Guess again.
Your guess: That is incorrect. Guess again.
Your guess: That is incorrect. Guess again.
Your guess: That is incorrect. Guess again.
Your guess: That is incorrect. Guess again.
Your guess: That is incorrect. Guess again.
Your guess: That is incorrect. Guess again.
Your guess: That is incorrect. Guess again.
Your guess: That is incorrect. Guess again.
Your guess: That is incorrect. Guess again.
Your guess: That is incorrect. Guess again.
Your guess: That is incorrect. Guess again.
Your guess: That is incorrect. Guess again.
Your guess: That is incorrect. Guess again.
Your guess: That is incorrect. Guess again.
Your guess: That is incorrect. Guess again.
Your guess: ^C

例如，在大学时，我在网络协议课上的一个作业是写一个网络服务器。网络服务器监听网络以获取页面请求。然后它找到请求的页面并将其发送到请求的网络浏览器。然后它等待另一个请求。我在那个作业中故意使用了一个无限循环，因为网络服务器软件旨在在机器启动时自动启动，全天候运行，并且只在机器关闭时关闭。

程序实际上没有自行停止；在程序一遍又一遍地重复时，我不得不按下 CTRL-C 来停止它。

这段代码中有一个无限循环。第 16 行检查变量secret的值是否与变量guess的值不同。如果是，它执行循环体，如果不是，它跳过循环体到第 21 行。

问题是一旦secret和guess不同，程序就永远无法到达另一行代码来改变任一变量，所以循环将永远重复第 16 行到第 20 行。

所以当你写一个 while 循环的条件时，试着记住：“我需要确保这个条件最终会变成假”。

学习演练

修复代码，使其不再产生无限循环。

练习 29：使用循环进行错误检查

到目前为止，在这本书中，我们大多数时间都在忽略错误检查。我们假设人类会遵循指示，如果他们的缺乏方向性导致我们的程序出错，我们只是责怪用户，不予理会。

当你只是在学习时，这是完全可以的。错误检查很难，这就是为什么大多数大型程序都有错误，并且需要一整群人非常努力地工作，以确保软件尽可能少地出现错误。

但是你终于到了能够编写一点错误检查的程度。

1 import java.util.Scanner;
 2 
 3 public class SafeSquareRoot
 4 {
 5     public static void main( String[] args )
 6     {
 7         Scanner keyboard = new Scanner(System.in);
 8         double x, y;
 9 
10         System.out.print("Give me a number, and I shall find the square root 
of it. ");
11         System.out.print("(No negatives, please.) ");
12         x = keyboard.nextDouble();
13 
14         while ( x < 0 )
15         {
16             System.out.print("Sorry, I won't take the square root of a 
negative.\nNew number: ");
17             x = keyboard.nextDouble();
18         }
19 
20         y = Math.sqrt(x);
21 
22         System.out.println("The square root of "+x+" is "+y);
23     }
24 }

你应该看到什么

Give me a number, and I shall find the square root of it. (No negatives, please.)
8
Sorry, I won't take the square root of a negative. New number: 7
Sorry, I won't take the square root of a negative. New number: 200
Sorry, I won't take the square root of a negative. New number: 5
The square root of 5.0 is 2.23606797749979

从第 14 行开始是我所说的“输入保护循环”的一个例子。在第 20 行，我们将对变量 x 中的任何值取平方根，并且在这样做之前，我们希望确保它包含一个正数。（Java 没有内置支持虚数。）我们可以使用内置的绝对值函数Math.abs()，但我想演示错误检查，好吗？

在第 12 行，我们让人类输入一个数字。我们已经很客气地要求他们只输入一个正数，但他们可以输入任何他们喜欢的东西。（他们甚至可以输入“Mister Mxyzptlk”，但我们的错误检查技能还不够先进，无法幸存下来。）

所以在第 14 行，我们检查他们是否遵守了指示。如果x中的值为负数（小于零），我们会打印出一个错误消息，让他们再试一次。然后，在他们输入新数字之后，我们回到第 14 行，检查条件是否仍然为真。他们是否仍然没有遵循指示？如果是，再次显示错误消息并给他们另一个机会。

计算机不会不耐烦或无聊，所以人类被困在这个循环中，直到他们遵守。他们可以输入负数两十亿次，每次计算机都会礼貌地抱怨并让他们重新输入。

最终，人类会变得聪明，输入一个非负数。然后while循环的条件将为假（终于），循环的主体将被跳过（终于），执行将在第 20 行继续，我们可以安全地计算一个我们知道是正数的数的平方根。

真正的程序到处都有这样的东西。你必须这样做，因为人类不可靠，经常做出意想不到的事情。当你的孩子在程序运行时拉起笔记本电脑并开始乱按键时会发生什么？我们希望程序不会崩溃。

哦，你有没有注意到？我在这个程序中改变了一些东西。到目前为止，我在这本书中每次在屏幕上打印东西时，我都在括号和引号之间放了一个空格，就像这样：

System.out.println( "This is a test." );

我这样做是因为我想要清楚地表明引号内的东西（技术上称为“字符串文字”）是一回事，而括号是另一回事。但是 Java 实际上并不在乎这些空格。（记住我充满了谎言。）如果你去掉空格，你的程序仍然会编译并且工作得和原来一样：

System.out.println("This is a test.");

你可能已经注意到，在第 22 行，我甚至省略了字符串文字和加号之间的空格。这样的间距不会影响 Java 程序的语法，尽管许多公司和其他软件编写团体都有“样式指南”，告诉你如果你想让团体的其他成员满意，应该以什么样的方式格式化你的代码。

有些人对此非常激动。他们认为你应该始终使用空格来缩进你的代码，或者始终将代码块的开放大括号放在上一行的末尾：

if ( age < 16 ) { 
    allowed = false;
}

…就像那样。我认为对于你自己的代码，你应该尝试其他风格，并做让你快乐的事情。当你和其他人一起工作时，你应该以让他们满意的方式格式化代码。

甚至有一些工具可以自动更改代码的格式以适应特定的风格！（搜索“源代码美化器”或“Java 代码美化器”来看一些例子。）

学习方法

不要使用输入保护循环，使用if语句和Math.abs()来处理负数的平方根。当数字为负时，取正数的平方根，并在答案旁边打印一个小的"i"。

练习 30：Do-While 循环

在这个练习中，我要做一些我通常不做的事情。我要向你展示在 Java 中制作循环的另一种方法。因为你只看了四个练习的while循环，向你展示一种不同类型的循环可能会让你感到困惑。通常我喜欢等到学生做了很长时间的事情后再向他们展示做同样事情的新方法。

所以如果你认为你会感到困惑，随时可以跳过这个练习。这几乎不会伤害你，你可以在更有信心的时候再回来。

无论如何，在 Java 中有几种制作循环的方法。除了while循环之外，还有 do-while 循环。它们几乎相同，因为它们都在括号中检查条件。如果条件为真，则执行循环体。如果条件为假，则跳过循环体（或停止循环）。

那么有什么区别呢？输入代码，然后我们再谈论它。

1 import java.util.Scanner;
 2 
 3 public class CoinFlip
 4 {
 5     public static void main( String[] args )
 6     {
 7         Scanner keyboard = new Scanner(System.in);
 8 
 9         String coin, again;
10         int flip, streak = 0;
11 
12         do
13         {
14             flip = 1 + (int)(Math.random()*2);
15 
16             if ( flip == 1 )
17                 coin = "HEADS";
18             else
19                 coin = "TAILS";
20 
21             System.out.println( "You flip a coin and it is... " + coin );
22 
23             if ( flip == 1 )
24             {
25                 streak++;
26                 System.out.println( "\tThat's " + streak + " in a row...." );
27                 System.out.print( "\tWould you like to flip again (y/n)? " );
28                 again = keyboard.next();
29             }
30             else
31             {
32                 streak = 0;
33                 again = "n";
34             }
35         } while ( again.equals("y") );
36 
37         System.out.println( "Final score: " + streak );
38     }
39 }

你应该看到什么

You flip a coin and it is... HEADS That's 1 in a row....
Would you like to flip again (y/n)? y You flip a coin and it is.  HEADS
That's 2 in a row....
Would you like to flip again (y/n)? y You flip a coin and it is.  HEADS
That's 3 in a row....
Would you like to flip again (y/n)? n Final score: 3

while循环和 do-while 循环之间只有两个区别。

while循环的条件在循环体之前，但是 do-while 循环在循环体之前有关键字do，条件在循环体结束后，紧跟着右花括号。（并且在循环条件的右括号后有一个分号，而while循环没有。）
while循环在进入循环体之前检查它们的条件，但是 do-while 循环无论如何都会运行一次循环体，并且只在第一次通过后检查条件。

在计算机科学领域，while循环被称为“前测试”循环（因为它首先检查条件），而 do-while 被称为“后测试”循环（因为它在之后检查条件）。

如果while循环的条件在第一次检查时为真，那么使用while循环的代码和使用 do-while 循环的等效代码将表现完全相同。任何你可以用while循环做的事情，你也可以用 do-while 循环（和稍微不同的代码）做，反之亦然。

那么为什么 Java 的开发者要费心制作 do-while 循环呢？因为有时你在条件中检查的是一些在至少执行一次循环体后才知道的东西。

在这种情况下，我们通过选择 1-2 之间的随机数来抛硬币，并使用if语句。然后我们问他们是否想再抛一次或停止。如果他们说想再抛一次，我们的循环条件会重复。

如果我们用while循环来做这个，条件会是这样的：

while ( again.equals("y") )
{

这是可以的，也可以工作，但是变量again直到第 28 行才得到一个值。所以我们的代码不会编译，因为again（用 Java 编译器的话）“可能尚未初始化”。所以我们必须在循环之前给它一个没有意义的值，只是为了取悦编译器。

这很烦人，所以 do-while 循环允许我们保持条件不变，但等到最后再检查它。这很方便。

学习演练

更改代码，使用while循环代替 do-while 循环。确保它能编译并且运行结果相同。
将它改回 do-while 循环。（当你忘记如何编写 do-while 循环时，你可能会回头看这段代码，我们不希望你唯一的例子被改成while循环。）

练习 31：逐个添加值

这个练习将演示一件你必须经常做的事情：处理一次只得到一个值。

如果我让你让人类输入三个数字并将它们相加，并且我保证他们只需要输入确切的三个数字（不多，不少），你可能会写出这样的东西：

int a, b, c, total;
a = keyboard.nextInt();
b = keyboard.nextInt();
c = keyboard.nextInt();
total = a + b + c;

如果我告诉你人类要输入五个数字，你的代码可能是这样的：

double num1, num2, num3, num4, num5, total;
num1 = keyboard.nextDouble();
num2 = keyboard.nextDouble();
num3 = keyboard.nextDouble();
num4 = keyboard.nextDouble();
num5 = keyboard.nextDouble();
total = num1+num2+num3+num4+num5;

但是，如果我告诉你他们想要输入一百个数字呢？或者一万个？或者可能是三个，可能是五个，我不确定？那么你需要另一种方法。你需要一个循环（这就是我们重复事情的方式），并且你需要一个变量，它将随着值的逐个添加而逐渐增加。一个从“空白”开始并逐个添加值的变量称为“累加器”变量，尽管这是一个相当古老的词，所以如果你的编程朋友年龄不到四十岁，他们可能从未听说过。

无论如何，基本想法看起来是这样的：

1 import java.util.Scanner;
 2 
 3 public class RunningTotal
 4 {
 5     public static void main( String[] args )
 6     {
 7         Scanner keyboard = new Scanner(System.in);
 8 
 9         int current, total = 0;
10 
11         System.out.print("Type in a bunch of values and I'll add them up. ");
12         System.out.println("I'll stop when you type a zero.");
13 
14         do
15         {
16             System.out.print("Value: ");
17             current = keyboard.nextInt();
18             int newtotal = current + total;
19             total = newtotal;
20             System.out.println("The total so far is: " + total);
21         } while ( current != 0 );
22 
23         System.out.println("The final total is: " + total);
24     }
25 }

你应该看到什么

Type in a bunch of values and I'll add them up. I'll stop when you type a zero. Value: 3
The total so far is: 3 Value: 4
The total so far is: 7 Value: 5
The total so far is: 12 Value: 6
The total so far is: 18 Value: 0
The total so far is: 18 The final total is: 18

我们需要两个变量：一个用于保存他们刚刚输入的值（current），一个用于保存运行总数（嗯…total）。在第 9 行，我们确保首先将零放入total中。很快你就会明白为什么。

在第 17 行，人类可以输入一个数字。这是在 do-while 循环的主体内，无论如何都会运行至少一次，所以这段代码总是会发生。假设他们一开始输入3。

在第 18 行，魔法的第一部分发生了。我们声明了一个名为newtotal的新变量，并将其值设置为人类刚刚输入的数字加上变量total 中已经存在的值。一开始total中有一个零，所以这行代码将零添加到current中，并将该数字存储到newtotal中。

然后在第 19 行，魔法的第二部分发生了：我们用 newtotal 的当前值替换 total 中的值（零）。所以现在 total 不再是零；它具有与 current 相同的值。所以 total 是0，现在是3。

然后我们打印小计，并在第 21 行检查current是否为零。如果不是，则循环重复到第 14 行。

人类可以输入第二个数字。假设是4。变量 newtotal 被初始化为

current（4）加上 total（3），所以 newtotal 是7。然后在第 19 行，我们将 total 的值更改为7。

条件再次被检查，过程继续。最终，人类输入了一个0，那个0被添加到总数中（这不会伤害它），条件变为假，所以 do-while 循环停止循环。

在练习结束之前，我应该提到两件事：

因为变量newtotal在第 18 行被声明（并定义），所以该变量的范围仅限于 do-while 循环的主体。这意味着在第 21 行，newtotal不再在范围内，因此在 do-while 循环的条件中引用newtotal的任何尝试都会导致错误。该变量在每次循环中不断创建和销毁。这有点低效。
我们甚至可以编写代码而不使用newtotal变量。由于 Java 在将右侧的最终值存储到左侧命名的变量之前，我们可以将第 18 行和第 19 行合并为一行：

total = current + total;

这个工作完全正常。（事实上，你以前见过它。）

学习演练

重写代码，使用while循环而不是 do-while 循环。确保它能够编译并确保它仍然有效。然后改回来。
更改 do-while 循环的条件，使得当newtotal恰好为 20 时循环停止。

哦？它不编译，因为newtotal超出了范围？更改newtotal声明的位置，使其正常工作。

练习 32：为骰子游戏添加值

Pig 是一个简单的骰子游戏，适用于两个或更多玩家。（如果您想了解更多信息，可以阅读维基百科关于 Pig 的条目。）基本思想是成为第一个“存入”100 分的人。当您掷出 1 时，您的回合结束，这一回合您不会获得任何分数。任何其他掷骰都会增加您这一回合的分数，但只有在您决定“保留”时才能保留这些分数。如果在保留之前掷出 1，那么您这一回合的所有分数都将丢失。

您已经掌握了整个 Pig 游戏的代码，但与您之前看到的较小程序相比，这是一次性的很多，所以我将把它分成两节课。今天我们只会为计算机玩家编写人工智能（A.I.）代码。这个计算机玩家将使用“在 20 时保留”策略，这意味着计算机会继续掷骰，直到他们这一回合的分数达到 20 或更多，然后无论如何都会保留。这实际上并不是一个糟糕的策略，而且编码起来也很容易。

1 import java.util.Scanner;
 2 
 3 public class PigDiceComputer
 4 {
 5     public static void main( String[] args )
 6     {
 7         Scanner keyboard = new Scanner(System.in);
 8 
 9         int roll, total;
10 
11         total = 0;
12 
13         do
14         {
15             roll = 1 + (int)(Math.random()*6);
16             System.out.println( "Computer rolled a " + roll + "." );
17             if ( roll == 1 )
18             {
19                 System.out.println( "\tThat ends its turn." );
20                 total = 0;
21             }
22             else
23             {
24                 total += roll;
25                 System.out.println( "\tComputer has " + total + " points so far this 
round." );
26                 if ( total < 20 )
27                 {
28                     System.out.println( "\tComputer chooses to roll again." );
29                 }
30             }
31         } while ( roll != 1 && total < 20 );
32 
33         System.out.println( "Computer ends the round with " + total + " points." );
34 
35     }
36 }

预期输出

Computer rolled a 2.
Computer has 2 points so far this round. Computer chooses to roll again.
Computer rolled a 3.
Computer has 5 points so far this round. Computer chooses to roll again.
Computer rolled a 1.
That ends its turn.
Computer ends the round with 0 points.

基本上整个程序都在一个大的 do-while 循环体中，告诉计算机何时停止：要么掷出 1，要么总数达到 20 或更多。只要掷骰不是 1 并且总数小于 20，条件就会成立，循环将从开始重新开始（在第 13 行）。我们选择 do-while 循环是因为我们希望计算机无论如何都至少掷一次骰子。

掷骰发生在第 15 行：从 1 到 6 的随机数字是掷骰的良好替代品。

在第 17 行，我们检查是否掷出了 1。如果是，所有分数都将丢失。如果不是（else），我们将此次掷骰的分数加到总分上。请注意我们使用了“加等于”，这是我们以前见过的。

第 26 行的if语句只是为了得到一个漂亮的消息，即计算机将再次掷骰。不错，对吧？所以下一课我们将回来玩完整的游戏！

学习演练

找到一个骰子（技术上应该是“骰子”，因为“骰子”是复数形式，而您只需要一个）或找到一个模拟掷骰子的应用程序或网站。拿出一张纸和一支笔。在纸张中间画一条线并制作两列。在左列上标注“掷骰”，在右列上标注“总数”。在总数列中放入0，并一开始将另一列留空。

然后掷骰子，并将您掷出的数字写在掷骰列的顶部。由于骰子掷出的行号是代码中的第 15 行，所以在掷骰值旁边用括号括起数字(15)。

然后逐行执行代码，就像计算机一样。将掷骰的当前值与 1 进行比较。如果它们相等，则划掉总数列中的当前值，并在那里放入0 (20)，因为总数将在代码的第 20 行变为零。

继续进行，直到程序结束。以下是程序“预期输出”部分所示程序示例运行的表格样式示例。

掷骰	总数
0 (11)
	2 (15)
2 (24)
	3 (15)
5 (24)
	1 (15)
0 (20)

笨办法学 Java（二）（3 ）https://developer.aliyun.com/article/1481896

笨办法学 Java（二）（2）

你应该看到什么

学习演练

练习 26：使用 while 循环重复自己

你应该看到什么

练习 27：一个猜数字游戏

你应该看到什么

练习 28：无限循环

你应该看到什么

学习演练

练习 29：使用循环进行错误检查

你应该看到什么

学习方法

练习 30：Do-While 循环

你应该看到什么

学习演练

练习 31：逐个添加值

你应该看到什么

学习演练

练习 32：为骰子游戏添加值

预期输出

学习演练

热门文章

最新文章

相关课程

相关电子书

相关实验场景

探索云世界

热门

云计算

大数据

云原生

人工智能

数据库

开发与运维

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

笨办法学 Java（二）（2）

你应该看到什么

学习演练

练习 26：使用 while 循环重复自己

你应该看到什么

练习 27：一个猜数字游戏

你应该看到什么

练习 28：无限循环

你应该看到什么

学习演练

练习 29：使用循环进行错误检查

你应该看到什么

学习方法

练习 30：Do-While 循环

你应该看到什么

学习演练

练习 31：逐个添加值

你应该看到什么

学习演练

练习 32：为骰子游戏添加值

预期输出

学习演练

热门文章

最新文章

相关课程

相关电子书

相关实验场景