(特价书)Java核心技术(卷I)基础知识(原书第9版)

1.5 关于Java的常见误解 10
第2章 Java程序设计环境 13
2.1 安装Java开发工具箱 13
2.1.1 下载JDK 13
2.1.2 设置执行路径 14
2.1.3 安装库源文件和文档 16
2.1.4 安装本书中的示例 17
2.1.5 导航Java目录 17
2.2 选择开发环境 18
2.3 使用命令行工具 18
2.4 使用集成开发环境 20
2.5 运行图形化应用程序 23
2.6 建立并运行applet 25
第3章 Java的基本程序设计结构 29
3.1 一个简单的Java应用程序 29
3.2 注释 32
3.3 数据类型 33
3.3.1 整型 33
3.3.2 浮点类型 34
3.3.3 char类型 35
3.3.4 boolean类型 36
3.4 变量 37
3.4.1 变量初始化 37
3.4.2 常量 38
3.5 运算符 39
3.5.1 自增运算符与自减运算符 40
3.5.2 关系运算符与boolean运算符 40
3.5.3 位运算符 41
3.5.4 数学函数与常量 42
3.5.5 数值类型之间的转换 43
3.5.6 强制类型转换 43
3.5.7 括号与运算符级别 44
3.5.8 枚举类型 45
3.6 字符串 45
3.6.1 子串 46
3.6.2 拼接 46
3.6.3 不可变字符串 46
3.6.4 检测字符串是否相等 47
3.6.5 空串与Null串 48
3.6.6 代码点与代码单元 49
3.6.7 字符串API 49
3.6.8 阅读联机API文档 51
3.6.9 构建字符串 53
3.7 输入输出 54
3.7.1 读取输入 54
3.7.2 格式化输出 56
3.7.3 文件输入与输出 60
3.8 控制流程 61
3.8.1 块作用域 62
3.8.2 条件语句 62
3.8.3 循环 65
3.8.4 确定循环 68
3.8.5 多重选择：switch语句 71
3.8.6 中断控制流程语句 74
3.9 大数值 76
3.10 数组 78
3.10.1 for each循环 79
3.10.2 数组初始化以及匿名数组 80
3.10.3 数组拷贝 80
3.10.4 命令行参数 81
3.10.5 数组排序 82
3.10.6 多维数组 85
3.10.7 不规则数组 87
第4章 对象与类 91
4.1 面向对象程序设计概述 91
4.1.1 类 92
4.1.2 对象 93
4.1.3 识别类 93
4.1.4　类之间的关系 94
4.2 使用预定义类 95
4.2.1 对象与对象变量 95
4.2.2 Java类库中的Gregorian-Calendar类 98
4.2.3 更改器方法与访问器方法 100
4.3 用户自定义类 106
4.3.1 Employee类 106
4.3.2 多个源文件的使用 108
4.3.3 剖析Employee类 109
4.3.4 从构造器开始 110
4.3.5 隐式参数与显式参数 111
4.3.6 封装的优点 112
4.3.7 基于类的访问权限 114
4.3.8 私有方法 114
4.3.9 final实例域 115
4.4 静态域与静态方法 115
4.4.1 静态域 115
4.4.2 静态常量 116
4.4.3 静态方法 117
4.4.4 工厂方法 118
4.4.5 main方法 118
4.5 方法参数 121
4.6 对象构造 126
4.6.1 重载 126
4.6.2 默认域初始化 126
4.6.3 无参数的构造器 127
4.6.4 显式域初始化 128
4.6.5 参数名 129
4.6.6 调用另一个构造器 129
4.6.7 初始化块 130
4.6.8 对象析构与finalize方法 134
4.7 包 134
4.7.1 类的导入 134
4.7.2 静态导入 136
4.7.3 将类放入包中 136
4.7.4 包作用域 139
4.8 类路径 140
4.9 文档注释 143
4.9.1 注释的插入 143
4.9.2 类注释 144
4.9.3 方法注释 144
4.9.4 域注释 145
4.9.5 通用注释 145
4.9.6 包与概述注释 146
4.9.7 注释的抽取 146
4.10 类设计技巧 147
第5章 继承 150
5.1 类、超类和子类 150
5.1.1 继承层次 156
5.1.2 多态 157
5.1.3 动态绑定 158
5.1.4 阻止继承：final类和方法 160
5.1.5 强制类型转换 161
5.1.6 抽象类 163
5.1.7 受保护访问 168
5.2 Object：所有类的超类 169
5.2.1 equals方法 169
5.2.2 相等测试与继承 171
5.2.3 hashCode方法 173
5.2.4 toString方法 175
5.3 泛型数组列表 181
5.3.1 访问数组列表元素 183
5.3.2 类型化与原始数组列表的兼容性 186
5.4 对象包装器与自动装箱 187
5.5 参数数量可变的方法 189
5.6 枚举类 191
5.7 反射 192
5.7.1 Class类 193
5.7.2 捕获异常 195
5.7.3 利用反射分析类的能力 196
5.7.4 在运行时使用反射分析对象 201
5.7.5 使用反射编写泛型数组代码 206
5.7.6 调用任意方法 209
5.8 继承设计的技巧 212
第6章 接口与内部类 215
6.1 接口 215
6.1.1 接口的特性 220
6.1.2 接口与抽象类 222
6.2 对象克隆 222
6.3 接口与回调 228
6.4 内部类 231
6.4.1 使用内部类访问对象状态 232
6.4.2 内部类的特殊语法规则 235
6.4.3 内部类是否有用、必要和安全 236
6.4.4 局部内部类 238
6.4.5 由外部方法访问final变量 239
6.4.6 匿名内部类 241
6.4.7 静态内部类 244
6.5 代理 247
第7章 图形程序设计 253
7.1 Swing概述 253
7.2 创建框架 257
7.3 框架定位 259
7.3.1 框架属性 261
7.3.2 确定合适的框架大小 262
7.4 在组件中显示信息 265
7.5 处理2D图形 270
7.6 使用颜色 277
7.7 文本使用特殊字体 280
7.8 显示图像 287
第8章 事件处理 291
8.1 事件处理基础 291
8.1.1 实例：处理按钮点击事件 293
8.1.2 建议使用内部类 297
8.1.3 创建包含一个方法调用的监听器 299
8.1.4 实例：改变观感 300
8.1.5 适配器类 303
8.2 动作 306
8.3 鼠标事件 312
8.4 AWT事件继承层次 318
第9章 Swing用户界面组件 322
9.1 Swing和模型–视图–控制器设计模式 322
9.1.1 设计模式 322
9.1.2 模型–视图–控制器模式 323
9.1.3 Swing按钮的模型–视图–控制器分析 326
9.2 布局管理概述 327
9.2.1 边框布局 329
9.2.2 网格布局 331
9.3 文本输入 334
9.3.1 文本域 334
9.3.2 标签和标签组件 336
9.3.3 密码域 337
9.3.4 文本区 338
9.3.5 滚动窗格 338
9.4 选择组件 340
9.4.1 复选框 340
9.4.2 单选按钮 342
9.4.3 边框 345
9.4.4 组合框 349
9.4.5 滑动条 352
9.5 菜单 357
9.5.1 菜单创建 357
9.5.2 菜单项中的图标 359
9.5.3 复选框和单选按钮菜单项 360
9.5.4 弹出菜单 361
9.5.5 快捷键和加速器 362
9.5.6 启用和禁用菜单项 364
9.5.7 工具栏 368
9.5.8 工具提示 369
9.6 复杂的布局管理 370
9.6.1 网格组布局 372
9.6.2 组布局 380
9.6.3 不使用布局管理器 388
9.6.4 定制布局管理器 388
9.6.5 遍历顺序 392
9.7 对话框 393
9.7.1 选项对话框 393
9.7.2 创建对话框 402
9.7.3 数据交换 406
9.7.4 文件对话框 411
9.7.5 颜色选择器 421
第10章 部署应用程序和applet 426
10.1 JAR文件 426
10.1.1 清单文件 427
10.1.2 可运行JAR文件 428
10.1.3 资源 429
10.1.4 密封 431
10.2 Java Web Start 432
10.2.1 沙箱 435
10.2.2 签名代码 436
10.2.3 JNLP API 438
10.3 applet 445
10.3.1 一个简单的applet 445
10.3.2 applet的HTML标记和属性 448
10.3.3 object标记 451
10.3.4 使用参数向applet传递信息 451
10.3.5 访问图像和音频文件 456
10.3.6 applet上下文 457
10.4 应用程序首选项存储 460
10.4.1 属性映射 460
10.4.2 Preferences API 464
第11章 异常、断言、日志和调试 471
11.1 处理错误 471
11.1.1 异常分类 473
11.1.2 声明已检查异常 474
11.1.3 如何抛出异常 476
11.1.4 创建异常类 477
11.2 捕获异常 478
11.2.1 捕获多个异常 480
11.2.2 再次抛出异常与异常链 481
11.2.3 finally子句 482
11.2.4 带资源的try语句 486
11.2.5 分析堆栈跟踪元素 487
11.3 使用异常机制的技巧 490
11.4 使用断言 492
11.4.1 启用和禁用断言 493
11.4.2 使用断言完成参数检查 494
11.4.3 为文档假设使用断言 495
11.5 记录日志 496
11.5.1 基本日志 496
11.5.2 高级日志 497
11.5.3 修改日志管理器配置 499
11.5.4 本地化 500
11.5.5 处理器 500
11.5.6 过滤器 503
11.5.7 格式化器 504
11.5.8 日志记录说明 504
11.6 调试技巧 512
11.7 GUI程序排错技巧 516
11.8 使用调试器 523
第12章 泛型程序设计 527
12.1 为什么要使用泛型程序设计 527
12.2 定义简单泛型类 529
12.3 泛型方法 531
12.4 类型变量的限定 532
12.5 泛型代码和虚拟机 534
12.5.1 翻译泛型表达式 535
12.5.2 翻译泛型方法 536
12.5.3 调用遗留代码 537
12.6 约束与局限性 538
12.6.1 不能用基本类型实例化类型参数 538
12.6.2 运行时类型查询只适用于原始类型 539
12.6.3 不能创建参数化类型的数组 539
12.6.4 Varargs警告 540
12.6.5 不能实例化类型变量 541
12.6.6 泛型类的静态上下文中类型变量无效 542
12.6.7 不能抛出或捕获泛型类的实例 543
12.6.8 注意擦除后的冲突 545
12.7 泛型类型的继承规则 546
12.8 通配符类型 547
12.8.1 通配符的超类型限定 549
12.8.2 无限定通配符 551
12.8.3 通配符捕获 551
12.9 反射和泛型 553
12.9.1 使用Class<T>参数进行类型匹配 554
12.9.2 虚拟机中的泛型类型信息 555
第13章 集合 560
13.1 集合接口 560
13.1.1 将集合的接口与实现分离 560
13.1.2 Java类库中的集合接口和迭代器接口 562
13.2 具体的集合 567
13.2.1 链表 568
13.2.2 数组列表 576
13.2.3 散列集 576
13.2.4 树集 579
13.2.5 对象的比较 580
13.2.6 队列与双端队列 585
13.2.7 优先级队列 586
13.2.8 映射表 587
13.2.9 专用集与映射表类 591
13.3 集合框架 595
13.3.1 视图与包装器 598
13.3.2 批操作 604
13.3.3 集合与数组之间的转换 605
13.4 算法 606
13.4.1 排序与混排 607
13.4.2 二分查找 609
13.4.3 简单算法 610
13.4.4 编写自己的算法 612
13.5 遗留的集合 613
13.5.1 Hashtable类 613
13.5.2 枚举 613
13.5.3 属性映射表 614
13.5.4 栈 615
13.5.5 位集 615
第14章 多线程 620
14.1 什么是线程 620
14.2 中断线程 630
14.3 线程状态 633
14.3.1 新创建线程 633
14.3.2 可运行线程 633
14.3.3 被阻塞线程和等待线程 634
14.3.4 被终止的线程 634
14.4 线程属性 636
14.4.1 线程优先级 636
14.4.2 守护线程 637
14.4.3 未捕获异常处理器 637
14.5 同步 638
14.5.1 竞争条件的一个例子 638
14.5.2 竞争条件详解 642
14.5.3 锁对象 644
14.5.4 条件对象 647
14.5.5 synchronized关键字 651
14.5.6 同步阻塞 655
14.5.7 监视器概念 656
14.5.8 Volatile域 657
14.5.9 final变量 658
14.5.10 原子性 658
14.5.11 死锁 658
14.5.12 线程局部变量 660
14.5.13 锁测试与超时 661
14.5.14 读/写锁 663
14.5.15 为什么弃用stop和suspend方法 663
14.6 阻塞队列 665
14.7 线程安全的集合 672
14.7.1 高效的映射表、集合和队列 672
14.7.2 写数组的拷贝 674
14.7.3 较早的线程安全集合 674
14.8 Callable与Future 675
14.9 执行器 679
14.9.1 线程池 680
14.9.2 预定执行 683
14.9.3 控制任务组 684
14.9.4 Fork-Join框架 686
14.10 同步器 688
14.10.1 信号量 689
14.10.2 倒计时门栓 689
14.10.3 障栅 689
14.10.4 交换器 690
14.10.5 同步队列 690
14.11 线程与Swing 690
14.11.1 运行耗时的任务 692
14.11.2 使用Swing工作线程 696
14.11.3 单一线程规则 701
附录　Java关键字 703

