mirror of
https://github.com/LingCoder/OnJava8.git
synced 2026-08-24 06:53:27 +08:00
LingCoder
GitHub
@@ -471,10 +471,10 @@ Incrementable.increment（）；
|
||||
// objects/HelloDate.java
|
||||
import java.util.*;
|
||||
|
||||
public class HelloDate {
|
||||
public class HelloDate {
|
||||
public static void main(String[] args) {
|
||||
System.out.println("Hello, it's: ");
|
||||
System.out.println(new Date());
|
||||
System.out.println("Hello, it's: ");
|
||||
System.out.println(new Date());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -490,14 +490,14 @@ import java.util.*;
|
||||
|
||||
现在，我们可以找到 Java 附带的每个类。使用浏览器的“查找”功能查找 “Date”。搜索结果中将会列出 java.util.Date，显而易见，它在 util 库中，所以我们必须导入 java.util.* 才能使用 Date。
|
||||
|
||||
如果你在文档中选择 java.lang，然后选择 System，你会看到 System 类中有几个字段，如果你选择 `out`，你会发现它是一个静态的 PrintStream 对象。 所以，即使我们没有使用 new 创建， `out` 对象就已经存在并可以使用。 `out` 对象可以执行的操作取决于 PrintStream 。 其在文档中的描述中显示为超链接，如果单击该链接，我们将可以看到 PrintStream 所对应的方法列表。（更多详情，将在本书后面介绍。） 现在我们重点说的是 println（）这个方法。 它的作用是“j将信息输出到控制台，并以换行符结束。” 既然如此，我们可以这样编码来输出信息到控制带。 代码示例：
|
||||
如果你在文档中选择 java.lang，然后选择 System，你会看到 System 类中有几个字段，如果你选择 `out`，你会发现它是一个静态的 PrintStream 对象。 所以，即使我们没有使用 new 创建， `out` 对象就已经存在并可以使用。 `out` 对象可以执行的操作取决于 PrintStream 。 其在文档中的描述中显示为超链接，如果单击该链接，我们将可以看到 PrintStream 所对应的方法列表。（更多详情，将在本书后面介绍。） 现在我们重点说的是 println() 这个方法。 它的作用是 “将信息输出到控制台，并以换行符结束。” 既然如此，我们可以这样编码来输出信息到控制台。 代码示例：
|
||||
|
||||
```JAVA
|
||||
|
||||
System.out.println("A String of things");
|
||||
```
|
||||
|
||||
每个 java 源文件中允许有多个类。与此同时，源文件的名称必须要和其中一个类名相同，否则编译器将会报错。每个独立的程序应该包含一个 mian 方法作为程序运行的入口。其方法签名和返回类型如下。代码示例：
|
||||
每个 java 源文件中允许有多个类。与此同时，源文件的名称必须要和其中一个类名相同，否则编译器将会报错。每个独立的程序应该包含一个 main 方法作为程序运行的入口。其方法签名和返回类型如下。代码示例：
|
||||
|
||||
```JAVA
|
||||
public static void main(String[] args) {
|
||||
@@ -505,7 +505,7 @@ public static void main(String[] args) {
|
||||
}
|
||||
```
|
||||
|
||||
关键字 `public` 表示方法可以被外界锁访问到。（ 更多详情将在 **隐藏实现** 章节讲到）
|
||||
关键字 `public` 表示方法可以被外界访问到。（ 更多详情将在 **隐藏实现** 章节讲到）
|
||||
main() 方法的参数是一个 字符串（String） 数组。 参数 `args` 并没有在当前的程序中使用到，但是 Java 虚拟机强制要求必须要有。 这是因为它们被用于保存命令行中的参数。
|
||||
|
||||
下面我们来看一段有趣的代码：
|
||||
@@ -522,12 +522,11 @@ System.out.println(new Date());
|
||||
|
||||
// objects/ShowProperties.java
|
||||
public class ShowProperties {
|
||||
public static void main(String[] args) {
|
||||
System.getProperties().list(System.out);
|
||||
System.out.println(System.getProperty("user.name"));
|
||||
System.out.println(
|
||||
System.getProperty("java.library.path"));
|
||||
}
|
||||
public static void main(String[] args) {
|
||||
System.getProperties().list(System.out);
|
||||
System.out.println(System.getProperty("user.name"));
|
||||
System.out.println(System.getProperty("java.library.path"));
|
||||
}
|
||||
}
|
||||
|
||||
/* Output：(前20行)
|
||||
@@ -599,7 +598,7 @@ class AllTheColorsOfTheRainbow {
|
||||
int anIntegerRepresentingColors;
|
||||
void changeTheHueOfTheColor(int newHue) {
|
||||
// ...
|
||||
}
|
||||
}
|
||||
// ...
|
||||
}
|
||||
|
||||
|
||||
@@ -4,13 +4,13 @@
|
||||
|
||||
> 程序操纵它的世界并做出选择。 在Java中，您可以使用执行控制语句进行选择。
|
||||
|
||||
Java 使用 C 的所有执行控制语句，因此如果您使用 C 或 C++ 进行编程，那么您所看到的大部分内容都是熟悉的。 大多数过程编程语言都有某种控制语句，并且语言之间经常存在重叠。在 Java 中，关键字包括 **if-else，while，do-while，for，return，break** 和名为 **switch** 的选择语句。 但是，Java并不支持备受诟病的**goto**（它仍然是解决某些类型问题的最有效方法）。 你仍然可以进行类似goto的跳转，但它比其他语言中的**goto**更受限制。
|
||||
Java 使用 C 的所有执行控制语句，因此如果您使用 C 或 C++ 进行编程，那么您所看到的大部分内容都是熟悉的。 大多数过程编程语言都有某种控制语句，并且语言之间经常存在重叠。在 Java 中，关键字包括 **if-else，while，do-while，for，return，break** 和名为 **switch** 的选择语句。 但是，Java 并不支持备受诟病的 **goto**（它仍然是解决某些类型问题的最有效方法）。 你仍然可以进行类似goto的跳转，但它比其他语言中的 **goto** 更受限制。
|
||||
|
||||
[TOC]
|
||||
|
||||
## true和flase
|
||||
|
||||
条件表达式的示例是 **a == b**。这里有一个条件表达式示例，它使用条件操作符**“==”**来查看 **a**的值是否等于 **b** 的值。 表达式返回 **true** 或 **false**。 如果显示条件表达式的结果，则会生成表示布尔值的字符串 **“true”** 和 **“false”**。
|
||||
条件表达式的示例是 **a == b**。这里有一个条件表达式示例，它使用条件操作符 **==** 来查看 **a** 的值是否等于 **b** 的值。 表达式返回 **true** 或 **false**。 如果显示条件表达式的结果，则会生成表示布尔值的字符串 **true** 和 **false**。
|
||||
|
||||
```java
|
||||
// control/TrueFalse.java
|
||||
@@ -24,7 +24,7 @@ public class TrueFalse {
|
||||
true false */
|
||||
```
|
||||
|
||||
您在上一章中看到的任何关系运算符都可以生成条件语句。 请注意，Java 不允许您使用数字作为布尔值，即使它在 C 和 C++ 中允许（在这些语言中，真"为非零，而”假“是零）。如果想在布尔测试中使用非布尔值，例如**if（a**），必须首先使用一个条件表达式将其转换为布尔值，例如 **if（a！= 0）**。
|
||||
您在上一章中看到的任何关系运算符都可以生成条件语句。 请注意，Java 不允许您使用数字作为布尔值，即使它在 C 和 C++ 中允许（在这些语言中，“真”为非零，而“假”是零）。如果想在布尔测试中使用非布尔值，例如**if (a)**，必须首先使用一个条件表达式将其转换为布尔值，例如 **if (a！= 0)**。
|
||||
|
||||
## if-else
|
||||
|
||||
@@ -76,15 +76,15 @@ public class IfElse {
|
||||
*/
|
||||
```
|
||||
|
||||
**[1]** “else if”不是新关键字，只是一个else后跟一个新的if语句。
|
||||
**[1]** “else if” 不是新关键字，只是一个 else 后跟一个新的 if 语句。
|
||||
|
||||
尽管Java（如之前的C和C ++）是一种“自由格式”语言，但通常会缩进控件流语句的主体，以便读者可以轻松确定它的开始和结束位置。
|
||||
尽管 Java（如之前的 C 和 C++）是一种“自由格式”语言，但通常会缩进控件流语句的主体，以便读者可以轻松确定它的开始和结束位置。
|
||||
|
||||
<!--Iteration Statements-->
|
||||
|
||||
## 迭代语句
|
||||
|
||||
循环由 **while**，**do-while** 和 **for** 控制，有时称为迭代语句。 语句会重复执行，直到起控制作用的 **布尔表达式** （Boolean expression）计算为"假"。
|
||||
循环由 **while**，**do-while** 和 **for** 控制，有时称为迭代语句。 语句会重复执行，直到起控制作用的 **布尔表达式** （Boolean expression）计算为“假”。
|
||||
|
||||
|
||||
### while
|
||||
@@ -130,7 +130,7 @@ false, Exited 'while'
|
||||
*/
|
||||
```
|
||||
|
||||
**condition()** 方法用到了 **Math** 库里的 **static** (静态)方法 **random()**，该方法的作用是产生 0 和 1 之间 (包括 0，但不包括 1) 的一个**double**值。**result** 的值是通过比较操作符<而得到它的，这个操作符产生 **boolean** 类型的结果。在打印 **boolean** 类型的值时，将自动地得到适合的字符串 **true** 或 **false**。while 的条件表达式意思是说："只要 **condition()**返回 **true**，就重复执行循环体中的语句"。
|
||||
**condition()** 方法用到了 **Math** 库里的 **static** (静态)方法 **random()**，该方法的作用是产生 0 和 1 之间 (包括 0，但不包括 1) 的一个**double**值。**result** 的值是通过比较操作符<而得到它的，这个操作符产生 **boolean** 类型的结果。在打印 **boolean** 类型的值时，将自动地得到适合的字符串 **true** 或 **false**。while 的条件表达式意思是说：“只要 **condition()**返回 **true**，就重复执行循环体中的语句”。
|
||||
|
||||
### do-while
|
||||
|
||||
@@ -183,7 +183,7 @@ value: 106 character: j
|
||||
*/
|
||||
```
|
||||
|
||||
请注意，变量 **c** 在程序用到它的地方被定义的，也就是在for循环的控制表达式内，而不是在 **main（）** 的开头。**c** 的范围是由 **for** 控制的语句。
|
||||
请注意，变量 **c** 在程序用到它的地方被定义的，也就是在for循环的控制表达式内，而不是在 **main()** 的开头。**c** 的范围是由 **for** 控制的语句。
|
||||
|
||||
像C这样的传统过程语言要求在块的开头定义所有变量。 当编译器创建块时，它可以为这些变量分配空间。 在Java和C ++中，您可以在整个块中传播变量声明，并在需要时定义它们。 这允许更自然的编码风格并使代码更容易理解。[1]
|
||||
|
||||
@@ -219,9 +219,9 @@ i = 4 j = 8
|
||||
|
||||
## for-in语法
|
||||
|
||||
Java 5引入了更简洁的 **for** 语法，用于数组和集合（您将在“数组和集合”章节中了解更多有关这些内容的信息）。 这有时被称为 **增强版for循环**，并且您将看到的大部分文档称为 *for-each* 语法，但Java 8添加了大量使用的 **forEach（）**。 这会混淆术语，所以我拿了一些许可证，而是称之为*for-in* （例如，在Python中，你实际上是 **for x in sequence**，所以有合理的先例）。 请记住，您可能会在其他地方看到它的不同叫法。
|
||||
Java 5引入了更简洁的 **for** 语法，用于数组和集合（您将在“数组和集合”章节中了解更多有关这些内容的信息）。 这有时被称为 **增强版for循环**，并且您将看到的大部分文档称为 *for-each* 语法，但Java 8添加了大量使用的 **forEach()**。 这会混淆术语，因此我称之为*for-in* （例如，在Python中，你实际上是 **for x in sequence**，所以有合理的先例）。 请记住，您可能会在其他地方看到它的不同叫法。
|
||||
|
||||
**for-in** 会自动为您生成每个项，因此你不必创建 **int** 变量去对由访问项构成的序列进行奇数。 例如，假设您有一个 **float** 数组，并且您想要选取该数组中的每个元素：
|
||||
**for-in** 会自动为您生成每个项，因此你不必创建 **int** 变量去对由访问项构成的序列进行计数。 例如，假设您有一个 **float** 数组，并且您想要选取该数组中的每个元素：
|
||||
|
||||
```java
|
||||
// control/ForInFloat.java
|
||||
@@ -319,9 +319,9 @@ public class ForInInt {
|
||||
|
||||
**range()** 方法已经被重载，重载表示相同的方法名可以具有不同的参数列表(你将很快学习重载)。**range()** 的第一个种重载形式是从0开始产生值，直到范围的上限，但不包括该上限。第二种重载形式是从第一个值开始产生值，直至比第二值小1的值为止。第三种形式有一个步进值，因此它每次的增量为该值。第四种 **range()** 表明还可以递减。**range()**是所谓生成器的一个非常简单的版本，有关生成器的内容将在本书稍后进行介绍。
|
||||
|
||||
**range（）** 允许在更多地方使用for-in语法，因此可以说提高可读性。
|
||||
**range()** 允许在更多地方使用 for-in 语法，因此可以说提高可读性。
|
||||
|
||||
请注意，**System.out.print（）** 不会输出换行符，因此您可以分段输出一行。
|
||||
请注意，**System.out.print()** 不会输出换行符，因此您可以分段输出一行。
|
||||
|
||||
*for-in* 语法不仅可以节省编写代码的时间。 更重要的是，它更容易阅读并说明你要做什么（获取数组的每个元素）而不是详细说明你是如何做到的（“我正在创建这个索引，所以我可以使用它来选择每个数组元素。“）。 本书只要有可能就会使用 *for-in* 语法。
|
||||
|
||||
@@ -408,7 +408,7 @@ public class BreakAndContinue {
|
||||
|
||||
**[2]** 使用 for-in 语法将产生相同的结果。
|
||||
|
||||
**[3]** 最后，可以看到一个"无穷 **while** 循环"的情况。然而，循环内部有一个 **break** 语句，可中止循环。请注意，**continue** 语句将控制权移回循环的顶部，而不会执行 **continue** 之后的任何操作。 因此，只有当 i 的值可被 10 整除时才会显示。在输出中，显示值 0，因为 0％9 产生0。
|
||||
**[3]** 最后，可以看到一个“无穷 **while** 循环”的情况。然而，循环内部有一个 **break** 语句，可中止循环。请注意，**continue** 语句将控制权移回循环的顶部，而不会执行 **continue** 之后的任何操作。 因此，只有当 i 的值可被 10 整除时才会显示。在输出中，显示值 0，因为 0％9 产生0。
|
||||
|
||||
无限循环的另一种形式是 **for（;;）**。 编译器以同样的方式处理 **while（true）** 和 **for（;;）**，因此使用哪种取决于编程品味。
|
||||
|
||||
@@ -416,19 +416,19 @@ public class BreakAndContinue {
|
||||
|
||||
## 臭名昭著的goto
|
||||
|
||||
goto 关键字很早就在程序设计语言中出现。事实上，goto 是汇编语言的程序控制结构的始 祖：“若条件A，则跳到这里；否则跳到那里”。若阅读由几乎所有编译器生成的汇编代码，就 会发现程序控制里包含了许多跳转。然而，goto是在源码的级别跳转的，所以招致了不好的 声誉。若程序总是从一个地方跳到另一个地方，还有什么办法能识别代码的流程呢？随着 Edsger Dijkstra 著名的 “Goto 有害”论的问世，goto 便从此失宠。
|
||||
goto 关键字很早就在程序设计语言中出现。事实上，goto 是汇编语言的程序控制结构的始祖：“若条件A，则跳到这里；否则跳到那里”。若阅读由几乎所有编译器生成的汇编代码，就会发现程序控制里包含了许多跳转。然而，goto是在源码的级别跳转的，所以招致了不好的声誉。若程序总是从一个地方跳到另一个地方，还有什么办法能识别代码的流程呢？随着 Edsger Dijkstra 著名的 “Goto 有害” 论的问世，goto 便从此失宠。
|
||||
|
||||
事实上，真正的问题并不在于使用 goto，而在于 goto 的滥用。而且在一些少见的情况下，goto 是组织控制流程的最佳手段。
|
||||
|
||||
尽管 goto 仍是 Java 的一个保留字，但并未在语言中得到正式使用；Java 没有 goto。然而，在 break和 continue 这两个关键字的身上，我们仍然能看出一些goto的影子。它并不属于一次跳 转，而是中断循环语句的一种方法。之所以把它们纳入 goto 问题中一起讨论，是由于它们使 用了相同的机制：标签。
|
||||
尽管 goto 仍是 Java 的一个保留字，但并未在语言中得到正式使用；Java 没有 goto。然而，在 break和 continue 这两个关键字的身上，我们仍然能看出一些goto的影子。它并不属于一次跳转，而是中断循环语句的一种方法。之所以把它们纳入 goto 问题中一起讨论，是由于它们使用了相同的机制：标签。
|
||||
|
||||
“标签”是后面跟一个冒号的标识符，就象下面这样：
|
||||
“标签”是后面跟一个冒号的标识符，就像下面这样：
|
||||
|
||||
```java
|
||||
label1:
|
||||
```
|
||||
|
||||
对 Java 来说，唯一用到标签的地方是在循环语句之前。进一步说，它实际需要紧靠在循环语 句的前方——在标签和循环之间置入任何语句都是不明智的。而在循环之前设置标签的唯一 理由是：我们希望在其中嵌套另一个循环或者一个开关。这是由于 break 和 continue 关键字通常只中断当前循环，但若随同标签使用，它们就会中断到存在标签的地方。如下所示：
|
||||
对 Java 来说，唯一用到标签的地方是在循环语句之前。进一步说，它实际需要紧靠在循环语句的前方——在标签和循环之间置入任何语句都是不明智的。而在循环之前设置标签的唯一理由是：我们希望在其中嵌套另一个循环或者一个开关。这是由于 break 和 continue 关键字通常只中断当前循环，但若随同标签使用，它们就会中断到存在标签的地方。如下所示：
|
||||
|
||||
```java
|
||||
label1:
|
||||
@@ -448,13 +448,13 @@ outer-iteration {
|
||||
|
||||
**[1]** **break** 中断内部循环，并在外部循环结束。
|
||||
|
||||
**[2]**，**continue** 移回内部循环的 起始处。但在条件3中，**continue label1** 却同时中断内部循环以及外部循环，并移至 **label1** 处。
|
||||
**[2]** **continue** 移回内部循环的起始处。但在条件3中，**continue label1** 却同时中断内部循环以及外部循环，并移至 **label1** 处。
|
||||
|
||||
**[3]**随后，它实际是继续循环，但却从外部循环开始。
|
||||
**[3]** 随后，它实际是继续循环，但却从外部循环开始。
|
||||
|
||||
**[4]**，**break label1** 也会中断所有循环，并回到 **label1** 处，但并不重新进入循环。也就是说，它实际是完全中止了两个循环。
|
||||
**[4]** **break label1** 也会中断所有循环，并回到 **label1** 处，但并不重新进入循环。也就是说，它实际是完全中止了两个循环。
|
||||
|
||||
下面是for循环的一个例子：
|
||||
下面是 for 循环的一个例子：
|
||||
|
||||
```java
|
||||
// control/LabeledFor.java
|
||||
@@ -586,13 +586,13 @@ break outer
|
||||
|
||||
(3) **break** 会中断当前循环，并移离当前标签的末尾。
|
||||
|
||||
(4) 带标签的**break**会中断当前循环，并移离由那个标签指示的循环的末尾。
|
||||
(4) 带标签的 **break** 会中断当前循环，并移离由那个标签指示的循环的末尾。
|
||||
|
||||
大家要记住的重点是：在Java里需要使用标签的唯一理由就是因为有循环嵌套存在，而且想从多层嵌套中 **break** 或 **continue**。
|
||||
大家要记住的重点是：在 Java 里需要使用标签的唯一理由就是因为有循环嵌套存在，而且想从多层嵌套中 **break** 或 **continue**。
|
||||
|
||||
**break** 和 **continue** 标签已经成为相对少用的推测特征(在前面的语言中很少或没有先例)，所以你很少在代码里看到它们。
|
||||
|
||||
在 **Dijkstra** 的 **“ goto 有害”** 论中，他最反对的就是标签，而非 **goto**。随着标签在一个程序里数量 的增多，他发现产生错误的机会也越来越多。标签和 **goto** 使我们难于对程序作静态分析。但是，Java 标签不会造成这方面的问题，因为它们的应用场合已经收到了限制，没有特别的方式用于概念程序的控制。由此也引出了一个有趣的问题：通过限制语句的能力，反而能使一项语言特性更加有用。
|
||||
在 **Dijkstra** 的 **“goto 有害”** 论中，他最反对的就是标签，而非 **goto**。随着标签在一个程序里数量的增多，他发现产生错误的机会也越来越多。标签和 **goto** 使我们难于对程序作静态分析。但是，Java 标签不会造成这方面的问题，因为它们的应用场合已经收到了限制，没有特别的方式用于概念程序的控制。由此也引出了一个有趣的问题：通过限制语句的能力，反而能使一项语言特性更加有用。
|
||||
|
||||
## switch
|
||||
|
||||
@@ -610,11 +610,13 @@ switch(integral-selector) {
|
||||
}
|
||||
```
|
||||
|
||||
其中，integral-selector (整数选择因子)是一个能够产生整数值的表达式，**switch** 能够将这个表达式的结果与每个 integral-value (整数值)相比较。若发现相符的，就执行对应的语句（简单或复合语句，其中并不需要括号）。若没有发现相 符的，就执行 default 语句。
|
||||
其中，integral-selector (整数选择因子)是一个能够产生整数值的表达式，**switch** 能够将这个表达式的结果与每个 integral-value (整数值)相比较。若发现相符的，就执行对应的语句（简单或复合语句，其中并不需要括号）。若没有发现相符的，就执行 default 语句。
|
||||
|
||||
在上面的定义中，大家会注意到每个 **case** 均以一个 **break** 结尾。这样可使执行流程跳转至 switch 主体的末尾。这是构建 **switch** 语句的一种传统方式，但 **break** 是可选的。若省略break， 会继续执行后面的 **case** 语句的代码，直到遇到一个 **break** 为止。尽管通常不想出现这种情况，但对有经验的程序员来说，也许能够善加利用。注意最后的 **default** 语句没有 **break**，因为执行流程已到了break的跳转目的地。当然，如果考虑到编程风格方面的原因，完全可以在**default** 语句的末尾放置一个 **break**，尽管它并没有任何实际的用处。
|
||||
在上面的定义中，大家会注意到每个 **case** 均以一个 **break** 结尾。这样可使执行流程跳转至 switch 主体的末尾。这是构建 **switch** 语句的一种传统方式，但 **break** 是可选的。若省略 break， 会继续执行后面的 **case** 语句的代码，直到遇到一个 **break** 为止。尽管通常不想出现这种情况，但对有经验的程序员来说，也许能够善加利用。注意最后的 **default** 语句没有 **break**，因为执行流程已到了break的跳转目的地。当然，如果考虑到编程风格方面的原因，完全可以在**default** 语句的末尾放置一个 **break**，尽管它并没有任何实际的用处。
|
||||
|
||||
switch 语句是实现多路选择的一种干净利落的一种方式（比如从一系列执行路径中挑选一个）。但它要求使用一个选择因子，并且必须是 int 或 char 那样的整数值。例如，假若将一个字串或者浮点数 作为选择因子使用，那么它们在 switch 语句里是不会工作的。对于非整数类型，则必须使用一 系列 if 语句。 下面这个例子可随机生成字母，并判断它们是元音还是辅音字母：
|
||||
switch 语句是实现多路选择的一种干净利落的一种方式（比如从一系列执行路径中挑选一个）。但它要求使用一个选择因子，并且必须是 int 或 char 那样的整数值。例如，假若将一个字串或者浮点数作为选择因子使用，那么它们在 switch 语句里是不会工作的。对于非整数类型，则必须使用一系列 if 语句。
|
||||
|
||||
下面这个例子可随机生成字母，并判断它们是元音还是辅音字母：
|
||||
|
||||
```java
|
||||
// control/VowelsAndConsonants.java
|
||||
@@ -661,7 +663,7 @@ z, 122: consonant
|
||||
*/
|
||||
```
|
||||
|
||||
由于 **Random.nextInt(26)** 会产生0到26之间的一个值，所以在其上加上一个偏移量 "a"，即可产生小写字母。在 **case** 语句中，使用单引号引起的字符也会产生用于比较的整数值。
|
||||
由于 **Random.nextInt(26)** 会产生 0 到 26 之间的一个值，所以在其上加上一个偏移量 "a"，即可产生小写字母。在 **case** 语句中，使用单引号引起的字符也会产生用于比较的整数值。
|
||||
|
||||
请注意 **case** 语句能够堆叠在一起，为一段代码形成多重匹配，即只要符合多种条件中的一种，就执行那段特别的代码。这时也应该注意将 **break** 语句置于特定 **case** 的末尾，否则控制流程会简单地下移，处理后面的 **case**。
|
||||
|
||||
@@ -671,13 +673,13 @@ z, 122: consonant
|
||||
int c = rand.nextInt(26) + 'a';
|
||||
```
|
||||
|
||||
**Random.nextInt()**将产生0~25之间的一个随机 **int** 值，它将被加到 **"a"** 上。这表示 **"a"** 将自动被转换为 **int** 以执行假发。为了把 **c** 当作字符打印，必须将其转型为 **char**；否则，将产生整数输出。
|
||||
此处 **Random.nextInt()** 将产生 0~25 之间的一个随机 **int** 值，它将被加到 **a** 上。这表示 **a** 将自动被转换为 **int** 以执行假发。为了把 **c** 当作字符打印，必须将其转型为 **char**；否则，将产生整数输出。
|
||||
|
||||
|
||||
<!-- Switching on Strings -->
|
||||
## switch字符串
|
||||
|
||||
Java 7增加了在字符串上 **switch** 的用法。 此示例展示了您从一组String可能性中选择的旧方法，以及使用switch的新方法：
|
||||
Java 7 增加了在字符串上 **switch** 的用法。 此示例展示了您从一组 String 可能性中选择的旧方法，以及使用 switch 的新方法：
|
||||
|
||||
```java
|
||||
// control/StringSwitch.java
|
||||
@@ -723,11 +725,11 @@ RED
|
||||
*/
|
||||
```
|
||||
|
||||
一旦理解了switch，这种语法就是一个逻辑扩展。 结果更清晰，更易于理解和维护。
|
||||
一旦理解了 switch，这种语法就是一个逻辑扩展。 结果更清晰，更易于理解和维护。
|
||||
|
||||
作为 **switch** 字符串的第二个例子，我们重新访问 Math.random（）。 它是否产生从 0 到 1 的值，包括还是不包括值“1”？ 在数学术语中，是（0,1），还是[0,1]，还是（0,1）还是[0,1]？ （方括号表示“包括”，而括号表示“不包括”。）
|
||||
作为 **switch** 字符串的第二个例子，我们重新访问 Math.random()。 它是否产生从 0 到 1 的值，包括还是不包括值 “1”？ 在数学术语中，是（0,1），还是 [0,1]，还是（0,1）还是 [0,1]？ （方括号表示“包括”，而括号表示“不包括”。）
|
||||
|
||||
下面一个可能提供答案的测试程序。 所有命令行参数都作为 **String** 对象传递，因此我们可以 **switch** 参数来决定要做什么。 有一个问题：用户可能不提供任何参数，因此索引到args数组会导致程序失败。 要解决这个问题，我们检查数组的长度，如果它为零，我们使用一个空字符串，否则我们选择 **args** 数组中的第一个元素：
|
||||
下面一个可能提供答案的测试程序。 所有命令行参数都作为 **String** 对象传递，因此我们可以 **switch** 参数来决定要做什么。 有一个问题：用户可能不提供任何参数，因此索引到 args 数组会导致程序失败。 要解决这个问题，我们检查数组的长度，如果它为零，我们使用一个空字符串，否则我们选择 **args** 数组中的第一个元素：
|
||||
|
||||
```java
|
||||
// control/RandomBounds.java
|
||||
@@ -768,7 +770,7 @@ or
|
||||
java RandomBounds upper
|
||||
```
|
||||
|
||||
使用 onjava 包中的 TimedAbort 类，程序在三秒后中止，因此看起来 Math.random（）从不生成 0.0或 1.0。 但这就是这样一个实验可以欺骗的地方。 如果考虑0到1之间所有不同 **double** 类型的分数（double fractions）的数量，实验中达到任何一个值的可能性可能超过一台计算机甚至一个实验者的寿命。 结果是0.0包含在 **Math.random（）**的输出中，而 1.0 则不包括在内。 在数学术语中，它是[0,1）。 您必须小心分析您的实验并了解它们的局限性。结果是 0.0 包含在 **Math.random（）**的输出中，而 1.0 则不包括在内。 在数学术语中，它是 [0,1）。 您必须小心分析您的实验并了解它们的局限性。
|
||||
使用 onjava 包中的 TimedAbort 类，程序在三秒后中止，因此看起来 Math.random() 从不生成 0.0 或 1.0。 但这就是这样一个实验可以欺骗的地方。 如果考虑0到1之间所有不同 **double** 类型的分数（double fractions）的数量，实验中达到任何一个值的可能性可能超过一台计算机甚至一个实验者的寿命。 结果是 0.0 包含在 **Math.random()** 的输出中，而 1.0 则不包括在内。 在数学术语中，它是 [0,1）。 您必须小心分析您的实验并了解它们的局限性。结果是 0.0 包含在 **Math.random()** 的输出中，而 1.0 则不包括在内。 在数学术语中，它是 [0,1）。 您必须小心分析您的实验并了解它们的局限性。
|
||||
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user