# 3.2 执行控制
(3)2 执行控制
Java使用了C的全部控制语句，所以假期您以前用C或C++编程，其中大多数都应是非常熟悉的。大多数程序化的编程语言都提供了某种形式的控制语句，这在语言间通常是共通的。在Java里，涉及的关键字包括`if-else`、`while`、`do-while`、`for`以及一个名为`switch`的选择语句。然而，Java并不支持非常有害的`goto`（它仍是解决某些特殊问题的权宜之计）。仍然可以进行象`goto`那样的跳转，但比典型的`goto`要局限多了。
## 3.2.1 真和假
所有条件语句都利用条件表达式的真或假来决定执行流程。条件表达式的一个例子是`A==B`。它用条件运算符`==`来判断`A`值是否等于`B`值。该表达式返回`true`或`false`。本章早些时候接触到的所有关系运算符都可拿来构造一个条件语句。注意Java不允许我们将一个数字作为布尔值使用，即使它在C和C++里是允许的（真是非零，而假是零）。若想在一次布尔测试中使用一个非布尔值——比如在`if(a)`里，那么首先必须用一个条件表达式将其转换成一个布尔值，例如`if(a!=0)`。
## 3.2.2 `if-else`
`if-else`语句或许是控制程序流程最基本的形式。其中的`else`是可选的，所以可按下述两种形式来使用`if`：
```
if(布尔表达式)
语句
```
或者
```
if(布尔表达式)
语句
else
语句
```
条件必须产生一个布尔结果。“语句”要么是用分号结尾的一个简单语句，要么是一个复合语句——封闭在括号内的一组简单语句。在本书任何地方，只要提及“语句”这个词，就有可能包括简单或复合语句。
作为`if-else`的一个例子，下面这个`test()`方法可告诉我们猜测的一个数字位于目标数字之上、之下还是相等：
```
static int test(int testval) {
int result = 0;
if(testval > target)
result = -1;
else if(testval < target)
result = +1;
else
result = 0; // match
return result;
}
```
最好将流程控制语句缩进排列，使读者能方便地看出起点与终点。
(1) `return`
`return`关键字有两方面的用途：指定一个方法返回什么值（假设它没有`void`返回值），并立即返回那个值。可据此改写上面的`test()`方法，使其利用这些特点：
```
static int test2(int testval) {
if(testval > target)
return -1;
if(testval < target)
return +1;
return 0; // match
}
```
不必加上`else`，因为方法在遇到`return`后便不再继续。
## 3.2.3 迭代
`while`，`do-while`和`for`控制着循环，有时将其划分为“迭代语句”。除非用于控制迭代的布尔表达式得到“假”的结果，否则语句会重复执行下去。`while`循环的格式如下：
```
while(布尔表达式)
语句
```
在循环刚开始时，会计算一次“布尔表达式”的值。而对于后来每一次额外的循环，都会在开始前重新计算一次。
下面这个简单的例子可产生随机数，直到符合特定的条件为止：
```
//: WhileTest.java
// Demonstrates the while loop
public class WhileTest {
public static void main(String[] args) {
double r = 0;
while(r < 0.99d) {
r = Math.random();
System.out.println(r);
}
}
} ///:~
```
它用到了`Math`库里的`static`（静态）方法`random()`。该方法的作用是产生0和1之间（包括0，但不包括1）的一个`double`值。`while`的条件表达式意思是说：“一直循环下去，直到数字等于或大于0.99”。由于它的随机性，每运行一次这个程序，都会获得大小不同的数字列表。
## 3.2.4 `do-while`
`do-while`的格式如下：
```
do
语句
while(布尔表达式)
```
`while`和`do-while`唯一的区别就是`do-while`肯定会至少执行一次；也就是说，至少会将其中的语句“过一遍”——即便表达式第一次便计算为`false`。而在`while`循环结构中，若条件第一次就为`false`，那么其中的语句根本不会执行。在实际应用中，`while`比`do-while`更常用一些。
## 3.2.5 `for`
`for`循环在第一次迭代之前要进行初始化。随后，它会进行条件测试，而且在每一次迭代的时候，进行某种形式的“步进”（Stepping）。`for`循环的形式如下：
```
for(初始表达式; 布尔表达式; 步进)
语句
```
无论初始表达式，布尔表达式，还是步进，都可以置空。每次迭代前，都要测试一下布尔表达式。若获得的结果是`false`，就会继续执行紧跟在`for`语句后面的那行代码。在每次循环的末尾，会计算一次步进。
`for`循环通常用于执行“计数”任务：
```
//: ListCharacters.java
// Demonstrates "for" loop by listing
// all the ASCII characters.
public class ListCharacters {
public static void main(String[] args) {
for( char c = 0; c < 128; c++)
if (c != 26 ) // ANSI Clear screen
System.out.println(
"value: " + (int)c +
" character: " + c);
}
} ///:~
```
注意变量`c`是在需要用到它的时候定义的——在`for`循环的控制表达式内部，而非在由起始花括号标记的代码块的最开头。`c`的作用域是由`for`控制的表达式。
以于象C这样传统的程序化语言，要求所有变量都在一个块的开头定义。所以在编译器创建一个块的时候，它可以为那些变量分配空间。而在Java和C++中，则可在整个块的范围内分散变量声明，在真正需要的地方才加以定义。这样便可形成更自然的编码风格，也更易理解。
可在`for`语句里定义多个变量，但它们必须具有同样的类型：
```
for(int i = 0, j = 1;
i < 10 && j != 11;
i++, j++)
/* body of for loop */;
```
其中，`for`语句内的`int`定义同时覆盖了`i`和`j`。只有`for`循环才具备在控制表达式里定义变量的能力。对于其他任何条件或循环语句，都不可采用这种方法。
(1) 逗号运算符
早在第1章，我们已提到了逗号运算符——注意不是逗号分隔符；后者用于分隔函数的不同参数。Java里唯一用到逗号运算符的地方就是`for`循环的控制表达式。在控制表达式的初始化和步进控制部分，我们可使用一系列由逗号分隔的语句。而且那些语句均会独立执行。前面的例子已运用了这种能力，下面则是另一个例子：
```
//: CommaOperator.java
public class CommaOperator {
public static void main(String[] args) {
for(int i = 1, j = i + 10; i < 5;
i++, j = i * 2) {
System.out.println("i= " + i + " j= " + j);
}
}
} ///:~
```
输出如下：
```
i= 1 j= 11
i= 2 j= 4
i= 3 j= 6
i= 4 j= 8
```
大家可以看到，无论在初始化还是在步进部分，语句都是顺序执行的。此外，尽管初始化部分可设置任意数量的定义，但都属于同一类型。
## 3.2.6 中断和继续
在任何循环语句的主体部分，亦可用`break`和`continue`控制循环的流程。其中，`break`用于强行退出循环，不执行循环中剩余的语句。而`continue`则停止执行当前的迭代，然后退回循环起始和，开始新的迭代。
下面这个程序向大家展示了`break`和`continue`在`for`和`while`循环中的例子：
```
//: BreakAndContinue.java
// Demonstrates break and continue keywords
public class BreakAndContinue {
public static void main(String[] args) {
for(int i = 0; i < 100; i++) {
if(i == 74) break; // Out of for loop
if(i % 9 != 0) continue; // Next iteration
System.out.println(i);
}
int i = 0;
// An "infinite loop":
while(true) {
i++;
int j = i * 27;
if(j == 1269) break; // Out of loop
if(i % 10 != 0) continue; // Top of loop
System.out.println(i);
}
}
} ///:~
```
在这个`for`循环中，`i`的值永远不会到达100。因为一旦`i`到达74，`break`语句就会中断循环。通常，只有在不知道中断条件何时满足时，才需象这样使用`break`。只要`i`不能被9整除，`continue`语句会使程序流程返回循环的最开头执行（所以使`i`值递增）。如果能够整除，则将值显示出来。
第二部分向大家揭示了一个“无限循环”的情况。然而，循环内部有一个`break`语句，可中止循环。除此以外，大家还会看到`continue`移回循环顶部，同时不完成剩余的内容（所以只有在i值能被9整除时才打印出值）。输出结果如下：
```
0
9
18
27
36
45
54
63
72
10
20
30
40
```
之所以显示0，是由于`0%9`等于0。
无限循环的第二种形式是`for(;;)`。编译器将`while(true)`与`for(;;)`看作同一回事。所以具体选用哪个取决于自己的编程习惯。
(1) 臭名昭著的`goto`
`goto`关键字很早就在程序设计语言中出现。事实上，`goto`是汇编语言的程序控制结构的始祖：“若条件`A`，则跳到这里；否则跳到那里”。若阅读由几乎所有编译器生成的汇编代码，就会发现程序控制里包含了许多跳转。然而，`goto`是在源码的级别跳转的，所以招致了不好的声誉。若程序总是从一个地方跳到另一个地方，还有什么办法能识别代码的流程呢？随着Edsger Dijkstra著名的“Goto有害”论的问世，`goto`便从此失宠。
事实上，真正的问题并不在于使用`goto`，而在于`goto`的滥用。而且在一些少见的情况下，`goto`是组织控制流程的最佳手段。
尽管`goto`仍是Java的一个保留字，但并未在语言中得到正式使用；Java没有`goto`。然而，在`break`和`continue`这两个关键字的身上，我们仍然能看出一些`goto`的影子。它并不属于一次跳转，而是中断循环语句的一种方法。之所以把它们纳入`goto`问题中一起讨论，是由于它们使用了相同的机制：标签。
“标签”是后面跟一个冒号的标识符，就象下面这样：
```
label1:
```
对Java来说，唯一用到标签的地方是在循环语句之前。进一步说，它实际需要紧靠在循环语句的前方——在标签和循环之间置入任何语句都是不明智的。而在循环之前设置标签的唯一理由是：我们希望在其中嵌套另一个循环或者一个开关。这是由于`break`和`continue`关键字通常只中断当前循环，但若随同标签使用，它们就会中断到存在标签的地方。如下所示：
```
label1:
外部循环{
内部循环{
//...
break; //1
//...
continue; //2
//...
continue label1; //3
//...
break label1; //4
}
}
```
在条件1中，`break`中断内部循环，并在外部循环结束。在条件2中，`continue`移回内部循环的起始处。但在条件3中，`continue label1`却同时中断内部循环以及外部循环，并移至`label1`处。随后，它实际是继续循环，但却从外部循环开始。在条件4中，break label1也会中断所有循环，并回到label1处，但并不重新进入循环。也就是说，它实际是完全中止了两个循环。
下面是`for`循环的一个例子：
```
//: LabeledFor.java
// Java’s "labeled for loop"
public class LabeledFor {
public static void main(String[] args) {
int i = 0;
outer: // Can't have statements here
for(; true ;) { // infinite loop
inner: // Can't have statements here
for(; i < 10; i++) {
prt("i = " + i);
if(i == 2) {
prt("continue");
continue;
}
if(i == 3) {
prt("break");
i++; // Otherwise i never
// gets incremented.
break;
}
if(i == 7) {
prt("continue outer");
i++; // Otherwise i never
// gets incremented.
continue outer;
}
if(i == 8) {
prt("break outer");
break outer;
}
for(int k = 0; k < 5; k++) {
if(k == 3) {
prt("continue inner");
continue inner;
}
}
}
}
// Can't break or continue
// to labels here
}
static void prt(String s) {
System.out.println(s);
}
} ///:~
```
这里用到了在其他例子中已经定义的`prt()`方法。
注意`break`会中断`for`循环，而且在抵达`for`循环的末尾之前，递增表达式不会执行。由于`break`跳过了递增表达式，所以递增会在`i==3`的情况下直接执行。在`i==7`的情况下，`continue outer`语句也会到达循环顶部，而且也会跳过递增，所以它也是直接递增的。
下面是输出结果：
```
i = 0
continue inner
i = 1
continue inner
i = 2
continue
i = 3
break
i = 4
continue inner
i = 5
continue inner
i = 6
continue inner
i = 7
continue outer
i = 8
break outer
```
如果没有`break outer`语句，就没有办法在一个内部循环里找到出外部循环的路径。这是由于break本身只能中断最内层的循环（对于`continue`同样如此）。
当然，若想在中断循环的同时退出方法，简单地用一个`return`即可。
下面这个例子向大家展示了带标签的`break`以及`continue`语句在`while`循环中的用法：
```
//: LabeledWhile.java
// Java's "labeled while" loop
public class LabeledWhile {
public static void main(String[] args) {
int i = 0;
outer:
while(true) {
prt("Outer while loop");
while(true) {
i++;
prt("i = " + i);
if(i == 1) {
prt("continue");
continue;
}
if(i == 3) {
prt("continue outer");
continue outer;
}
if(i == 5) {
prt("break");
break;
}
if(i == 7) {
prt("break outer");
break outer;
}
}
}
}
static void prt(String s) {
System.out.println(s);
}
} ///:~
```
同样的规则亦适用于`while`：
(1) 简单的一个`continue`会退回最内层循环的开头（顶部），并继续执行。
(2) 带有标签的`continue`会到达标签的位置，并重新进入紧接在那个标签后面的循环。
(3) `break`会中断当前循环，并移离当前标签的末尾。
(4) 带标签的`break`会中断当前循环，并移离由那个标签指示的循环的末尾。
这个方法的输出结果是一目了然的：
```
Outer while loop
i = 1
continue
i = 2
i = 3
continue outer
Outer while loop
i = 4
i = 5
break
Outer while loop
i = 6
i = 7
break outer
```
大家要记住的重点是：在Java里唯一需要用到标签的地方就是拥有嵌套循环，而且想中断或继续多个嵌套级别的时候。
在Dijkstra的“Goto有害”论中，他最反对的就是标签，而非`goto`。随着标签在一个程序里数量的增多，他发现产生错误的机会也越来越多。标签和`goto`使我们难于对程序作静态分析。这是由于它们在程序的执行流程中引入了许多“怪圈”。但幸运的是，Java标签不会造成这方面的问题，因为它们的活动场所已被限死，不可通过特别的方式到处传递程序的控制权。由此也引出了一个有趣的问题：通过限制语句的能力，反而能使一项语言特性更加有用。
## 3.2.7 开关
“开关”（`Switch`）有时也被划分为一种“选择语句”。根据一个整数表达式的值，`switch`语句可从一系列代码选出一段执行。它的格式如下：
```
switch(整数选择因子) {
case 整数值1 : 语句; break;
case 整数值2 : 语句; break;
case 整数值3 : 语句; break;
case 整数值4 : 语句; break;
case 整数值5 : 语句; break;
//..
default:语句;
}
```
其中，“整数选择因子”是一个特殊的表达式，能产生整数值。`switch`能将整数选择因子的结果与每个整数值比较。若发现相符的，就执行对应的语句（简单或复合语句）。若没有发现相符的，就执行`default`语句。
在上面的定义中，大家会注意到每个`case`均以一个`break`结尾。这样可使执行流程跳转至`switch`主体的末尾。这是构建`switch`语句的一种传统方式，但`break`是可选的。若省略`break`，会继续执行后面的`case`语句的代码，直到遇到一个`break`为止。尽管通常不想出现这种情况，但对有经验的程序员来说，也许能够善加利用。注意最后的`default`语句没有`break`，因为执行流程已到了`break`的跳转目的地。当然，如果考虑到编程风格方面的原因，完全可以在`default`语句的末尾放置一个`break`，尽管它并没有任何实际的用处。
`switch`语句是实现多路选择的一种易行方式（比如从一系列执行路径中挑选一个）。但它要求使用一个选择因子，并且必须是`int`或`char`那样的整数值。例如，假若将一个字符串或者浮点数作为选择因子使用，那么它们在`switch`语句里是不会工作的。对于非整数类型，则必须使用一系列`if`语句。
下面这个例子可随机生成字母，并判断它们是元音还是辅音字母：
```
//: VowelsAndConsonants.java
// Demonstrates the switch statement
public class VowelsAndConsonants {
public static void main(String[] args) {
for(int i = 0; i < 100; i++) {
char c = (char)(Math.random() * 26 + 'a');
System.out.print(c + ": ");
switch(c) {
case 'a':
case 'e':
case 'i':
case 'o':
case 'u':
System.out.println("vowel");
break;
case 'y':
case 'w':
System.out.println(
"Sometimes a vowel");
break;
default:
System.out.println("consonant");
}
}
}
} ///:~
```
由于`Math.random()`会产生0到1之间的一个值，所以只需将其乘以想获得的最大随机数（对于英语字母，这个数字是26），再加上一个偏移量，得到最小的随机数。
尽管我们在这儿表面上要处理的是字符，但`switch`语句实际使用的字符的整数值。在`case`语句中，用单引号封闭起来的字符也会产生整数值，以便我们进行比较。
请注意`case`语句相互间是如何聚合在一起的，它们依次排列，为一部分特定的代码提供了多种匹配模式。也应注意将`break`语句置于一个特定`case`的末尾，否则控制流程会简单地下移，并继续判断下一个条件是否相符。
(1) 具体的计算
应特别留意下面这个语句：
```
char c = (char)(Math.random() * 26 + 'a');
```
`Math.random()`会产生一个`double`值，所以26会转换成`double`类型，以便执行乘法运算。这个运算也会产生一个`double`值。这意味着为了执行加法，必须无将`'a'`转换成一个`double`。利用一个“转换”，`double`结果会转换回`char`。
我们的第一个问题是，转换会对`char`作什么样的处理呢？换言之，假设一个值是29.7，我们把它转换成一个`char`，那么结果值到底是30还是29呢？答案可从下面这个例子中得到：
```
//: CastingNumbers.java
// What happens when you cast a float or double
// to an integral value?
public class CastingNumbers {
public static void main(String[] args) {
double
above = 0.7,
below = 0.4;
System.out.println("above: " + above);
System.out.println("below: " + below);
System.out.println(
"(int)above: " + (int)above);
System.out.println(
"(int)below: " + (int)below);
System.out.println(
"(char)('a' + above): " +
(char)('a' + above));
System.out.println(
"(char)('a' + below): " +
(char)('a' + below));
}
} ///:~
```
输出结果如下：
```
above: 0.7
below: 0.4
(int)above: 0
(int)below: 0
(char)('a' + above): a
(char)('a' + below): a
```
所以答案就是：将一个`float`或`double`值转换成整数值后，总是将小数部分“砍掉”，不作任何进位处理。
第二个问题与`Math.random()`有关。它会产生0和1之间的值，但是否包括值1呢？用正统的数学语言表达，它到底是`(0,1)`，`[0,1]`，`(0,1]`，还是`[0,1)`呢（方括号表示“包括”，圆括号表示“不包括”）？同样地，一个示范程序向我们揭示了答案：
```
//: RandomBounds.java
// Does Math.random() produce 0.0 and 1.0?
public class RandomBounds {
static void usage() {
System.err.println("Usage: \n\t" +
"RandomBounds lower\n\t" +
"RandomBounds upper");
System.exit(1);
}
public static void main(String[] args) {
if(args.length != 1) usage();
if(args[0].equals("lower")) {
while(Math.random() != 0.0)
; // Keep trying
System.out.println("Produced 0.0!");
}
else if(args[0].equals("upper")) {
while(Math.random() != 1.0)
; // Keep trying
System.out.println("Produced 1.0!");
}
else
usage();
}
} ///:~
```
为运行这个程序，只需在命令行键入下述命令即可：
```
java RandomBounds lower
```
或
```
java RandomBounds upper
```
在这两种情况下，我们都必须人工中断程序，所以会发现`Math.random()`“似乎”永远都不会产生0.0或1.0。但这只是一项实验而已。若想到0和1之间有2的128次方不同的双精度小数，所以如果全部产生这些数字，花费的时间会远远超过一个人的生命。当然，最后的结果是在`Math.random()`的输出中包括了0.0。或者用数字语言表达，输出值范围是`[0,1)`。
- Java 编程思想
- 写在前面的话
- 引言
- 第1章 对象入门
- 1.1 抽象的进步
- 1.2 对象的接口
- 1.3 实现方案的隐藏
- 1.4 方案的重复使用
- 1.5 继承：重新使用接口
- 1.6 多态对象的互换使用
- 1.7 对象的创建和存在时间
- 1.8 异常控制：解决错误
- 1.9 多线程
- 1.10 永久性
- 1.11 Java和因特网
- 1.12 分析和设计
- 1.13 Java还是C++
- 第2章 一切都是对象
- 2.1 用引用操纵对象
- 2.2 所有对象都必须创建
- 2.3 绝对不要清除对象
- 2.4 新建数据类型：类
- 2.5 方法、参数和返回值
- 2.6 构建Java程序
- 2.7 我们的第一个Java程序
- 2.8 注释和嵌入文档
- 2.9 编码样式
- 2.10 总结
- 2.11 练习
- 第3章 控制程序流程
- 3.1 使用Java运算符
- 3.2 执行控制
- 3.3 总结
- 3.4 练习
- 第4章 初始化和清除
- 4.1 用构造器自动初始化
- 4.2 方法重载
- 4.3 清除：收尾和垃圾收集
- 4.4 成员初始化
- 4.5 数组初始化
- 4.6 总结
- 4.7 练习
- 第5章 隐藏实现过程
- 5.1 包：库单元
- 5.2 Java访问指示符
- 5.3 接口与实现
- 5.4 类访问
- 5.5 总结
- 5.6 练习
- 第6章 类复用
- 6.1 组合的语法
- 6.2 继承的语法
- 6.3 组合与继承的结合
- 6.4 到底选择组合还是继承
- 6.5 protected
- 6.6 累积开发
- 6.7 向上转换
- 6.8 final关键字
- 6.9 初始化和类装载
- 6.10 总结
- 6.11 练习
- 第7章 多态性
- 7.1 向上转换
- 7.2 深入理解
- 7.3 覆盖与重载
- 7.4 抽象类和方法
- 7.5 接口
- 7.6 内部类
- 7.7 构造器和多态性
- 7.8 通过继承进行设计
- 7.9 总结
- 7.10 练习
- 第8章 对象的容纳
- 8.1 数组
- 8.2 集合
- 8.3 枚举器（迭代器）
- 8.4 集合的类型
- 8.5 排序
- 8.6 通用集合库
- 8.7 新集合
- 8.8 总结
- 8.9 练习
- 第9章 异常差错控制
- 9.1 基本异常
- 9.2 异常的捕获
- 9.3 标准Java异常
- 9.4 创建自己的异常
- 9.5 异常的限制
- 9.6 用finally清除
- 9.7 构造器
- 9.8 异常匹配
- 9.9 总结
- 9.10 练习
- 第10章 Java IO系统
- 10.1 输入和输出
- 10.2 增添属性和有用的接口
- 10.3 本身的缺陷：RandomAccessFile
- 10.4 File类
- 10.5 IO流的典型应用
- 10.6 StreamTokenizer
- 10.7 Java 1.1的IO流
- 10.8 压缩
- 10.9 对象序列化
- 10.10 总结
- 10.11 练习
- 第11章 运行期类型识别
- 11.1 对RTTI的需要
- 11.2 RTTI语法
- 11.3 反射：运行期类信息
- 11.4 总结
- 11.5 练习
- 第12章 传递和返回对象
- 12.1 传递引用
- 12.2 制作本地副本
- 12.3 克隆的控制
- 12.4 只读类
- 12.5 总结
- 12.6 练习
- 第13章 创建窗口和程序片
- 13.1 为何要用AWT？
- 13.2 基本程序片
- 13.3 制作按钮
- 13.4 捕获事件
- 13.5 文本字段
- 13.6 文本区域
- 13.7 标签
- 13.8 复选框
- 13.9 单选钮
- 13.10 下拉列表
- 13.11 列表框
- 13.12 布局的控制
- 13.13 action的替代品
- 13.14 程序片的局限
- 13.15 视窗化应用
- 13.16 新型AWT
- 13.17 Java 1.1用户接口API
- 13.18 可视编程和Beans
- 13.19 Swing入门
- 13.20 总结
- 13.21 练习
- 第14章 多线程
- 14.1 反应灵敏的用户界面
- 14.2 共享有限的资源
- 14.3 堵塞
- 14.4 优先级
- 14.5 回顾runnable
- 14.6 总结
- 14.7 练习
- 第15章 网络编程
- 15.1 机器的标识
- 15.2 套接字
- 15.3 服务多个客户
- 15.4 数据报
- 15.5 一个Web应用
- 15.6 Java与CGI的沟通
- 15.7 用JDBC连接数据库
- 15.8 远程方法
- 15.9 总结
- 15.10 练习
- 第16章 设计模式
- 16.1 模式的概念
- 16.2 观察器模式
- 16.3 模拟垃圾回收站
- 16.4 改进设计
- 16.5 抽象的应用
- 16.6 多重分发
- 16.7 访问器模式
- 16.8 RTTI真的有害吗
- 16.9 总结
- 16.10 练习
- 第17章 项目
- 17.1 文字处理
- 17.2 方法查找工具
- 17.3 复杂性理论
- 17.4 总结
- 17.5 练习
- 附录A 使用非JAVA代码
- 附录B 对比C++和Java
- 附录C Java编程规则
- 附录D 性能
- 附录E 关于垃圾收集的一些话
- 附录F 推荐读物