.　　关于本书
　　第1章概述Java与其他程序设计语言不同的性能。解释这种语言的设计初衷，以及在哪些方面达到了预期的效果。然后，简要叙述Java诞生和发展的历史。
　　第2章详细地论述如何下载和安装JDK以及本书的程序示例。然后，通过编译和运行三个典型的Java程序（一个控制台应用、一个图形应用、一个applet），指导读者使用简易的JDK、可启用Java的文本编辑器以及一个Java IDE。
　　第3章开始讨论Java 语言。这一章涉及的基础知识有变量、循环以及简单的函数。对于C或C++程序员来说，学习这一章的内容将会感觉一帆风顺，因为这些语言特性的语法本质上与C语言相同。对于没有C语言程序设计背景，但使用过其他程序设计语言（如Visual Basic）的程序员来说，仔细地阅读这一章是非常必要的。
　　面向对象程序设计（Object-Oriented Programming, OOP）是当今程序设计的主流，而Java是一种完全面向对象的语言。第4章将介绍面向对象两个基本成分中最重要的—封装，以及Java语言实现封装的机制，即类与方法。除了Java语言规则之外，还对如何正确地进行OOP设计给出了忠告。最后，介绍奇妙的javadoc工具，它将代码注释转换为超链接的网页。熟悉C++的程序员可以快速地浏览这一章，而没有面向对象程序设计背景的程序员，应在进一步学习Java之前花一些时间了解OOP的有关概念。
　　类与封装仅仅是OOP中的一部分，第5章将介绍另一部分—继承。继承使程序员可以使用现有的类，并根据需要进行修改。这是Java程序设计中的基础。Java中的继承机制与C++的继承机制十分相似。C++程序员只需关注两种语言的不同之处即可。
　　第6章展示如何使用Java的接口。接口可以让你的理解超越第5章的简单继承模型。掌握接口的使用将可以获得Java的完全的面向对象程序设计的能力。本章还将介绍Java的一个有用的技术特性—内部类。内部类可以使代码更清晰、更简洁。
　　第7章开始细致地讨论应用程序设计。每一个Java程序员都应该了解一些图形用户界面程序设计的知识，本卷包含了其中的基本内容部分。本章将展示如何制作窗口、如何在窗口中绘图、如何用几何图形作画、如何用多种字体格式化文本以及如何显示图像。
　　第8章详细讨论AWT（Abstract Window Toolkit ）的事件模型。我们将介绍如何编写代码来响应鼠标点击或按键等事件。同时，还将介绍如何处理基本的GUI元素，比如：按钮和面板。
　　第9章详细讨论Swing GUI工具箱。Swing工具箱允许建立一个跨平台的图形用户界面。本章将介绍如何建立各种各样的按钮、文本组件、边框、滑块、列表框、菜单以及对话框等。一些更高级的组件将在卷II中讨论。
　　第10章阐述如何部署自己编写的应用程序或applet。在这里将描述如何将应用程序打包到JAR文件中，以及如何使用Java的Web Start和applet机制在Internet上发布应用程序。最后，将解释Java程序部署之后如何存储和检索配置信息。
　　第11章讨论异常处理，即Java的健壮机制，它用于处理调试好的程序可能出现意外的情况。异常提供了一种将正常的处理代码与错误处理代码分开的有效手段。当然，即使程序包含处理所有异常情况的功能，依然有可能无法按照预计的方式工作。这一章的后半部分将给出大量的实用调试技巧。最后，将指导你完成一个完整的示例调试过程。
　　第12章概要介绍泛型程序设计，这是Java SE 5.0的一项重要改进。泛型程序设计使得程序拥有更好的可读性和安全性。在这里，将展示如何使用强类型机制，而舍弃不安全的强制类型转换，以及如何处理与旧版本Java兼容而带来的复杂问题。
　　第13章介绍Java平台的集合框架。当需要将大量对象收集到一起，并在以后要对它们进行检索时，可能会想要使用集合，这是目前最为合适的做法，它取代了将这些元素放置在数组中的做法。本章将介绍如何使用预先建立好的标准集合。
　　第14章是本书的最后一章。在这一章中将介绍多线程，这是一种可以让程序任务并行执行的特性（线程是程序中的控制流），并阐述如何建立线程、如何处理线程的同步问题。从Java SE 5.0开始，多线程有了很大的改进，本章将介绍所有这些新的机制。
　　附录列出了Java语言的保留字。
　　约定
　　本书使用以下图标表示特殊内容。
　　注释：“注释”信息会用这样的“注释”图标标识。
　　提示：“提示”信息会用这样的“提示”图标标识。
　　警告：对于可能出现的危险，我们用一个“警告”图标做出警示。
　　C++注释：在本书中有许多用来解释Java与C++之间不同的C++注释。对于没有C++程序设计背景，或者不擅长C++程序设计、把它当做一场噩梦不愿再想起的程序员来说，可以跳过这些注释。
　　应用程序编程接口
　　Java带有一个很大的程序设计库，即应用程序编程接口。第一次使用API调用时，将会在该节的结尾给出一个概要描述。这些描述十分通俗易懂，希望能够比联机API文档提供更多的信息。类、接口或方法名后面的编号是介绍该特性的JDK版本号。
　　程序（源代码见本书网站）以如下形式给出：
　　程序清单1-1 inputTest/InputTest.java
　　示例代码
　　本书的网站http://horstmann.conl/corejava以压缩的形式提供了书中的所有示例代码。可以用熟悉的解压缩程序或者用Java开发工具箱中的jar实用程序解压这个文件。有关安装Java开发工具箱和示例程序的详细信息请参看第2章。
　　

.　　凭借Java当前版本的使用经验，给出对这些术语的理解。
　　 注释：写这本书时，白皮书可以在www.oracle.com/technetwork/java/langenv-140151.html.上找到。对于11个关键术语的论述请参看http://labs.oracle.com/features/tenyeares/volcd/papers/7Gosling.pdf。
　　1.2.1 简单性
　　人们希望构建一个无须深奥的专业训练就可以进行编程的系统，并且要符合当今的标准惯例。因此，尽管人们发现C++不太适用，但在设计Java的时候还是尽可能地接近C++，以便系统更易于理解。Java剔除了C++中许多很少使用、难以理解、易混淆的特性。在目前看来，这些特性带来的麻烦远远多于其带来的好处。
　　的确，Java语法是C++语法的一个“纯净”版本。这里没有头文件、指针运算（甚至指针语法）、结构、联合、操作符重载、虚基类等（请参阅本书各个章节给出的C++注释，那里比较详细地解释了Java与C++之间的区别）。然而，设计者并没有试图清除C++中所有不适当的特性。例如，switch语句的语法在Java中就没有改变。如果知道C++就会发现可以轻而易举地将其转换成Java。
　　如果已经习惯于使用可视化的编程环境（例如Visual Basic），你就不会觉得Java简单了。Java有许多奇怪的语法（尽管掌握其要领并不需要很长时间），更重要的是，使用Java需要自己编写大量的程序。Visual Basic的魅力在于它的可视化设计环境几乎自动地为应用程序提供了大量的基础结构。而使用Java实现同样的功能却需要手工编制代码，通常代码量还相当大。然而，已经有一些支持“拖放”风格程序开发的第三方开发环境。
　　简单的另一个方面是小。Java的目标之一是支持开发能够在小型机器上独立运行的软件。基本的解释器以及类支持大约仅为40KB；再加上基础的标准类库和对线程的支持（基本上是一个自包含的微内核）大约需要增加175KB。
　　在当时，这是一个了不起的成就。当然，由于不断的扩展，类库已经相当庞大了。现在有一个独立的具有较小类库的Java微型版（Java Micro Edition）用于嵌入式设备。
　　1.2.2 面向对象
　　简单地讲，面向对象设计是一种程序设计技术。它将重点放在数据（即对象）和对象的接口上。用木匠打一个比方，一个“面向对象的”木匠始终关注的是所制作的椅子，第二位才是所使用的工具；一个“非面向对象的”木匠首先考虑的是所用的工具。在本质上，Java的面向对象能力与C++是一样的。
　　在过去的40年里，面向对象已经证明了自身的价值，一种现代的程序设计语言不使用面向对象技术简直让人难以置信。的确，Java的面向对象特性与C++旗鼓相当。Java与C++的主要不同点在于多继承，在Java中，取而代之的是简单的接口概念，以及Java的元类（metaclass）模型（有关这部分内容将在第5章中讨论）。
　　 注释：如果没有使用面向对象程序设计语言的经验，你一定要仔细阅读第4章~第6章。这些章节解释了什么是面向对象程序设计以及在编程实现复杂的项目时为什么比传统的像C或Basic这样的面向过程的语言更加有效。
　　1.2.3 网络技能
　　Java有一个扩展的例程库，用于处理像HTTP和FTP之类的TCP/IP协议。Java应用程序能够通过URL打开和访问网络上的对象，其便捷程度就好像访问本地文件一样。
　　人们已经看到Java的网络能力强大且易于使用。任何曾经试图使用其他语言进行网络编程的人都会惊呼Java竟然把类似打开socket连接这类繁重的任务都变得如此简单（在本书的卷II中介绍网络连接）。另外，远程方法调用机制使得分布式对象之间可以进行通信（也将在卷II中介绍）。
　　1.2.4 健壮性
　　Java的设计目标之一在于使得Java编写的程序具有多方面的可靠性。Java投入了大量的精力进行早期的问题检测、后期动态的（运行时）检测，并消除了有出错倾向的状态……Java和C++最大的不同在于Java采用的指针模型可以消除重写内存和损坏数据的可能性。
　　这个特性非常有用。Java编译器能够检测许多在其他语言中仅在运行时刻才能够检测出来的问题。至于第二点，对于曾经花费几个小时来检查由于指针bug而引起内存冲突的人来说，一定很喜欢Java的这一特性。
　　如果曾经只使用过Visual Basic这类没有显式指针的语言，你就会感觉这么说似乎有些小题大做了。然而，C程序员就没有这样幸运了。他们需要利用指针存取字符串、数组、对象，甚至文件。在Visual Basic中，根本不必使用指针访问这些实体，也不必关心有关内存分配的问题。另一方面，在没有指针的语言中，许多数据结构很难实现。Java具有双方的优势。它不需要使用指针构造诸如字符串、数组这样的结构。如果必要的话，它也能够具有指针的能力，如链表。Java绝对是安全的，其原因是永远不会存取一个“坏的”指针，造成内存分配的错误，也不必防范内存泄漏。
　　1.2.5 安全性
　　Java适用于网络/分布式环境。为了达到这个目标，在安全方面投入了很大精力。使用Java可以构建防病毒、防篡改的系统。
　　本书的第1版曾经说过：“永远不要把话说绝！”事实证明这是正确的。在Java开发工具箱第1版启用后不久，普林斯顿大学的一些安全专家就发现了在JDK1.0中的某些安全特性方面存在着一些非常隐蔽的bug。Sun Microsystems 大力支持对Java的安全性的研究，制定了供人们使用的规范，实现了虚拟机和安全库，并迅速地处理了所有已知的安全bug。在任何情况下，蒙骗Java的安全机制都是十分困难的。现在，发现bug的技术越来越强，数目越来越少。
　　从一开始，Java就设计成能够防范各种攻击，其中包括：
　　运行时堆栈溢出。如，蠕虫等病毒常用的攻击手段。
　　在自己的处理空间之外破坏内存。
　　未经授权读写文件。
　　许多安全特性相继不断地加入到Java中。自从Java 1.1问世以来，Java就有了数字签名类（digitally signed class）的概念（请参看卷II）。通过数字签名类，可以确定类的作者。如果信任这个类的作者，这个类就可以在你的机器上拥有更多的权限。
　　 注释：来自微软的基于ActiveX技术的竞争代码传输机制，其安全性完全依赖于数字签名。这显然是不够的，因为微软自身产品的任何用户都可以证实，来自知名提供商的程序会崩溃并对系统产生危害。Java的安全机制比ActiveX要强得多，因为它是在应用程序运行时加以控制并制止恶意性破坏的。
　　1.2.6 体系结构中立
　　编译器生成一个体系结构中立的目标文件格式，这是一种编译过的代码，只要有Java运行时系统，就可以在许多处理器上运行。Java编译器通过生成与特定的计算机体系结构无关的字节码指令来实现这一特性。精心设计的字节码不仅可以很容易地在任何机器上解释执行，而且还可以迅速地翻译成本地机器的代码。
　　这并不是什么新的思路。40多年以前，Niklaus Wirth 实现的原始 Pascal以及UCSD Pascal系统都使用了这种技术。
　　当然，解释字节码肯定会比全速运行机器指令慢很多。所以说，这是不是一个好的思路还很难讲！然而，虚拟机有一个选项，可以将使用最频繁的字节码序列翻译成机器码，这一过程被称为即时编译。这一策略已经证明十分有效，致使微软的.NET平台也依赖于虚拟机。
　　虚拟机还有一些其他的优点。虚拟机可以检测指令序列的行为，以增强其安全性。有些程序还可以快速地生成字节码，并动态地增强所运行程序的处理能力。
　　1.2.7 可移植性
　　与C和C++不同，Java规范中没有“依赖具体实现”的地方。基本数据类型的大小以及有关算法都做了明确的说明。
　　例如，Java中的int永远为32位的整数，而在C/C++中，int可能是16位整数、32位整数，也可能是编译器提供商指定的其他大小。唯一的限制只是int类型的大小不能低于short int，并且不能高于long int。在Java中，数据类型具有固定的大小，这消除了代码移植时令人头痛的主要问题。二进制数据以固定的格式进行存储和传输，消除了字节顺序的困扰。字符串是用标准的Unicode格式存储的。
　　作为系统组成部分的类库，定义了可移植的接口。例如，有一个抽象的Window类给出了在UNIX、Windows和Macintosh环境下的不同实现。
　　凡是尝试过的人都知道，要编写一个在Windows、Macintosh和10种不同风格的UNIX上看起来都不错的程序有多么困难。Java 1.0就尝试着做了这么一个壮举，发布了一个将常用的用户界面元素映射到不同平台上的简单工具箱。遗憾的是，花费了大量的心血，却构建了一个在各个平台上都难以让人接受的库（而且，在不同平台的图形实现中有不同的bug）。不过，这毕竟是个开端。对于许多应用问题来说，可移植性比华而不实的用户界面更加重要；而且这些应用程序从Java的早期版本中获益匪浅。现在，用户界面工具箱已经完全重写了，不再依赖于主机的用户界面。现在的Java版本比早期版本更加稳定，更加吸引人。
　　1.2.8 解释型
　　Java解释器可以在任何移植了解释器的机器上执行Java字节码。由于链接是一个增量式且轻量级的过程，所以，开发过程也变得更加快捷，更加具有探索性。
　　增量式链接有其优势，但给开发过程带来的好处显然是言过其实了。事实上，早期的Java开发工具的速度相当慢。现在，使用即时编译器将字节码翻译成机器码。
　　1.2.9 高性能
　　尽管对解释后的字节码性能已经比较满意，但在有些场合下还需要更加高效的性能。字节码可以（在运行时刻）快速地翻译成运行这个应用程序的特定CPU的机器码。
　　使用Java的头几年，许多用户不同意这样的看法：性能就是“适用性更强”。然而，现在的即时编译器已经非常出色，以至于成了传统编译器的竞争对手。在某些情况下，甚至超越了传统编译器，其原因是它们含有更多的可用信息。例如，即时编译器可以监控经常执行哪些代码并优化这些代码以提高速度。更为复杂的优化是消除函数调用（即“内嵌”）。即时编译器知道哪些类已经加载。如果基于当前加载的类集，且特定的函数不被覆盖的话就可以内嵌。必要时，还可以撤销优化。
　　1.2.10 多线程
　　多线程可以带来更好的交互响应和实时行为。
　　如果曾经使用过其他语言编写多线程的应用程序，就会对Java多线程处理的便捷性惊叹不已。只要操作系统支持，Java中的线程就可以利用多个处理器。在底层，主流平台的线程实现机制各不相同，Java并没有花费太大的力气对此实现平台无关性。在不同的机器上，只是调用多线程的代码完全相同；Java把多线程的实现交给了底层的操作系统或线程库来完成。尽管如此，多线程编译的简单性是Java成为颇具魅力的服务器端开发语言的主要原因之一。
　　1.2.11 动态性
　　从各种角度看，Java与C或C++相比更加具有动态性。它能够适应不断发展的环境。库中可以自由地添加新方法和实例变量，而对客户端却没有任何影响。在Java中找出运行时类型信息十分简单。
　　当需要将某些代码添加到正在运行的程序中时，动态性将是一个非常重要的特性。一个很好的例子是：从Internet上下载代码，然后在浏览器上运行。在Java 1.0中，不能直接获得运行时的类型信息，而Java的当前版本允许程序员知道对象的结构和行为。这对于必须在运行时分析对象的系统来说非常有用。这些系统有：Java GUI 构建器、智能调试器、可插拔组件以及对象数据库。
　　 注释：Java成功地推出后不久，微软就发布了一个叫做J++的产品，它与Java有相同的编程语言以及虚拟机。现在，微软不再支持J++，取而代之的是另一种被称为C# 的语言。C# 与Java有很多相似之处，然而使用的却是完全不同的虚拟机。甚至还有一种J# 语言可将J++的应用迁移到使用C# 的虚拟机上。本书不准备介绍J++、C#或J#语言。
　　1.3 Java applet与Internet
　　这里的想法很简单：用户从Internet下载Java字节码，并在自己的机器上运行。在网页中运行Java程序称为applet。为了使用applet，需要启用Java的Web浏览器执行字节码。由于Sun公司负责发放Java源代码的许可证，并坚持不允许对语言和基本类库的结构做出任何修改，因此，Java的applet应该可以运行在任何启用Java浏览器上，并且无论何时访问包含applet的网页，都会得到程序的最终版本。最重要的是，要感谢虚拟机的安全机制，它让我们不必再担心来自恶意代码的攻击。
　　用户下载一个applet 就如同在网页中嵌入一幅图片。applet成了页面的一部分。文本环绕着applet所占据的空间周围。关键一点是图片是活动的。它可以对用户命令做出响应，改变外观，在运行它的计算机与提供它的计算机之间传递数据。
　　图1-1展示了一个很好的动态网页的示例。Jmol applet显示了分子结构，这将需要相当复杂的计算。在这个网页中，可以利用鼠标进行旋转，调整焦距等操作，以便更加细致地理解分子结构。用静态网页将无法实现这种直接的操作，而applet却可以达到此目的（可以在http://jmol.sourceforge.net上找到这个applet）。
　　图1-1 Jmol applet
　　当applet首次出现时，人们欣喜若狂。许多人相信applet的魅力将会导致Java迅速地流行起来。然而，初期的兴奋很快就淡化了。不同版本的Netscape与Internet Explorer运行不同版本的Java，其中有些早已过时。这种糟糕的情况导致更加难于利用Java的最新版本开发applet。今天，当需要在浏览器中显示动态效果时，大多数网页都直接使用JavaScript或Flash。另外，Java已经成为用来开发服务器端应用程序的最流行的语言，使用这些服务器端应用程序可以产生网页、运行后端逻辑。
　　1.4 Java发展简史
　　本节将介绍Java的发展简史。这些参考资料来源于多方面的出版物（最重要的是SunWorld的在线杂志1995年7月刊上对Java创建者的专访）。
　　Java的历史要追溯到1991年，由Patrick Naughton及其伙伴James Gosling（一个全能的计算机奇才）带领的Sun公司的工程师小组想要设计一种小型的计算机语言，主要用于像有线电视转换盒这类的消费设备。由于这些消费设备的处理能力和内存都很有限，所以语言必须非常小且能够生成非常紧凑的代码。另外，由于不同的厂商会选择不同的中央处理器（CPU），因此这种语言的关键是不能与任何特定的体系结构捆绑在一起。这个项目被命名为“Green”。
　　代码短小、紧凑且与平台无关，这些要求促使开发团队联想起很早以前的一种模型，某些Pascal的实现曾经在早期的PC上尝试过这种模型。以Pascal的发明者Niklaus Wirth为先驱，率先设计出一种为假想的机器生成中间代码的可移植语言（假想的机器称为虚拟机—Java虚拟机即JVM的命名由此而来）。这种中间代码可以应用于所有已经正确安装解释器的机器上。Green项目工程师也使用了虚拟机，从而解决了课题中的主要问题。
　　不过，Sun公司的人都有UNIX的应用背景。因此，所开发的语言以C++为基础，而不是Pascal。特别是这种语言是面向对象的，而不是面向过程的。就像Gosling在专访中谈到的：“毕竟，语言只是实现目标的工具，而不是目标本身”。Gosling把这种语言称为“Oak”（这么起名的原因大概是因为他非常喜欢自己办公室外的橡树）。Sun公司的人后来发现Oak是一种已有的计算机语言的名字，于是，将其改名为Java。事实证明这是一个极好的选择。
　　1992年，Green项目发布了它的第一个产品，称之为“*7”。这个产品具有非常智能的远程控制（其能力相当于长6英寸、宽4英寸、高4英寸的SPARC工作站）。遗憾的是，Sun公司对生产这个产品并不感兴趣，Green项目组的人员必须找出其他的方法来将他们的技术推向市场。然而，没有一个标准消费品公司对此感兴趣。于是，Green项目组竞标了一个提供视频点播等新型服务的有线电视盒的项目，但没有成功（有趣的是，得到这个项目的公司的领导恰恰是开创Netscape公司的Jim Clark。Netscape公司后来对Java的成功给予了很大的帮助）。
　　Green项目（这时换了一个新名字—“First Person公司”）花费了1993年一整年以及1994年的上半年，一直在苦苦寻求其技术的买家。然而，一个也没有找到（Patrick Naughton，项目组的创立人之一，也是完成此项目大多数市场工作的人，声称为了销售这项技术，累计飞行了300 000英里）。1994年First Person公司解散了。
　　当这一切在Sun 公司中继续进行的时候，Internet的万维网也日渐发展壮大。Web 的关键是把超文本页面转换到屏幕上的浏览器。1994年大多数人都在使用Mosaic，这是一个1993年出自伊利诺斯大学超级计算中心的非商业化的Web浏览器（Mosaic的一部分是由Marc Andreessen编写的。当时，他作为一名参加半工半读项目的本科生，编写了这个软件，每小时的薪水只有6.85美元。他后来成了Netscape公司的创始人之一和技术总监，可谓名利双收）。
　　在接受SunWorld 采访的时候，Gosling 说在1994年中期，Java语言的开发者意识到：“我们能够建立一个最酷的浏览器。我们已经拥有在客户机/服务器主流模型中所需要的体系结构中立、实时、可靠、安全—这些在工作站环境并不太重要，所以，我们决定开发浏览器。”
　　实际的浏览器是由Patrick Naughton和Jonathan Payne开发的，并演变为HotJava浏览器。为了炫耀Java语言超强的能力，HotJava浏览器采用Java编写。然而，设计者也非常清楚现在所谓的applet的威力，因此他们让HotJava浏览器具有执行网页中内嵌代码的能力。这一“技术印证”在1995年5月23日的SunWorld上得到展示，同时引发了人们延续至今的对Java的狂热追逐。
　　1996年年初，Sun发布了Java的第1个版本。人们很快地意识到Java1.0不能用来进行真正的应用开发。的确，可以使用Java 1.0来实现在画布上随机跳动的神经质的文本applet，但它却没有提供打印功能。坦率地说，Java 1.0的确没有为其黄金时期的到来做好准备。后来的Java1.1弥补了其中的大多明显的缺陷，大大改进了反射能力，并为GUI编程增加了新的事件处理模型。不过它仍然具有很大的局限性。
　　1998年JavaOne会议的头号新闻是即将发布Java 1.2版。这个版本取代了早期玩具式的GUI，并且它的图形工具箱更加精细而具有可伸缩性，更加接近“一次编写，随处运行”的承诺。在1998年12月Java 1.2发布三天之后，Sun公司市场部将其名称改为更加吸引人的“Java 2标准版软件开发工具箱1.2版”。
　　除了“标准版”之外，Sun还推出了两个其他的版本：一个是用于手机等嵌入式设备的“微型版”；另一个是用于服务器端处理的“企业版”。本书主要讲述标准版。
　　标准版的1.3和1.4版本对最初的Java 2版本做出了某些改进，扩展了标准类库，提高系统性能。当然，还修正了一些bug。在此期间，Java applet采用低调姿态，并淡化了客户端的应用，但Java却成为服务器端应用的首选平台。
　　5.0版是自1.1版以来第一个对Java语言做出重大改进的版本（这一版本原来被命名为1.5版，在2004年的JavaOne会议之后，版本数字升至5.0）。经历了多年的研究，这个版本添加了泛型类型（generic type）（类似于C++的模板），其挑战性在于添加这一特性并没有对虚拟机做出任何修改。另外，还有几个受C#启发的很有用的语言特性：“for each”循环、自动装箱和元数据。
　　版本6（没有后缀.0）于2006年年末发布。同样，这个版本没有对语言方面再进行改进。但是，改进了其他性能，并增强了类库。随着数据中心越来越依赖于商业硬件而不是专用服务器，Sun Microsystems终于沦陷，于2009年被Oracle收购。Java的开发停滞了很长一段时间。直到2011年Oracle发布了Java的一个新版本，Java 7，其中只做了一些简单的改进，而决定将重要的改进推迟到Java 8，该版本将在2013年发布。
　　表1-1展示了Java语言以及类库的发展状况。可以看到，应用程序接口（API）的规模发生了惊人的变化。
　　表1-1 Java语言的发展状况
　　版 本 年 份 语言新特性 类与接口的数量
　　1.0 1996 语言本身 211
　　1.1 1997 内部类 477
　　1.2 1998 无 1524
　　1.3 2000 无 1840
　　1.4 2002 断言 2723
　　5.0 2004 泛型类型、“for each”循环、可变元参数、自动装箱、元数据、枚举、静态导入 3279
　　6 2006 无 3793
　　7 2011 基于字符串的switch、变形操作符、二进制字面量、异常处理改进 4024
　　1.5 关于Java的常见误解
　　在结束本章之前，我们列出了一些关于Java的常见误解，同时给出了解释。
　　1）Java是HTML的扩展。
　　Java是一种程序设计语言；HTML是一种描述网页结构的方式。除了用于在网页上放置Java applet的HTML扩展之外，两者没有任何共同之处。
　　2）使用XML，就不需要Java。
　　Java是一种程序设计语言；XML是一种描述数据的方式。可以使用任何一种程序设计语言处理XML数据，而Java API对XML处理提供了很好的支持。此外，许多重要的第三方XML工具采用Java编写。有关这方面更加详细的信息请参看卷II。
　　3）Java是一种非常容易学习的程序设计语言。
　　像Java这种功能强大的语言大都不太容易学习。首先，必须将编写玩具式程序的轻松和开发实际项目的艰难区分开来。需要注意的是：本书只用了4章讨论Java语言。在两卷中，其他的章节介绍如何使用Java类库将Java语言应用到实际中去。Java类库包含了数千种类和接口与几万个方法。幸运的是，并不需要知道它们中的每一个，然而，要想Java解决实际问题，还是需要了解不少内容的。
　　4）Java将成为适用于所有平台的通用性编程语言。
　　从理论上讲，这是完全有可能的。的确，除了微软之外的每一个厂商都希望如此。然而，有很多在桌面计算机上已经工作良好的应用程序，在其他设备上或浏览器中或许不能正常地工作。同时，在编写这些应用程序时，利用了相应处理器的速度和本地的用户接口库，而且它们已经移植到所有重要的平台上。这类应用程序包括：字处理程序、图片编辑器以及Web浏览器。它们通常是用C或C++编写的，采用Java语言重新编写似乎对最终的用户不会带来什么特别的好处。
　　5）Java只不过是另外一种程序设计语言。
　　Java是一种很好的程序设计语言，很多程序设计人员喜欢Java胜过C、C++或C#。有上百种好的程序设计语言没有广泛地流行，而带有明显缺陷的语言，如：C++和Visual Basic却大行其道。
　　这是为什么呢？程序设计语言的成功更多地取决于其支撑系统的能力，而不是优美的语法。人们主要关注：是否提供了易于实现某些功能的易用、便捷和标准的库？是否拥有强大的程序设计能力与调试工具？语言和工具是否能够与计算机的其他基础结构整合在一起？Java的成功源于其类库能够让人们轻松地完成原本有一定难度的事情。例如：联网和多线程。Java减少了指针错误，因此使用Java编程的效率更高。但这些并不是Java成功的全部原因。
　　6）现在有了C#，Java过时了。
　　C#借鉴了Java许多好的思想，例如：清晰的语言结构、虚拟机和垃圾收集。无论怎样，C#还是省去了一些好的特性，其中最重要的是安全性和平台无关性。如果确定使用Windows，C#就更有意义。但是，从求职广告判定，Java仍然是大多数开发者选择的语言。
　　7）Java是专用的，应该避免使用。
　　Sun Microsystems负责将Java的许可发放给销售者以及最终用户。尽管Sun公司通过Java Community Process最终控制着Java，但他们同时与许多其他的公司联手一起进行着语言修订版的开发及新类库的设计。虚拟机和类库的源代码都可以免费获取，但是，只能查阅，不能修改，也不能再发布。因此，Java是“闭源，但运转良好”。
　　这种状况在2007年发生了戏剧性的变化，Sun声称Java未来的版本将在General Public License下可用。Linux使用的是同一个开放源代码许可。Oracle一直致力于保持Java开源。只有一点美中不足—专利。根据GPL，任何人都可以得到专利许可，允许其使用和修改Java，不过仅限于桌面和服务器平台。如果你想在嵌入式系统中使用Java，就需要另外一个不同的许可，这很可能需要付费。不过，这些专利在未来十年就会到期，那时Java就完全免费了。
　　8）Java是解释型的，因此对于关键的应用程序速度太慢了。
　　早期的Java是解释型的。现在除了像手机这样的“微型”平台之外，Java虚拟机使用了即时编译器，因此采用Java编写的“热点”代码其运行速度与C++相差无几。
　　Java有一些C++没有的额外开销。虚拟机的启动时间要慢一些，并且Java GUI要比本地的GUI慢一些，这是因为它们采用了与平台无关的绘图方式。
　　对于Java比C++慢，人们已经抱怨很多年了。但是，今天的计算机速度远比人们发出抱怨的时候快了很多。一个较慢的Java程序与几年前相当快的C++程序相比还要快一些。就这一点来说，那些抱怨听起来有点像狐狸抱怨葡萄酸，有些人已经转过来攻击Java用户界面不够漂亮而不再攻击速度慢了。
　　9）所有的Java程序都是在网页中运行的。
　　所有的Java applet都是在网页浏览器中运行的。这也恰恰是applet的定义，即一种在网页中运行的Java程序。然而，大多数Java程序是运行在Web浏览器之外的独立应用程序。实际上，很多Java 程序都在Web服务器上运行并生成用于网页的代码。
　　10）Java程序是主要的安全风险。
　　早期的Java，有过关于安全系统失效的报道，曾经一度引起公众哗然。大多数安全问题都存在于Java的特定浏览器中。研究人员将这视为一种挑战，即努力找出Java的漏洞，对applet安全模型的强度和复杂度发起挑战。随后，人们很快就解决了引发问题的所有技术因素。据我们所知，任何实用系统都有安全危机。想想看：毫不夸张地说，有数百万种病毒攻击着Windows的可执行文件和Word宏，这给系统造成了巨大的损害，但却很少有人批评被攻击平台的脆弱。同样，Internet Explorer中的ActiveX机制始终作为被攻击的目标，但由于阻止这种攻击非常简单，所以人们也就懒得将它们公布于众了。
　　有些系统程序员在公司的浏览器中禁用Java，却允许其用户下载可执行文件、ActiveX控件和Word文档。这是多么荒唐可笑啊！事实上这会带来更大的风险。尽管距离Java的诞生已经15年之久，但与其他常用的执行平台相比，还是Java安全得多。
　　11）JavaScript是Java的简易版。
　　JavaScript是一种在网页中使用的脚本语言，它是由Netscape发明的，原来的名字叫做LiveScript。JavaScript的语法类似Java，除此之外，两者无任何关系。当然，名字有些相像。JavaScript的一个子集已经标准化为ECMA-262。与Java applet相比，JavaScript更紧密地与浏览器集成在一起。特别是JavaScript 程序可以修改正在显示的文档，而applet只能在有限的区域内控制外观。
　　12）使用Java可以用价值500美元的Internet设备取代电脑。
　　当Java刚刚发布的时候，一些人打赌：肯定会有这样的好事情发生。从本书的第1版开始，我们就已经认定“家庭用户将会放弃功能强大且便利的桌面系统，而使用没有本地存储的网络设备”是一种荒谬的想法。我们发现基于Java的网络计算机，对利用“零管理”降低计算机所有者的商业成本是一种很好的选择。即便如此，这种好事也没有发生。新一代的平板电脑并没有使用Java。
　　第2章 Java程序设计环境
　　▲ 安装Java 开发工具箱 ▲ 使用集成开发环境
　　▲ 选择开发环境 ▲ 运行图形化应用程序
　　▲ 使用命令行工具 ▲ 建立并运行applet
　　本章主要介绍如何安装Java开发工具箱（JDK）以及如何编译和运行各种类型的程序：控制台程序、图形化应用程序以及applet应用程序。运行JDK的方法是在shell窗口中键入命令行。然而，很多程序员更喜欢使用集成开发环境。为此，将在稍后介绍如何使用免费的开发环境编译和运行Java程序。尽管学起来很容易，但集成开发环境需要吞噬大量资源，在编写小型程序时会给人带来烦恼。作为折中方案，再介绍一下如何调用Java编译器并运行Java程序的文本编辑器。一旦掌握了本章的技术，并选定了自己的开发工具，就可以学习第3章，开始研究Java程序设计语言。
　　2.1 安装Java开发工具箱
　　Oracle公司为Linux、Mac OS X、Solaris和Windows提供了Java开发工具箱（JDK）的最新、最完整的版本。用于很多其他平台的版本仍处于各种不同的开发状态中，不过，这些版本都是由相应平台的开发商授权并分发的。
　　2.1.1 下载JDK
　　要想下载Java开发工具箱，必须访问Oracle网站，地址：www.oracle.com/technetwork/java/javase/downloads，并且在得到所需的软件之前必须弄清楚大量的专业术语。请看表2-1。
　　表2-1 Java术语
　　术 语 名 缩 写 解 释
　　Java Development Kit
　　Java Runtime Environment
　　Standard Edition
　　Enterprise Edition
　　Micro Edition
　　Java 2
　　Software Development Kit
　　Update
　　NetBeans JDK
　　JRE
　　SE
　　EE
　　ME
　　J2
　　SDK
　　u
　　— 编写Java程序的程序员使用的软件
　　运行Java程序的用户使用的软件
　　用于桌面或简单的服务器应用的Java平台
　　用于复杂的服务器应用的Java平台
　　用于手机和其他小型设备的Java平台
　　一个过时的术语，用于描述1998年~2006年之间的Java版本
　　一个过时的术语，用于描述1998年~2006年之间的JDK
　　Oracle的术语，用于发布修改的bug
　　Oracle的集成开发环境
　　JDK是Java Development Kit的缩写。有点混乱的地方是：工具箱的版本1.2~版本1.4被称为Java SDK（Software Development Kit）。在某些场合下，还可以看到这些过时的术语。另外，还有Java运行时环境（JRE），它包含虚拟机但不包含编译器。这并不是开发者所想要的环境，而是专门为不需要编译器的用户而设计。
　　还有，随处可见的Java SE，相对于Java EE（Enterprise Edition）和Java ME（Micro Edition），它是Java的标准版。
　　Java 2这种提法始于1998年。当时Sun公司的销售人员感觉通过增加小数点后面的数值改变版本号并没有反映出JDK 1.2 的重大改进。但是，由于在发布之后才意识到这个问题，所以决定将开发工具箱的版本号仍然沿用1.2，接下来的版本就是1.3、1.4和5.0。但是，Java平台被重新命名为Java 2。因此，就有了Java 2 Standard Edition Software Development Kit的5.0版，即J2SE SDK 5.0。
　　对于工程师来说，所有这一切都可能会引起困惑，这正是没有将其投入市场的原因。2006年，日趋完善的Java SE开始流行。无意义的Java 2被遗弃，Java当前的标准版本被称为Java SE 6。偶尔还会看到使用1.5版本和1.6版本，但这些只是5.0版本和6版本的同义词。
　　最后，当Oracle为解决一些紧急问题做出了某些微小的版本改变时，将其称为更新。例如：对Java SE 7开发包做出的第一次更新，正式称为JDK 7u1，内部的版本号为1.7.0_01。更新不需要安装在前一个版本上，它将包含整个JDK的最新版本。
　　Oracle公司曾经制作过将Java开发工具箱和集成开发环境捆绑在一起的产品。其中的集成开发环境，在不同时期被命名为不同的名字，例如，Forte、Sun ONE Studio、Sun Java Studio和NetBeans。我们无法知道每个人在登录下载网站时，市场正在热销什么。这里，建议大家只安装Java开发工具箱。如果最终决定使用Oracle的集成开发环境，只需要从http://netbeans.org下载。
　　 注释：安装过程提供了包含JDK版本号（如jdk1.7.0）的默认的安装路径。这似乎有些烦人，但是，应该重视版本号，它会给安装新版JDK的测试带来便利。
　　在Windows环境下，强烈建议不要接受带空格的默认路径名，如：c:\ProgramFiles\ jdk1.7.0。应该将Program Files部分删掉。
　　在本书中，使用的安装路径是jdk。例如：当引用jdk/bin目录时，意味着引用的是/usr/ local/jdk1.7.0/bin或c:\ jdk1.7.0\bin。
　　2.1.2 设置执行路径
　　在完成了JDK的安装之后，还需要执行另外一个步骤：把jdk/bin目录添加到执行路径中。所谓执行路径是指操作系统搜索本地可执行文件的目录列表。对于不同的操作系统，这个步骤的操作过程有所不同。
　　在UNIX（包括Linux、Mac OS X和Solaris）环境下，编辑执行路径的过程与所使用的shell有关。如果使用的是Bourne Again shell（Linux的默认选择），在~/.bashrc或~/.bash_profile文件的末尾就要添加：
　　在Windows下，以管理员身份登录。启动Control Panel，切换到Classic View，并选择System图标。在Windows XP中，立即会看到System Properties对话框。在Vista和Windows 7中，需要选择Advanced系统设置（如图2-1所示）。在System Properties对话框中，点击Advanced标签，然后点击Environment按钮。滚动System Variables窗口直到找到变量名path为止。点击Edit按钮（如图2-2所示）。将jdk\bin目录添加到路径的开始处，用分号将新条目隔开，如下所示：
　　图2-1 在Windows Vista中启动的System Properties对话框
　　图2-2 在Windows Vista中设置Path环境变量
　　要注意，需要将jdk替换为你的Java安装的实际路径，如c:\jdk1.7.0_02。如果忽视我们的建议，想要保留Program Files目录，则要把整个路径用双引号引起来，如：“c:\Program Files\jdk 1.7.0_02\bin”;other stuff。
　　将这个设置保存起来，新打开的任何控制台窗口都会有正确的路径。
　　下面是测试上述设置是否正确的方法：打开一个shell窗口，键入：
　　然后，按ENTER键。应该能够看到下面的显示信息：
　　如果看到的是“java:command not found”、或“The name specified is not recognized as an internel or external command, operable program or batch file”，则需要回到前面，重新检查整个安装过程。
　　 注释：在Windows中，按照下面的命令打开shell窗口。如果使用Windows XP环境，那么在开始菜单中选择Run选项，并键入cmd。在Vista和Windows 7中，只在开始菜单中的Start Search中输入cmd，再按下ENTER键就会出现一个shell窗口。
　　如果以前没有接触过这些内容，建议学习一下有关命令行的基础教程。例如http://www.horstmann.com/bigj/help/windows/tutorial. html。