mirror of
https://github.com/LingCoder/OnJava8.git
synced 2026-08-23 22:43:28 +08:00
Joe
GitHub
@@ -23,9 +23,6 @@ Java 语言曾规划设计的许多功能并未按照承诺兑现。本书中，
|
||||
|
||||
通信革命使我们相互沟通更加便利。无论是一对一沟通，还是团队里的互相沟通，甚至是地球上不同地区的沟通。据说下一次革命需要的是一种全球性的思维，这种思维源于足量的人以及足量相互连接。不我不知道 Java 是否能成为这场革命的工具之一，但至少这种可能性让我觉得：我现在正在做的传道授业的事情是有意义的！
|
||||
|
||||
|
||||
|
||||
|
||||
## 前提条件
|
||||
|
||||
阅读本书需要读者对编程有基本的了解:
|
||||
@@ -41,17 +38,14 @@ Java 语言曾规划设计的许多功能并未按照承诺兑现。本书中，
|
||||
|
||||
你可以通过在 On Java 8 的网站上免费下载 《Think in C》来补充学习 Java 所需要的前置知识。本书介绍了 Java 语言的基本控制机制以及面对对象编程（OOP）的概念。在本书中我引述了一些 C/C++ 语言中的一些特性来帮助读者更好的理解 Java。毕竟 Java 是在它们的基础之上发明的，理解他们之间的区别，有助于读者更好地学习 Java。我会试图简化这些引述，尽量让没有 C/C++ 基础的读者也能很好地理解。
|
||||
|
||||
|
||||
## JDK文档
|
||||
|
||||
甲骨文公司已经提供了免费的标准 JDK 文档。除非有必要，否则本书中将不再赘述 API 相关的使用细节。使用浏览器来即时搜索最新最全的 JDK 文档好过翻阅本书来查找。只有在需要补充特定的示例时，我才会提供有关的额外描述。
|
||||
|
||||
|
||||
## C编程思想
|
||||
|
||||
*Thinking in C* 已经可以在 www.OnJava8.com 免费下载。Java 的基础语法是基于 C 语言的。*Thinking in C* 中有更适合初学者的编程基础介绍。 我已经委托 Chuck Allison 将这本 C 基础的书籍作为独立产品附赠于本书的 CD 中。希望大家在阅读本书时，都已具备了学习 Java 的良好基础。
|
||||
|
||||
|
||||
## 源码下载
|
||||
|
||||
本书中所有源代码的示例都在版权保护的前提下通过 GitHub 免费提供。你可以将这些代码用于教育。任何人不得在未经正确引用代码来源的情况下随意重新发布此代码示例。在每个代码文件中，你都可以找到以下版权声明文件作为参考：
|
||||
@@ -62,7 +56,7 @@ Java 语言曾规划设计的许多功能并未按照承诺兑现。本书中，
|
||||
|
||||
1. 允许编译源代码并将编译代码仅以可执行格式包含在个人和商业软件程序中。
|
||||
|
||||
2. 允许在课堂情况下使用源代码而不修改源代码，包括在演示材料中，前提是“On Java 8”一书被引用为原点。
|
||||
2. 允许在课堂情况下使用源代码而不修改源代码，包括在演示材料中，前提是 “On Java 8” 一书被引用为原点。
|
||||
|
||||
3. 可以通过以下方式获得将源代码合并到印刷媒体中的许可：MindView LLC，PO Box 969，Crested Butte，CO 81224 MindViewInc@gmail.com
|
||||
|
||||
@@ -70,29 +64,24 @@ Java 语言曾规划设计的许多功能并未按照承诺兑现。本书中，
|
||||
|
||||
5. 在任何情况下，MINDVIEW LLC 或其出版商均不对任何一方根据任何法律理论对直接，间接，特殊，偶发或后果性损害承担任何责任，包括利润损失，业务中断，商业信息丢失或任何其他保险公司。由于 MINDVIEW LLC 或其出版商已被告知此类损害的可能性，因此使用本源代码及其文档或因无法使用任何结果程序而导致的个人受伤或者个人受伤。MINDVIEW LLC 特别声明不提供任何担保，包括但不限于对适销性和特定用途适用性的暗示担保。此处提供的源代码和文档基于“原样”基础，没有MINDVIEW LLC的任何随附服务，MINDVIEW LLC 没有义务提供维护，支持，更新，增强或修改。
|
||||
|
||||
|
||||
**请注意**，MindView LLC 仅提供以下唯一网址发布更新书中的代码示例，https://github.com/BruceEckel/OnJava8-examples 。你可在上述条款范围内将示例免费使用于项目和课堂中。
|
||||
|
||||
如果你在源代码中发现错误，请在下面的网址提交更正：https://github.com/BruceEckel/OnJava8-examples/issues
|
||||
|
||||
|
||||
## 编码样式
|
||||
|
||||
本书中代码标识符（关键字，方法，变量和类名）以粗体，固定宽度代码字体显示。像“*class”这种在代码中高频率出现的关键字可能让你觉得粗体有点乏味。（译者注：由于中英排版差异，中文翻译过程并未完全参照原作者的说明。具体排版格式请参考[此处](https://github.com/ruanyf/document-style-guide)）其他显示为正常字体。本书文本格式尽可能遵循 Oracle 常见样式，并保证在大多数 Java 开发环境中被支持。书中我使用了自己喜欢的字体风格。Java 是一种自由的编程语言，你也可以使用 IDE（集成开发环境）工具（如 IntelliJ IDEA，Eclipse 或 NetBeans）将格式更改为适合你的格式。
|
||||
|
||||
本书代码文件使用自动化工具进行测试，并在最新版本的 Java 编译通过（除了那些特别标记的错误之外）。本书重点介绍并使用 Java 8 进行测试。如果你必须了解更早的语言版本，可以在 [www.OnJava8.com](http://www.OnJava8.com) 免费下载 《Thinking in Java》。
|
||||
本书中代码标识符（关键字，方法，变量和类名）以粗体，固定宽度代码字体显示。像 “*class” 这种在代码中高频率出现的关键字可能让你觉得粗体有点乏味。（译者注：由于中英排版差异，中文翻译过程并未完全参照原作者的说明。具体排版格式请参考[此处](https://github.com/ruanyf/document-style-guide)）其他显示为正常字体。本书文本格式尽可能遵循 Oracle 常见样式，并保证在大多数 Java 开发环境中被支持。书中我使用了自己喜欢的字体风格。Java 是一种自由的编程语言，你也可以使用 IDE（集成开发环境）工具（如 IntelliJ IDEA，Eclipse 或 NetBeans）将格式更改为适合你的格式。
|
||||
|
||||
本书代码文件使用自动化工具进行测试，并在最新版本的 Java 编译通过（除了那些特别标记的错误之外）。本书重点介绍并使用 Java 8 进行测试。如果你必须了解更早的语言版本，可以在 [www.OnJava8.com](http://www.OnJava8.com) 免费下载 《Thinking in Java》。
|
||||
|
||||
## BUG提交
|
||||
|
||||
本书经过多重校订，但还是难免有所遗漏被新读者发现。如果你在正文或示例中发现任何错误的内容，请在[此处](https://github.com/BruceEckel/OnJava8-examples/issues)提交错误以及建议更正，作者感激不尽。
|
||||
|
||||
|
||||
## 邮箱订阅
|
||||
|
||||
你可以在 [www.OnJava8.com上](http://www.OnJava8.com) 订阅邮件。邮件不含广告并尽量提供干货。
|
||||
|
||||
|
||||
## Java图形界面
|
||||
|
||||
Java 在图形用户界面和桌面程序方面的发展可以说是一段悲伤的历史。Java 1.0 中图形用户界面（GUI）库的原始设计目标是让用户能在所有平台提供一个漂亮的界面。但遗憾的是，这个理想没有实现。相反，Java 1.0 AWT（抽象窗口工具包）在所有平台都表现平平，并且有诸多限制。你只能使用四种字体。另外，Java 1.0 AWT 编程模型也很笨拙且非面向对象。我的一个曾在 Java 设计期间工作过的学生道出了缘由：早期的 AWT 设计是在仅仅在一个月内构思、设计和实施的。不得不说这是一个“奇迹”，但同时更是“设计失败”的绝佳教材。
|
||||
|
||||
@@ -53,7 +53,7 @@
|
||||
|
||||
本书出版自美国，版权所有，翻版必究。未经授权不得非法存储在检索系统中，或以电子，机械，影印，录制任何形式传输等。制造商和销售商使用商标用来区分其产品标识。如果这些名称出现在这本书中，并且出版商知道商标要求，则这些名称已经用大写字母或所有大写字母打印。
|
||||
|
||||
Java 是甲骨文公司（Oracle. Inc.）的商标。Windows 95，Windows NT，Windows 2000，Windows XP，Windows 7，Windows 8和 Windows 10是微软公司（Microsoft Corporation）的商标。
|
||||
Java 是甲骨文公司（Oracle. Inc.）的商标。Windows 95，Windows NT，Windows 2000，Windows XP，Windows 7，Windows 8 和 Windows 10 是微软公司（Microsoft Corporation）的商标。
|
||||
此处提及的所有其他产品名称和公司名称均为其各自所有者的财产。作者和出版商在编写本书时已经仔细校对过，但不作任何明示或暗示的保证，对错误或遗漏不承担任何责任。对于因使用此处包含的信息或程序而产生的偶然或间接损失，我们不承担任何责任。
|
||||
|
||||
这本书是以平板电脑和计算机为载体的电子书，非传统纸质版书籍。
|
||||
|
||||
@@ -4,13 +4,12 @@
|
||||
|
||||
> 本书基于 Java 8 版本来教授当前 Java 编程的最优实践。
|
||||
|
||||
此前，我的另一本 Java 书籍 *Thinking in Java,4th Edition*（《Java编程思想》 第 4 版 Prentice Hall 2006）依然适用于 Java 5 编程。Android 编程就是始于此语言版本。
|
||||
此前，我的另一本 Java 书籍 *Thinking in Java, 4th Edition*（《Java编程思想》 第 4 版 Prentice Hall 2006）依然适用于 Java 5 编程。Android 编程就是始于此语言版本。
|
||||
|
||||
随着 Java 8 的出现，这门语言在许多地方发生了翻天覆地的变化。在新的版本中，代码的运用和实现上与以往不尽相同。这也促使了我时隔多年后再次创作了这本新书。《On Java 8》旨在面向已具有编程基础的开发者们。对于初学者，可以先在 [Code.org](http://Code.org) 或者 [Khan Academy](https://www.khanacademy.org/computing/computer-programming) 等网站上补充必要的前置知识。同时，[OnJava8.com](http://www.OnJava8.com) 上也有免费的 Thinking in C（《C编程思想》）专题知识。
|
||||
|
||||
与几年前我们依赖印刷媒体相比，YouTube，博客和 StackOverflow 等网站的出现让寻找答案变得简单。请结合这些学习途径和努力坚持下去。本书可作为编程入门书籍，同时也适用于想要扩展知识的在职程序员。每次在世界各地的演讲中，我都非常感谢 《*Thinking in Java*》 这本书给我带来的所有荣誉。它对于我重塑 [Reinventing Business](http://www.reinventing-business.com) 项目和促进交流是非常宝贵的。最后，写这本书的原因之一 希望这本书可以为我的这个项目众筹。似乎下一步要创建一个所谓的蓝绿色组织（Teal Organization）才合乎逻辑的。
|
||||
|
||||
|
||||
## 教学目标
|
||||
|
||||
每章教授一个或一组相关的概念，并且这些知识不依赖于尚未学习到的章节。如此，学习者可以在当前知识的背景框架下循序渐进地掌握 Java。
|
||||
@@ -22,12 +21,10 @@
|
||||
|
||||
2. 尽可能地使用简单和简短的示例，方便读者理解。而不强求引入解决实际问题的例子。因为我发现，相比解决某个实际问题，读者更乐于看到自己真正理解了示例的每个细节。或许我会因为这些“玩具示例”而被一些人所诟病，但我更愿意看到我的读者们因此能保持饶有兴趣地学习。
|
||||
|
||||
3. 把我知道以及我认为对于你学习语言很重要的东西都告诉你。我认为信息的重要性是分层次结构的。绝大多数情况下，我们没必要弄清问题的所有本质。好比编程语言中的某些特性和实现细节，95%的程序员都不需要取知道。这些细节除了会加重你的学习成本，还让你更觉得这门语言好复杂。如果你非要考虑这些细节，那么它还会迷惑该代码的阅读者/维护者，所以我主张选择简单的方法解决问题。
|
||||
3. 把我知道以及我认为对于你学习语言很重要的东西都告诉你。我认为信息的重要性是分层次结构的。绝大多数情况下，我们没必要弄清问题的所有本质。好比编程语言中的某些特性和实现细节，95% 的程序员都不需要取知道。这些细节除了会加重你的学习成本，还让你更觉得这门语言好复杂。如果你非要考虑这些细节，那么它还会迷惑该代码的阅读者/维护者，所以我主张选择简单的方法解决问题。
|
||||
|
||||
4. 希望本书能为你打下坚实的基础，方便你将来学习更难的课程和书籍。
|
||||
|
||||
|
||||
|
||||
## 语言设计错误
|
||||
|
||||
每种语言都有设计错误。当新手程序员涉足语言特性并猜测应用场景和使用方式时，他们体验到极大的不确定性和挫折感。承认错误令人尴尬，但这种糟糕的初学者经历比认识到你错了什么还要糟糕。哎，每一种设语言/库的设计错误都会永久地嵌入在 Java 的发行版中。
|
||||
@@ -48,60 +45,42 @@
|
||||
|
||||
新功能的设计与以往有很大不同。掌舵者开始重视程序员的编程经验。新功能的开发都是在努力使语言变得更好，而非仅仅停留在快速堆砌功能而不去深入研究它们的含义。甚至有些新特性的实现方式非常优雅（至少在 Java 约束下尽可能优雅）。
|
||||
|
||||
我猜测可能是部分设计者的离开让他们意识到了这点。说真的，我没想到会有这些变化！因为这些原因吧，写这本书的体验要比以往好很多。Java 8 包含了一系列基础和重要的改进。遗憾的是，为了严格地“向后兼容”，我们不大可能看到戏剧性的变化，当然我希望我是错的。尽管如此，我很赞赏那些敢于自我颠覆，并为 Java 设定更好路线的人。第一次，对于自己所写的部分 Java 8 代码我终于可以说“赞！”
|
||||
我猜测可能是部分设计者的离开让他们意识到了这点。说真的，我没想到会有这些变化！因为这些原因，写这本书的体验要比以往好很多。Java 8 包含了一系列基础和重要的改进。遗憾的是，为了严格地“向后兼容”，我们不大可能看到戏剧性的变化，当然我希望我是错的。尽管如此，我很赞赏那些敢于自我颠覆，并为 Java 设定更好路线的人。第一次，对于自己所写的部分 Java 8 代码我终于可以说“赞！”
|
||||
|
||||
最后，本书所著时间似乎也还不错，因为 Java 8 引入的新功能已经强烈地影响了今后 Java 的编码方式。截止我在写这本书时，Java 9 似乎更专注于对语言底层的基础结构功能的重要更新，而非本书所关注的新编码方式。话说回来，得益于电子书出版形式的便捷，假如我发现本书有需要更新或添加的内容，我可以第一时间将新版本推送给现有读者。
|
||||
|
||||
|
||||
|
||||
## 测试用例
|
||||
|
||||
书中代码示例基于 Java 8 和 Gradle 编译构建，并且代码示例都保存在[这个自由访问的GitHub的仓库](https://github.com/BruceEckel/OnJava8-Examples) 中。我们需要内置的测试框架，以便于在每次构建系统时自动运行。否则，你将无法保证自己代码的可靠性。为了实现这一点，我创建了一个测试系统来显示和验证大多数示例的输出结果。这些输出结果我会附加在示例结尾的代码块中。有时仅显示必要的那几行或者首尾行。利用这种方式来改善读者的阅读和学习体验，同时也提供了一种验证示例正确性的方法。
|
||||
|
||||
|
||||
|
||||
## 普及性
|
||||
|
||||
Java 的普及性对于其受欢迎程度有重要意义。学习 Java 会让你更容易找到工作。相关的培训材料，课程和其他可用的学习资源也很多。对于企业来说，招聘 Java 程序员相对容易。如果你不喜欢 Java 语言，那么最好不要拿他当作你谋生的工具，因为这种生活体验并不好。作为一家公司，在技术选型前一定不要单单只考虑 Java 程序员好招。每种语言都有其适用的范围，有可能你们的业务更适用于另一种编程语言来达到事半功倍的效果。如果你真的喜欢 Java，那么欢迎你。希望这本书能丰富你的编程经验！
|
||||
|
||||
|
||||
|
||||
## 关于安卓
|
||||
|
||||
本书基于 Java 8 版本。如果你是 Andriod 程序员，请务必学习 Java 5。在《On Java 8》出版的时候，我的另一本基于 Java 5 的著作 *Thinking in Java 4th Edition*（《Java编程思想》第四版）已经可以在[www.OnJava8.com](http://www.OnJava8.com)上免费下载了。此外，还有许多其他专用于 Andriod 编程的资源。
|
||||
|
||||
|
||||
|
||||
|
||||
## 电子版权声明
|
||||
|
||||
《On Java 8》仅提供电子版，并且仅通过 [www.OnJava8.com](http://www.OnJava8.com) 提供。任何未经 <mindviewinc@gmail.com> 授权的其他来源或流传送机构都是非法的。本作品受版权保护！未经许可，请勿通过以任何方式分享或发布。你可以使用这些示例进行教学，只要不对本书非法重新出版。有关完整详细信息，请参阅示例分发中的 Copyright.txt 文件。对于视觉障碍者，电子版本有可搜索性，字体大小调整或文本到语音等诸多好处。
|
||||
《On Java 8》仅提供电子版，并且仅通过 [www.OnJava8.com](http://www.OnJava8.com) 提供。任何未经 <mindviewinc@gmail.com> 授权的其他来源或流传送机构都是非法的。本作品受版权保护！未经许可，请勿通过以任何方式分享或发布。你可以使用这些示例进行教学，只要不对本书非法重新出版。有关完整详细信息，请参阅示例分发中的 Copyright.txt 文件。对于视觉障碍者，电子版本有可搜索性，字体大小调整或文本到语音等诸多好处。
|
||||
|
||||
任何购买这本书的读者，还需要一台计算机来运行和写作代码。另外电子版在计算机上和移动设备上的显示效果俱佳，推荐使用平板设备阅读。相比购买传统纸质版的价格，平板电脑价格都足够便宜。在床上阅读电子版比看这样一本厚厚的实体书要方便得多。起初你可能会有些不习惯，但我相信很快你就会发现它带来的优点远胜过不适。我已经走过这个阶段，Google Play 图书的浏览器阅读体验非常好，包括在 Linux 和 iOS 设备上。作为一次尝试，我决定尝试通过 Google 图书进行出版。
|
||||
|
||||
**注意**：在撰写本文时，通过 Google Play 图书网络浏览器应用阅读图书虽然可以忍受，但体验还是有点差强人意，我强烈推荐读者们使用平板电脑来阅读。
|
||||
|
||||
|
||||
|
||||
|
||||
## 版本说明
|
||||
|
||||
本书采用 [Pandoc](http://pandoc.org) 风格的 Markdown 编写，使用 Pandoc 生成 ePub v3 格式。
|
||||
|
||||
正文字体为 Georgia，标题字体为 Verdana。 代码字体使用的 Ubuntu Mono，因为它特别紧凑，单行能容纳更多的代码。 我选择将代码内联（而不是将列表放入图像，参照其他书籍），因为我觉得这个功能很重要：让代码块能适应字体大小得改变而改变（否则，买电子版，还图什么呢？）。
|
||||
|
||||
书中的提取，编译和测试代码示例的构建过程都是自动化的。所有自动化操作都是通过我在 Python 3中编写的程序来实现的。
|
||||
|
||||
|
||||
|
||||
书中的提取，编译和测试代码示例的构建过程都是自动化的。所有自动化操作都是通过我在 Python 3 中编写的程序来实现的。
|
||||
|
||||
## 封面设计
|
||||
|
||||
《On Java 8》的封面是根据 W.P.A.（Works Progress Administration 1935年至1943年美国大萧条期间的一个巨大项目，它使数百万失业人员重新就业）的马赛克创作的。它还让我想起了《绿野仙踪》（*The Wizard of Oz*）系列丛书中的插图。 我的好朋友、设计师丹 *Daniel Will-Harris*（[www.will-harris.com](http://www.will-harris.com)）和我都喜欢这个形象。
|
||||
|
||||
|
||||
|
||||
|
||||
## 感谢的人
|
||||
|
||||
感谢 *Domain-Driven Design*（《领域驱动设计》 ）的作者 *Eric Evans* 建议书名，以及其他新闻组校对的帮助。
|
||||
|
||||
@@ -1,10 +1,6 @@
|
||||
|
||||
[TOC]
|
||||
|
||||
|
||||
# 第一章 对象的概念
|
||||
|
||||
|
||||
> “我们没有意识到惯用语言的结构有多大的力量。可以毫不夸张地说，它通过语义反应机制奴役我们。语言表现出来并在无意识中给我们留下深刻印象的结构会自动投射到我们周围的世界。” -- Alfred Korzybski (1930)
|
||||
|
||||
计算机革命的起源来自机器。编程语言就像是那台机器。它不仅是我们思维放大的工具与另一种表达媒介，更像是我们思想的一部分。语言的灵感来自其他形式的表达，如写作，绘画，雕塑，动画和电影制作。编程语言就是创建应用程序的思想结构。
|
||||
@@ -23,7 +19,7 @@
|
||||
|
||||
面向对象的程序设计在此基础上跨出了一大步，程序员可利用一些工具表达“问题空间”内的元素。由于这种表达非常具有普遍性，所以不必受限于特定类型的问题。我们将问题空间中的元素以及它们在解决方案空间的表示称作“对象”（**Object**）。当然，还有一些在问题空间没有对应的对象体。通过添加新的对象类型，程序可进行灵活的调整，以便与特定的问题配合。所以当你在阅读描述解决方案的代码时，也是在阅读问题的表述。与我们以前见过的相比，这无疑是一种更加灵活、更加强大的语言抽象方法。总之，OOP 允许我们根据问题来描述问题，而不是根据运行解决方案的计算机。然而，它仍然与计算机有联系，每个对象都类似一台小计算机：它们有自己的状态并且可以进行特定的操作。这与现实世界的“对象”或者“物体”相似：它们都有自己的特征和行为。
|
||||
|
||||
Smalltalk 作为第一个成功的面向对象并影响了 Java的程序设计语言 ，*Alan Kay* 总结了其五大基本特征。通过这些特征，我们可理解“纯粹”的面向对象程序设计方法是什么样的：
|
||||
Smalltalk 作为第一个成功的面向对象并影响了 Java 的程序设计语言 ，*Alan Kay* 总结了其五大基本特征。通过这些特征，我们可理解“纯粹”的面向对象程序设计方法是什么样的：
|
||||
|
||||
> 1. **万物皆对象**。你可以将对象想象成一种特殊的变量。它存储数据，但可以在你对其“发出请求”时执行本身的操作。理论上讲，你总是可以从要解决的问题身上抽象出概念性的组件，然后在程序中将其表示为一个对象。
|
||||
> 2. **程序是一组对象，通过消息传递来告知彼此该做什么**。要请求调用一个对象的方法，你需要向该对象发送消息。
|
||||
@@ -33,14 +29,13 @@ Smalltalk 作为第一个成功的面向对象并影响了 Java的程序设计
|
||||
|
||||
*Grady Booch* 提供了对对象更简洁的描述：一个对象具有自己的状态，行为和标识。这意味着对象有自己的内部数据(提供状态)、方法 (产生行为)，并彼此区分（每个对象在内存中都有唯一的地址）。
|
||||
|
||||
|
||||
## 接口
|
||||
|
||||
亚里士多德（*Aristotle*）大概是第一个认真研究“类型”的哲学家，他曾提出过“鱼类和鸟类”这样的概念。所有对象都是唯一的，但同时也是具有相同的特性和行为的对象所归属的类的一部分。这种思想被首次应用于第一个面向对象编程语言 Simula-67，它在程序中使用基本关键字 **class** 来引入新的类型（class 和 type 通常可互换使用，有些人对它们进行了进一步区分，他们强调 type 决定了接口，而 class 是那个接口的一种特殊实现方式）。
|
||||
|
||||
Simula 是一个很好的例子。正如这个名字所暗示的，它的作用是“模拟”（Simulate）类似“银行出纳员”这样的经典问题。在这个例子里，我们有一系列出纳员、客户、帐号、交易和货币单位等许多"对象”。每类成员（元素）都具有一些通用的特征：每个帐号都有一定的余额；每名出纳都能接收客户的存款；等等。与此同时，每个成员都有自己的状态；每个帐号都有不同的余额；每名出纳都有一个名字。所以在计算机程序中，能用独一无二的实体分别表示出纳员、客户、帐号以及交易。这个实体便是“对象”，而且每个对象都隶属一个特定的“类”，那个类具有自己的通用特征与行为。
|
||||
|
||||
因此，在面向对象的程序设计中，尽管我们真正要做的是新建各种各样的数据“类型”（Type），但几乎所有面向对象的程序设计语言都采用了 `class` 关键字。当你看到“type”这个词的时候，请同时想到 `class`；反之亦然。
|
||||
因此，在面向对象的程序设计中，尽管我们真正要做的是新建各种各样的数据“类型”（Type），但几乎所有面向对象的程序设计语言都采用了 `class` 关键字。当你看到 “type” 这个词的时候，请同时想到 `class`；反之亦然。
|
||||
|
||||
创建好一个类后，可根据情况生成许多对象。随后，可将那些对象作为要解决问题中存在的元素进行处理。事实上，当我们进行面向对象的程序设计时，面临的最大一项挑战性就是：如何在“问题空间”（问题实际存在的地方）的元素与“方案空间”（对实际问题进行建模的地方，如计算机）的元素之间建立理想的“一对一”的映射关系。
|
||||
|
||||
@@ -55,13 +50,12 @@ Light lt = new Light();
|
||||
lt.on();
|
||||
```
|
||||
|
||||
在这个例子中，类型／类的名称是 **Light**，可向 **Light** 对象发出的请求包括包括打开 `on`、关闭 `off`、变得更明亮 `brighten` 或者变得更暗淡 `dim`。通过声明一个引用，如 `lt` 和 `new` 关键字，我们创建了一个**Light**类型的对象，再用等号将其赋给引用。
|
||||
在这个例子中，类型／类的名称是 **Light**，可向 **Light** 对象发出的请求包括包括打开 `on`、关闭 `off`、变得更明亮 `brighten` 或者变得更暗淡 `dim`。通过声明一个引用，如 `lt` 和 `new` 关键字，我们创建了一个 **Light** 类型的对象，再用等号将其赋给引用。
|
||||
|
||||
为了向对象发送消息，我们使用句点符号 `.` 将 `lt` 和消息名称 `on` 连接起来。可以看出，使用一些预先定义好的类时，我们在程序里采用的代码是非常简单直观的。
|
||||
|
||||
上图遵循 **UML**（Unified Modeling Language，统一建模语言）的格式。每个类由一个框表示，框的顶部有类型名称，框中间部分是要描述的任何数据成员，方法（属于此对象的方法，它们接收任何发送到该对象的消息）在框的底部。通常，只有类的名称和公共方法在 **UML** 设计图中显示，因此中间部分未显示，如本例所示。如果你只对类名感兴趣，则也不需要显示方法信息。
|
||||
|
||||
|
||||
## 服务提供
|
||||
|
||||
在开发或理解程序设计时，我们可以将对象看成是“服务提供者”。你的程序本身将为用户提供服务，并且它能通过调用其他对象提供的服务来实现这一点。我们的最终目标是开发或调用工具库中已有的一些对象，提供理想的服务来解决问题。
|
||||
@@ -70,12 +64,11 @@ lt.on();
|
||||
|
||||
我们可以将这些问题一一分解，抽象成一组服务。软件设计的基本原则是高内聚：每个组件的内部作用明确，功能紧密相关。然而经常有人将太多功能塞进一个对象中。例如：在支票打印模块中，你需要设计一个可以同时读取文本格式又能正确识别不同打印机型号的对象。正确的做法是提供三个或更多对象：一个对象检查所有排版布局的目录；一个或一组可以识别不同打印机型号的对象展示通用的打印界面；第三个对象组合上述两个服务来完成任务。这样，每个对象都提供了一组紧密的服务。在良好的面向对象设计中，每个对象功能单一且高效。这样的程序设计可以提高我们代码的复用性，同时也方便别人阅读和理解我们的代码。只有让人知道你提供什么服务，别人才能更好地将其应用到其他模块或程序中。
|
||||
|
||||
|
||||
## 封装
|
||||
|
||||
我们可以把编程的侧重领域划分为研发和应用。应用程序员调用研发程序员构建的基础工具类来做快速开发。研发程序员开发一个工具类，该工具类仅向应用程序员公开必要的内容，并隐藏内部实现的细节。这样可以有效地避免该工具类被错误的使用和更改，从而减少程序出错的可能。彼此职责划分清晰，相互协作。当应用程序员调用研发程序员开发的工具类时，双方建立了关系。应用程序员通过使用现成的工具类组装应用程序或者构建更大的工具库。如果工具类的创建者将类的内部所有信息都公开给调用者，那么有些使用规则就不容易被遵守。因为前者无法保证后者是否会按照正确的规则来使用，甚至是改变该工具类。只有设定访问控制，才能从根本上阻止这种情况的发生。
|
||||
|
||||
因此，使用访问控制的原因有以下2点：
|
||||
因此，使用访问控制的原因有以下两点：
|
||||
|
||||
1. 让应用程序员不要触摸他们不应该触摸的部分。（请注意，这也是一个哲学决策。部分编程语言认为如果程序员有需要，则应该让他们访问细节部分。）；
|
||||
|
||||
@@ -83,14 +76,13 @@ lt.on();
|
||||
|
||||
Java 有三个显式关键字来设置类中的访问权限：`public`（公开），`private`(私有)和`protected`（受保护）。这些访问修饰符决定了谁能使用它们修饰的方法、变量或类。
|
||||
|
||||
1. `public` （公开） 表示任何人都可以访问和使用该元素；
|
||||
1. `public`（公开）表示任何人都可以访问和使用该元素；
|
||||
|
||||
2. `private` （私有） 除了类本身和类内部的方法，外界无法直接访问该元素。`private` 是类和调用者之间的屏障。任何试图访问私有成员的行为都会报编译时错误；
|
||||
2. `private`（私有）除了类本身和类内部的方法，外界无法直接访问该元素。`private` 是类和调用者之间的屏障。任何试图访问私有成员的行为都会报编译时错误；
|
||||
|
||||
3. `protected` （受保护） 类似于 `private`，区别是子类（下一节就会引入继承的概念）可以访问 `protected` 的成员，但不能访问 `private` 成员；
|
||||
|
||||
4. `default` （默认） 如果你不使用前面的三者，默认就是 `default` 访问权限。`default` 被称为包访问，因为该权限下的资源可以被同一包（库组件）中其他类的成员访问。
|
||||
3. `protected`（受保护）类似于 `private`，区别是子类（下一节就会引入继承的概念）可以访问 `protected` 的成员，但不能访问 `private` 成员；
|
||||
|
||||
4. `default`（默认）如果你不使用前面的三者，默认就是 `default` 访问权限。`default` 被称为包访问，因为该权限下的资源可以被同一包（库组件）中其他类的成员访问。
|
||||
|
||||
## 复用
|
||||
|
||||
@@ -100,7 +92,7 @@ Java 有三个显式关键字来设置类中的访问权限：`public`（公开
|
||||
|
||||
* **组合**（Composition）经常用来表示“拥有”关系（has-a relationship）。例如，“汽车拥有引擎”。
|
||||
|
||||
* **聚合**（Aggregation） 动态的 **组合**。
|
||||
* **聚合**（Aggregation）动态的**组合**。
|
||||
|
||||
|
||||
|
||||
@@ -118,8 +110,6 @@ Java 有三个显式关键字来设置类中的访问权限：`public`（公开
|
||||
|
||||
通过使用 `class` 关键字，这些概念形成了编程语言中的基本单元。遗憾的是，这么做还是有很多麻烦：在创建了一个类之后，即使另一个新类与其具有相似的功能，你还是得重新创建一个新类。但我们若能利用现成的数据类型，对其进行“克隆”，再根据情况进行添加和修改，情况就显得理想多了。“继承”正是针对这个目标而设计的。但继承并不完全等价于克隆。在继承过程中，若原始类（正式名称叫作基类、超类或父类）发生了变化，修改过的“克隆”类（正式名称叫作继承类或者子类）也会反映出这种变化。
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
这个图中的箭头从派生类指向基类。正如你将看到的，通常有多个派生类。类型不仅仅描述一组对象的约束，它还涉及其他类型。两种类型可以具有共同的特征和行为，但是一种类型可能包含比另一种类型更多的特征，并且还可以处理更多的消息（或者以不同的方式处理它们）。继承通过基类和派生类的概念来表达这种相似性。基类包含派生自它的类型之间共享的所有特征和行为。创建基类以表示思想的核心。从基类中派生出其他类型来表示实现该核心的不同方式。
|
||||
@@ -136,21 +126,20 @@ Java 有三个显式关键字来设置类中的访问权限：`public`（公开
|
||||
|
||||
有两种方法可以区分新的派生类与原始的基类。第一种方法很简单：在派生类中添加新方法。这些新方法不是基类接口的一部分。这意味着基类不能满足你的所有需求，所以你添加了更多的方法。继承的这种简单而原始的用途有时是解决问题的完美解决方案。然而，还是要仔细考虑是否在基类中也要有这些额外的方法。这种设计的发现与迭代过程在面向对象程序设计中会经常发生。
|
||||
|
||||
尽管继承有时意味着你要在接口中添加新方法（尤其是在以**extends**关键字表示继承的Java中），但并非总需如此。第二种也是更重要地区分派生类和基类的方法是改变现有基类方法的行为，这被称为覆盖(overriding)。要想覆盖一个方法，只需要在派生类中重新定义这个方法即可。
|
||||
尽管继承有时意味着你要在接口中添加新方法（尤其是在以 **extends** 关键字表示继承的 Java 中），但并非总需如此。第二种也是更重要地区分派生类和基类的方法是改变现有基类方法的行为，这被称为覆盖 (overriding)。要想覆盖一个方法，只需要在派生类中重新定义这个方法即可。
|
||||
|
||||
### "是一个"与"像是一个"的关系
|
||||
|
||||
对于继承可能会引发争论：继承应该只覆盖基类的方法(不应该添加基类中没有的方法)吗？如果这样的话，基类和派生类就是相同的类型了，因为它们具有相同的接口。这会造成，你可以用一个派生类对象完全替代基类对象，这叫作"纯粹替代"，也经常被称作"替代原则"。在某种意义上，这是一种处理继承的理想方式。我们经常把这种基类和派生类的关系称为是一个(is-a)关系，因为可以说"圆是一个形状"。判断是否继承，就看在你的类之间有无这种is-a关系。
|
||||
对于继承可能会引发争论：继承应该只覆盖基类的方法(不应该添加基类中没有的方法)吗？如果这样的话，基类和派生类就是相同的类型了，因为它们具有相同的接口。这会造成，你可以用一个派生类对象完全替代基类对象，这叫作"纯粹替代"，也经常被称作"替代原则"。在某种意义上，这是一种处理继承的理想方式。我们经常把这种基类和派生类的关系称为是一个（is-a）关系，因为可以说"圆是一个形状"。判断是否继承，就看在你的类之间有无这种 is-a 关系。
|
||||
|
||||
有时你在派生类添加了新的接口元素，从而扩展接口。虽然新类型仍然可以替代基类，但是这种替代不完美，原因在于基类无法访问新添加的方法。这种关系称为像是一个(is-like-a)关系。新类型不但拥有旧类型的接口，而且包含其他方法，所以不能说新旧类型完全相同。
|
||||
|
||||
|
||||
|
||||
以空调为例，假设房间里已经安装好了制冷设备的控制器，即你有了控制制冷设备的接口。想象一下，现在空调坏了，你重新安装了一个既制冷又制热的热力泵。热力泵就像是一个(is-like-a)空调，但它可以做更多。因为当初房间的控制系统被设计成只能控制制冷设备，所以它只能与新对象(热力泵)的制冷部分通信。新对象的接口已经扩展了，现有控制系统却只知道原来的接口，一旦看到这个设计，你就会发现，作为基类的制冷系统不够一般化，应该被重新命名为"温度控制系统"，也应该包含制热功能，这样的话，我们就可以使用替代原则了。上图反映了在现实世界中进行设计时可能会发生的事情。
|
||||
以空调为例，假设房间里已经安装好了制冷设备的控制器，即你有了控制制冷设备的接口。想象一下，现在空调坏了，你重新安装了一个既制冷又制热的热力泵。热力泵就像是一个（is-like-a）空调，但它可以做更多。因为当初房间的控制系统被设计成只能控制制冷设备，所以它只能与新对象(热力泵)的制冷部分通信。新对象的接口已经扩展了，现有控制系统却只知道原来的接口，一旦看到这个设计，你就会发现，作为基类的制冷系统不够一般化，应该被重新命名为"温度控制系统"，也应该包含制热功能，这样的话，我们就可以使用替代原则了。上图反映了在现实世界中进行设计时可能会发生的事情。
|
||||
|
||||
当你看到替代原则时，很容易会认为纯粹替代是唯一可行的方式，并且使用纯粹替代的设计是很好的。但有些时候，你会发现必须得在派生(扩展)类中添加新方法(提供新的接口)。只要仔细审视，你可以很明显地区分两种设计方式的使用场合。
|
||||
|
||||
|
||||
## 多态
|
||||
|
||||
我们在处理类的层次结构时，通常把一个对象看成是它所属的基类，而不是把它当成具体类。通过这种方式，我们可以编写出不局限于特定类型的代码。在上个“形状”的例子中，“方法”（method）操纵的是通用“形状”，而不关心它们是“圆”、“正方形”、“三角形”还是某种尚未定义的形状。所有的形状都可以被绘制、擦除和移动，因此“方法”向其中的任何代表“形状”的对象发送消息都不必担心对象如何处理信息。
|
||||
@@ -167,7 +156,7 @@ Java 有三个显式关键字来设置类中的访问权限：`public`（公开
|
||||
|
||||
通过继承，程序直到运行时才能确定代码的地址，因此发送消息给对象时，还需要其他一些方案。为了解决这个问题，面向对象语言使用**后期绑定**的概念。当向对象发送信息时，被调用的代码直到运行时才确定。编译器确保方法存在，并对参数和返回值执行类型检查，但是它不知道要执行的确切代码。
|
||||
|
||||
为了执行后期绑定，Java 使用一个特殊的代码位来代替绝对调用。这段代码使用对象中存储的信息来计算方法主体的地址（此过程在多态性章节中有详细介绍）。因此，每个对象的行为根据特定代码位的内容而不同。当你向对象发送消息时，对象知道该如何处理这条消息。在某些语言中，必须显式地授予方法后期绑定属性的灵活性。例如，C++ 使用**virtual**关键字。在这些语言中，默认情况下方法不是动态绑定的。在 Java 中，动态绑定是默认行为，不需要额外的关键字来实现多态性。
|
||||
为了执行后期绑定，Java 使用一个特殊的代码位来代替绝对调用。这段代码使用对象中存储的信息来计算方法主体的地址（此过程在多态性章节中有详细介绍）。因此，每个对象的行为根据特定代码位的内容而不同。当你向对象发送消息时，对象知道该如何处理这条消息。在某些语言中，必须显式地授予方法后期绑定属性的灵活性。例如，C++ 使用 **virtual** 关键字。在这些语言中，默认情况下方法不是动态绑定的。在 Java 中，动态绑定是默认行为，不需要额外的关键字来实现多态性。
|
||||
|
||||
为了演示多态性，我们编写了一段代码，它忽略了类型的具体细节，只与基类对话。该代码与具体类型信息分离，因此更易于编写和理解。而且，如果通过继承添加了一个新类型（例如，一个六边形），那么代码对于新类型的 Shape 就像对现有类型一样有效。因此，该程序是可扩展的。
|
||||
|
||||
@@ -213,7 +202,7 @@ void doSomething(Shape shape) {
|
||||
shape.draw();
|
||||
```
|
||||
|
||||
我们可以看到程序并未这样表达：“如果你是一个 Circle ，就这样做；如果你是一个 Square，就那样做…...”。若那样编写代码，就需检查 Shape 所有可能的类型，如圆、矩形等等。这显然是非常麻烦的，而且每次添加了一种新的 Shape 类型后，都要相应地进行修改。在这里，我们只需说：“你是一种几何形状，我知道你能删掉 `erase()` 和绘制 `draw()`，你自己去做吧，注意细节。”
|
||||
我们可以看到程序并未这样表达：“如果你是一个 Circle ，就这样做；如果你是一个 Square，就那样做...”。若那样编写代码，就需检查 Shape 所有可能的类型，如圆、矩形等等。这显然是非常麻烦的，而且每次添加了一种新的 Shape 类型后，都要相应地进行修改。在这里，我们只需说：“你是一种几何形状，我知道你能删掉 `erase()` 和绘制 `draw()`，你自己去做吧，注意细节。”
|
||||
|
||||
尽管我们没作出任何特殊指示，程序的操作也是完全正确和恰当的。我们知道，为 Circle 调用`draw()` 时执行的代码与为一个 Square 或 Line 调用 `draw()` 时执行的代码是不同的。但在将 `draw()` 信息发给一个匿名 Shape 时，根据 Shape 句柄当时连接的实际类型，会相应地采取正确的操作。这非常神奇，因为当 Java 编译器为 `doSomething()` 编译代码时，它并不知道自己要操作的准确类型是什么。
|
||||
|
||||
@@ -223,7 +212,7 @@ void doSomething(Shape shape) {
|
||||
|
||||
## 单继承结构
|
||||
|
||||
自从 C++ 引入以来，一个OOP 问题变得尤为突出：是否所有的类都应该默认从一个基类继承呢？这个答案在 Java 中是肯定的（实际上，除 C++ 以外的几乎所有OOP语言中也是这样）。在 Java 中，这个最终基类的名字就是 `Object`。
|
||||
自从 C++ 引入以来，一个 OOP 问题变得尤为突出：是否所有的类都应该默认从一个基类继承呢？这个答案在 Java 中是肯定的（实际上，除 C++ 以外的几乎所有OOP语言中也是这样）。在 Java 中，这个最终基类的名字就是 `Object`。
|
||||
|
||||
Java 的单继承结构有很多好处。由于所有对象都具有一个公共接口，因此它们最终都属于同一个基类。相反的，对于 C++ 所使用的多继承的方案则是不保证所有的对象都属于同一个基类。从向后兼容的角度看，多继承的方案更符合 C 的模型，而且受限较少。
|
||||
|
||||
@@ -233,7 +222,6 @@ Java 的单继承结构有很多好处。由于所有对象都具有一个公共
|
||||
|
||||
由于运行期的类型信息会存在于所有对象中，所以我们永远不会遇到判断不了对象类型的情况。这对于系统级操作尤其重要，例如[异常处理](#异常处理)。同时，这也让我们的编程具有更大的灵活性。
|
||||
|
||||
|
||||
## 集合
|
||||
|
||||
通常，我们并不知道解决某个具体问题需要的对象数量和持续时间，以及对象的存储方式。那么我们如何知悉程序在运行时需要分配的内存空间呢？
|
||||
@@ -262,7 +250,6 @@ Java 的单继承结构有很多好处。由于所有对象都具有一个公共
|
||||
|
||||
泛型的应用，让 Java 的许多标准库和组件都发生了改变。在本书的代码示例中，你也会经常看到泛型的身影。
|
||||
|
||||
|
||||
## 对象创建与生命周期
|
||||
|
||||
我们在使用对象时要注意的一个关键问题就是对象的创建和销毁方式。每个对象的生存都需要资源，尤其是内存。为了资源的重复利用，当对象不再被使用时，我们应该及时释放资源，清理内存。
|
||||
@@ -285,7 +272,6 @@ Java 使用动态内存分配。每次创建对象时，使用 `new` 关键字
|
||||
|
||||
Java 的垃圾收集器被设计用来解决内存释放的问题（虽然这不包括对象清理的其他方面）。垃圾收集器知道对象什么时候不再被使用并且自动释放内存。结合单继承和仅可在堆中创建对象的机制，Java 的编码过程比用 C++ 要简单得多。我们所要做的决定和要克服的障碍也会少很多！
|
||||
|
||||
|
||||
## 异常处理
|
||||
|
||||
自编程语言被发明以来，程序的错误处理一直都是个难题。因为很难设计出一个好的错误处理方案，所以许多编程语言都忽略了这个问题，把这个问题丢给了程序类库的设计者。他们提出了在许多情况下都可以工作但很容易被规避的半途而废的措施，通常只需忽略错误。多数错误处理方案的主要问题是：它们依赖程序员之间的约定俗成而不是语言层面的限制。换句话说，如果程序员赶时间或没想起来，这些方案就很容易被忘记。
|
||||
@@ -296,7 +282,6 @@ Java 的垃圾收集器被设计用来解决内存释放的问题（虽然这不
|
||||
|
||||
Java 的异常处理机制在编程语言中脱颖而出。Java 从一开始就内置了异常处理，因此你不得不使用它。这是 Java 语言唯一接受的错误报告方法。如果没有编写适当的异常处理代码，你将会收到一条编译时错误消息。这种有保障的一致性有时会让程序的错误处理变得更容易。值得注意的是，异常处理并不是面向对象的特性。尽管在面向对象的语言中异常通常由对象表示，但是在面向对象语言之前也存在异常处理。
|
||||
|
||||
|
||||
## 本章小结
|
||||
|
||||
面向过程程序包含数据定义和函数调用。要找到程序的意图，你必须要在脑中建立一个模型，弄清函数调用和更底层的概念。这些程序令人困扰，因为它们的表示更多地面向计算机而不是我们要解决的问题，这就是我们在设计程序时需要中间表示的原因。OOP 在面向过程编程的基础上增加了许多新的概念，所以有人会认为使用 Java 来编程会比同等的面向过程编程要更复杂。在这里，我想给大家一个惊喜：通常按照 Java 规范编写的程序会比面向过程程序更容易被理解。
|
||||
@@ -306,5 +291,4 @@ Java 的异常处理机制在编程语言中脱颖而出。Java 从一开始就
|
||||
OOP 和 Java 不一定适合每个人。评估自己的需求以及与现有方案作比较是很重要的。请充分考虑后再决定是不是选择 Java。如果在可预见的未来，Java 并不能很好的满足你的特定需求，那么你应该去寻找其他替代方案（特别是，我推荐看 Python）。如果你依然选择 Java 作为你的开发语言，我希望你至少应该清楚你选择的是什么，以及为什么选择这个方向。
|
||||
<!-- 分页 -->
|
||||
|
||||
<div style="page-break-after: always;"></div>
|
||||
|
||||
<div style="page-break-after: always;"></div>
|
||||
@@ -6,18 +6,16 @@
|
||||
|
||||
在开始学习 Java 之前，你必须要先安装好 Java 和本书的源代码示例。因为考虑到可能有“专门的初学者”从本书开始学习编程，所以我会详细地教你如何使用命令行。 如果你已经有此方面的经验了，可以跳过这段安装说明。如果你对此处描述的任何术语或过程仍不清楚，还可以通过 [Google](https://google.com/) 搜索找到答案。具体的问题或困难请试着在 [StackOverflow](https://stackoverflow.com/) 上提问。或者去 [YouTube](https://youtube.com) 看有没有相关的安装说明。
|
||||
|
||||
|
||||
## 编辑器
|
||||
|
||||
首先你需要安装一个编辑器来创建和修改本书用例里的 Java 代码。有可能你还需要使用编辑器来更改系统配置文件。
|
||||
|
||||
相比一些重量级的 IDE（Integrated Development Environments，集成开发环境），如Eclipse、NetBeans和IntelliJ IDEA (译者注：做项目强烈推荐IDEA)，编辑器是一种更纯粹的文本编辑器。如果你已经有了一个用着顺手的 IDE，那就可以直接用了。为了方便后面的学习和统一下教学环境，我推荐大家使用 Atom 这个编辑器。大家可以在 [atom.io](https://atom.io) 上下载。
|
||||
相比一些重量级的 IDE（Integrated Development Environments，集成开发环境），如 Eclipse、NetBeans 和 IntelliJ IDEA (译者注：做项目强烈推荐IDEA)，编辑器是一种更纯粹的文本编辑器。如果你已经有了一个用着顺手的 IDE，那就可以直接用了。为了方便后面的学习和统一下教学环境，我推荐大家使用 Atom 这个编辑器。大家可以在 [atom.io](https://atom.io) 上下载。
|
||||
|
||||
Atom 是一个免费开源、易于安装且跨平台（支持 Window、Mac和Linux）的文本编辑器。内置支持 Java 文件。相比 IDE 的厚重，它比较轻量级，是学习本书的理想工具。Atom 包含了许多方便的编辑功能，相信你一定会爱上它！更多关于 Atom 使用的细节问题可以到它的网站上寻找。
|
||||
|
||||
还有很多其他的编辑器。有一种亚文化的群体，他们热衷于争论哪个更好用！如果你找到一个你更喜欢的编辑器，换一种使用也没什么难度。重要的是，你要找一个用着舒服的。
|
||||
|
||||
|
||||
## Shell
|
||||
|
||||
如果你之前没有接触过编程，那么有可能对 Shell（命令行窗口） 不太熟悉。shell 的历史可以追溯到早期的计算时代，当时在计算机上的操作是都通过输入命令进行的，计算机通过回显响应。所有的操作都是基于文本的。
|
||||
@@ -150,7 +148,6 @@ Java HotSpot(TM) 64-Bit Server VM (build 25.112-b15, mixed mode)
|
||||
```
|
||||
如果提示命令找不到或者无法被识别，请根据安装说明重试；如果还不行，尝试到 [StackOverflow](https://stackoverflow.com/search?q=installing+java) 寻找答案。
|
||||
|
||||
|
||||
## 安装和运行代码示例
|
||||
|
||||
当 Java 安装完毕，下一步就是安装本书的代码示例了。安装步骤所有平台一致：
|
||||
@@ -173,7 +170,7 @@ Java HotSpot(TM) 64-Bit Server VM (build 25.112-b15, mixed mode)
|
||||
|
||||
**注意**： 第一次运行 gradlew 命令时必须连接互联网。
|
||||
|
||||
**Gradle基础任务**
|
||||
**Gradle 基础任务**
|
||||
|
||||
本书构建的大量 Gradle 任务都可以自动运行。Gradle 使用约定大于配置的方式，简单设置即可具备高可用性。本书中“一起去骑行”的某些任务不适用于此或无法执行成功。以下是你通常会使用上的 Gradle 任务列表：
|
||||
|
||||
|
||||
@@ -33,39 +33,36 @@ Java 利用万物皆对象的思想和单一一致的语法方式来简化问题
|
||||
Java 语法允许我们使用带双引号的文本内容来初始化字符串。同样，其他类型的对象也有相应的初始化方式。
|
||||
|
||||
<!-- You Must Create All the Objects -->
|
||||
|
||||
## 对象创建
|
||||
|
||||
“引用”用来关联“对象”。在 Java 中，通常我们使用`new`操作符来创建一个新对象。`new`关键字代表：创建一个新的对象实例。所以，我们也可以这样来表示前面的代码示例：
|
||||
“引用”用来关联“对象”。在 Java 中，通常我们使用`new`操作符来创建一个新对象。`new` 关键字代表：创建一个新的对象实例。所以，我们也可以这样来表示前面的代码示例：
|
||||
|
||||
```java
|
||||
String s = new String("asdf");
|
||||
```
|
||||
以上展示了字符串对象的创建过程，以及如何初始化生成字符串。除了 **String** 类型以外，Java 本身自带了许多现成的数据类型。除此之外，我们还可以创建自己的数据类型。事实上，这是Java程序设计中的一项基本行为。在本书后面的学习中将会接触到。
|
||||
以上展示了字符串对象的创建过程，以及如何初始化生成字符串。除了 **String** 类型以外，Java 本身自带了许多现成的数据类型。除此之外，我们还可以创建自己的数据类型。事实上，这是 Java 程序设计中的一项基本行为。在本书后面的学习中将会接触到。
|
||||
|
||||
<!-- Where Storage Lives -->
|
||||
|
||||
### 数据存储
|
||||
|
||||
那么，程序在运行时是如何存储的呢？尤其是内存是怎么分配的。有5个不同的地方可以存储数据：
|
||||
|
||||
1. **寄存器** （Registers） 最快的存储区域，位于CPU内部 [^2]。然而，寄存器的数量十分有限，所以寄存器根据需求进行分配。我们对其没有直接的控制权，也无法在自己的程序里找到寄存器存在的踪迹（另一方面，C/C++ 允许开发者向编译器建议寄存器的分配）。
|
||||
1. **寄存器**（Registers）最快的存储区域，位于 CPU 内部 [^2]。然而，寄存器的数量十分有限，所以寄存器根据需求进行分配。我们对其没有直接的控制权，也无法在自己的程序里找到寄存器存在的踪迹（另一方面，C/C++ 允许开发者向编译器建议寄存器的分配）。
|
||||
|
||||
2. **栈内存**（Stack） 存在于常规内存 RAM （随机访问存储器，Random Access Memory）区域中，可通过栈指针获得处理器的直接支持。栈指针下移分配内存，上移释放内存，这是一种快速有效的内存分配方法，速度仅次于寄存器。创建程序时，Java 系统必须准确地知道栈内保存的所有项的生命周期。这种约束限制了程序的灵活性。因此，虽然在栈内存上存在一些 Java 数据，特别是对象引用，但 Java 对象却是保存在堆内存的。
|
||||
2. **栈内存**（Stack）存在于常规内存 RAM（随机访问存储器，Random Access Memory）区域中，可通过栈指针获得处理器的直接支持。栈指针下移分配内存，上移释放内存，这是一种快速有效的内存分配方法，速度仅次于寄存器。创建程序时，Java 系统必须准确地知道栈内保存的所有项的生命周期。这种约束限制了程序的灵活性。因此，虽然在栈内存上存在一些 Java 数据，特别是对象引用，但 Java 对象却是保存在堆内存的。
|
||||
|
||||
3. **堆内存**（Heap） 这是一种通用的内存池（也在 RAM区域），所有 Java 对象都存在于其中。与栈内存不同，编译器不需要知道对象必须在堆内存上停留多长时间。因此，用堆内存保存数据更具灵活性。创建一个对象时，只需用 `new` 命令实例化对象即可，当执行代码时，会自动在堆中进行内存分配。这种灵活性是有代价的：分配和清理堆内存要比栈内存需要更多的时间（如果可以用 Java 在栈内存上创建对象，就像在C++ 中那样的话）。随着时间的推移，Java 的堆内存分配机制现在已经非常快，因此这不是一个值得关心的问题了。
|
||||
3. **堆内存**（Heap）这是一种通用的内存池（也在 RAM 区域），所有 Java 对象都存在于其中。与栈内存不同，编译器不需要知道对象必须在堆内存上停留多长时间。因此，用堆内存保存数据更具灵活性。创建一个对象时，只需用 `new` 命令实例化对象即可，当执行代码时，会自动在堆中进行内存分配。这种灵活性是有代价的：分配和清理堆内存要比栈内存需要更多的时间（如果可以用 Java 在栈内存上创建对象，就像在 C++ 中那样的话）。随着时间的推移，Java 的堆内存分配机制现在已经非常快，因此这不是一个值得关心的问题了。
|
||||
|
||||
4. **常量存储** （Constant storage） 常量值通常直接放在程序代码中，因为它们永远不会改变。如需严格保护，可考虑将它们置于只读存储器 ROM （只读存储器，Read Only Memory）中 [^3]。
|
||||
|
||||
5. **非 RAM 存储** （Non-RAM storage） 数据完全存在于程序之外，在程序未运行以及脱离程序控制后依然存在。两个主要的例子：（1）序列化对象：对象被转换为字节流，通常被发送到另一台机器；（2）持久化对象：对象被放置在磁盘上，即使程序终止，数据依然存在。这些存储的方式都是将对象转存于另一个介质中，并在需要时恢复成常规的、基于 RAM 的对象。Java 为轻量级持久化提供了支持。而诸如 JDBC 和 Hibernate 这些类库为使用数据库存储和检索对象信息提供了更复杂的支持。
|
||||
4. **常量存储**（Constant storage）常量值通常直接放在程序代码中，因为它们永远不会改变。如需严格保护，可考虑将它们置于只读存储器 ROM （只读存储器，Read Only Memory）中 [^3]。
|
||||
|
||||
5. **非 RAM 存储**（Non-RAM storage）数据完全存在于程序之外，在程序未运行以及脱离程序控制后依然存在。两个主要的例子：（1）序列化对象：对象被转换为字节流，通常被发送到另一台机器；（2）持久化对象：对象被放置在磁盘上，即使程序终止，数据依然存在。这些存储的方式都是将对象转存于另一个介质中，并在需要时恢复成常规的、基于 RAM 的对象。Java 为轻量级持久化提供了支持。而诸如 JDBC 和 Hibernate 这些类库为使用数据库存储和检索对象信息提供了更复杂的支持。
|
||||
|
||||
<!-- Special Case: Primitive Types -->
|
||||
### 基本类型的存储
|
||||
|
||||
有一组类型在 Java 中使用频率很高，它们需要特殊对待，这就是 Java 的基本类型。之所以这么说，是因为它们的创建并不是通过 `new` 关键字来产生。通常 `new` 出来的对象都是保存在堆内存中的， 以此方式创建小而简单的变量往往是不划算的。所以对于这些基本类型的创建方法， Java 使用了和 C/C++ 一样的策略。也就是说，不是使用 `new` 创建变量，而是使用一个“自动”变量。 这个变量直接存储"值"，并置于栈内存中，因此更加高效。
|
||||
有一组类型在 Java 中使用频率很高，它们需要特殊对待，这就是 Java 的基本类型。之所以这么说，是因为它们的创建并不是通过 `new` 关键字来产生。通常 `new` 出来的对象都是保存在堆内存中的，以此方式创建小而简单的变量往往是不划算的。所以对于这些基本类型的创建方法，Java 使用了和 C/C++ 一样的策略。也就是说，不是使用 `new` 创建变量，而是使用一个“自动”变量。 这个变量直接存储"值"，并置于栈内存中，因此更加高效。
|
||||
|
||||
Java 确定了每种基本类型的内存占用大小。 这些大小不会像其他一些语言那样随着机器环境的变化而变化。这种不变性也是 Java 更具可移植性的一个原因。
|
||||
Java 确定了每种基本类型的内存占用大小。 这些大小不会像其他一些语言那样随着机器环境的变化而变化。这种不变性也是 Java 更具可移植性的一个原因。
|
||||
|
||||
| 基本类型 | 大小 | 最小值 | 最大值 | 包装类型 |
|
||||
| :------: | :------: | :------: | :------: | :------: |
|
||||
@@ -99,7 +96,6 @@ char c = ch;
|
||||
个中原因将在以后的章节里解释。
|
||||
|
||||
<!-- High-Precision Numbers -->
|
||||
|
||||
### 高精度数值
|
||||
|
||||
在 Java 中有两种类型的数据可用于高精度的计算。它们是 `BigInteger` 和 `BigDecimal`。尽管它们大致可以划归为“包装类型”，但是它们并没有对应的基本类型。
|
||||
@@ -112,10 +108,8 @@ BigDecimal 支持任意精度的定点数字。例如，可用它进行精确的
|
||||
关于这两个类的详细信息，请参考 JDK 官方文档。
|
||||
|
||||
<!-- Arrays in Java -->
|
||||
|
||||
### 数组的存储
|
||||
|
||||
|
||||
许多编程语言都支持数组类型。在 C 和 C++ 中使用数组是危险的，因为那些数组只是内存块。如果程序访问了内存块之外的数组或在初始化之前使用该段内存（常见编程错误），则结果是不可预测的。
|
||||
|
||||
Java 的设计主要目标之一是安全性，因此许多困扰 C 和 C++ 程序员的问题不会在 Java 中再现。在 Java 中，数组使用前需要被初始化，并且不能访问数组长度以外的数据。这种范围检查，是以每个数组上少量的内存开销及运行时检查下标的额外时间为代价的，但由此换来的安全性和效率的提高是值得的。（并且 Java 经常可以优化这些操作）。
|
||||
@@ -125,10 +119,8 @@ Java 的设计主要目标之一是安全性，因此许多困扰 C 和 C++ 程
|
||||
我们还可创建基本类型的数组。编译器通过将该数组的内存全部置零来保证初始化。本书稍后将详细介绍数组，特别是在数组章节中。
|
||||
|
||||
<!-- Comments -->
|
||||
|
||||
## 代码注释
|
||||
|
||||
|
||||
Java 中有两种类型的注释。第一种是传统的 C 风格的注释，以 `/*` 开头，可以跨越多行，到 `*/ ` 结束。注意，许多程序员在多行注释的每一行开头添加 `*`，所以你经常会看到：
|
||||
|
||||
```java
|
||||
@@ -138,7 +130,7 @@ Java 中有两种类型的注释。第一种是传统的 C 风格的注释，以
|
||||
*/
|
||||
```
|
||||
|
||||
但请记住， `/*` 和 `*/` 之间的内容都是被忽略的。所以你将其改为下面这样也是没有区别的。
|
||||
但请记住，`/*` 和 `*/` 之间的内容都是被忽略的。所以你将其改为下面这样也是没有区别的。
|
||||
|
||||
```java
|
||||
/* 这是跨越多
|
||||
@@ -154,12 +146,12 @@ Java 中有两种类型的注释。第一种是传统的 C 风格的注释，以
|
||||
<!-- You Never Need to Destroy an Object -->
|
||||
## 对象清理
|
||||
|
||||
在一些编程语言中，管理变量的生命周期需要大量的工作。一个变量需要存活多久？如果我们想销毁它，应该什么时候去做呢？变量生命周期的混乱会导致许多bug，本小结向你介绍 Java 是如何通过释放存储来简化这个问题的。
|
||||
在一些编程语言中，管理变量的生命周期需要大量的工作。一个变量需要存活多久？如果我们想销毁它，应该什么时候去做呢？变量生命周期的混乱会导致许多 bug，本小结向你介绍 Java 是如何通过释放存储来简化这个问题的。
|
||||
|
||||
<!-- Scoping -->
|
||||
### 作用域
|
||||
|
||||
大多数程序语言都有作用域的概念。作用域决定了在该范围内定义的变量名的可见性和生存周期。在 C、C++ 和 Java 中，作用域是由大括号 `{}` 的位置决定的。例如：
|
||||
大多数程序语言都有作用域的概念。作用域决定了在该范围内定义的变量名的可见性和生存周期。在 C、 C++ 和 Java 中，作用域是由大括号 `{}` 的位置决定的。例如：
|
||||
|
||||
```java
|
||||
{
|
||||
@@ -188,7 +180,6 @@ Java 的变量只有在其作用域内才可用。缩进使得 Java 代码更易
|
||||
在上例中， Java 编译器会在提示变量 x 已经被定义过了。因此，在 C/C++ 中将一个较大作用域的变量"隐藏"起来的做法，在 Java 中是不被允许的。 因为 Java 的设计者认为这样做会导致程序混乱。
|
||||
|
||||
<!-- Scope of Objects -->
|
||||
|
||||
### 对象作用域
|
||||
|
||||
Java 对象与基本类型具有不同的生命周期。当我们使用 `new` 关键字来创建 Java 对象时，它的生命周期将会超出作用域。因此，下面这段代码示例：
|
||||
@@ -199,14 +190,14 @@ Java 对象与基本类型具有不同的生命周期。当我们使用 `new`
|
||||
}
|
||||
// 作用域终点
|
||||
```
|
||||
|
||||
上例中，引用 s 在作用域终点就结束了。但是，引用 s 指向的字符串对象依然还在占用内存。在这段代码中，我们无法在这个作用域之后访问这个对象，因为唯一对它的引用 s 已超出了作用域的范围。在后面的章节中，我们还会学习怎么在编程中传递和复制对象的引用。
|
||||
|
||||
只要你需要， `new` 出来的对象就会一直存活下去。 相比在 C++ 编码中操作内存可能会出现的诸多问题，这些困扰在 Java 中都不复存在了。在 C++ 中你不仅要确保对象的内存在你操作的范围内存在，还必须在使用完它们之后，将其销毁。
|
||||
只要你需要，`new` 出来的对象就会一直存活下去。 相比在 C++ 编码中操作内存可能会出现的诸多问题，这些困扰在 Java 中都不复存在了。在 C++ 中你不仅要确保对象的内存在你操作的范围内存在，还必须在使用完它们之后，将其销毁。
|
||||
|
||||
那么问题来了：我们在 Java 中并没有主动清理这些对象，那么它是如何避免 C++ 中出现的内存被填满从而阻塞程序的问题呢？答案是：Java 的垃圾收集器会检查所有 `new` 出来的对象并判断哪些不再可达，继而释放那些被占用的内存，供其他新的对象使用。也就是说，我们不必担心内存回收的问题了。你只需简单创建对象即可。当其不再被需要时，能自行被垃圾收集器释放。垃圾回收机制有效防止了因程序员忘记释放内存而造成的“内存泄漏”问题。
|
||||
|
||||
<!-- Creating New Data Types: class -->
|
||||
|
||||
## 类的创建
|
||||
|
||||
### 类型
|
||||
@@ -228,7 +219,6 @@ ATypeName a = new ATypeName();
|
||||
到现在为止，我们还不能用这个对象来做什么事（即不能向它发送任何有意义的消息），除非我们在这个类里定义一些方法。
|
||||
|
||||
<!-- Fields -->
|
||||
|
||||
### 属性
|
||||
|
||||
当我们创建好一个类之后，我们可以往类里存放两种类型的元素：方法（method）和属性（field）。类的属性可以是基本类型，也可以是引用类型。如果类的属性是对某个对象的引用，那么必须要初始化该引用将其关联到一个实际的对象上（通过之前介绍的创建对象的方法）。每个对象都有用来存储其属性的空间。通常，属性不在对象间共享。下面是一个具有某些属性的类的代码示例：
|
||||
@@ -264,7 +254,6 @@ class DataOnly {
|
||||
你可以用这种方式嵌套许多对象（尽管这样的设计会带来混乱）。
|
||||
|
||||
<!-- Default Values for Primitive Members -->
|
||||
|
||||
### 基本类型默认值
|
||||
|
||||
如果类的成员变量（属性）是基本类型，那么在类初始化时，这些类型将会被赋予一个初始值。
|
||||
@@ -280,7 +269,7 @@ class DataOnly {
|
||||
| float | 0.0f |
|
||||
| double | 0.0d |
|
||||
|
||||
这些默认值仅在 Java 初始化类的时候才会被赋予。这种方式确保了基本类型的属性始终能被初始化（在C++ 中不会），从而减少了 bug 的来源。但是，这些初始值对于程序来说并不一定是合法或者正确的。 所以，为了安全，我们最好始终显式地初始化变量。
|
||||
这些默认值仅在 Java 初始化类的时候才会被赋予。这种方式确保了基本类型的属性始终能被初始化（在 C++ 中不会），从而减少了 bug 的来源。但是，这些初始值对于程序来说并不一定是合法或者正确的。 所以，为了安全，我们最好始终显式地初始化变量。
|
||||
|
||||
这种默认值的赋予并不适用于局部变量 —— 那些不属于类的属性的变量。 因此，若在方法中定义的基本类型数据，如下：
|
||||
|
||||
@@ -290,7 +279,6 @@ class DataOnly {
|
||||
|
||||
这里的变量 x 不会自动初始化为0，因而在使用变量 x 之前，程序员有责任主动地为其赋值（和 C 、C++ 一致）。如果我们忘记了这一步， Java 将会提示我们“编译时错误，该变量可能尚未被初始化”。 这一点做的比 C++ 更好，在后者中，编译器只是提示警告，而在 Java 中则直接报错。
|
||||
|
||||
|
||||
<!-- Methods, Arguments,and Return Values -->
|
||||
### 方法使用
|
||||
|
||||
@@ -316,7 +304,7 @@ Java 中的方法只能作为类的一部分创建。它只能被对象所调用
|
||||
[对象引用].[方法名](参数1, 参数2, 参数3);
|
||||
```
|
||||
|
||||
若方法不带参数，例如一个对象引用 `a` 的方法 `f` 不带参数并返回 **int** 型结果，我们可以如下表示：
|
||||
若方法不带参数，例如一个对象引用 `a` 的方法 `f` 不带参数并返回 **int** 型结果，我们可以如下表示：
|
||||
|
||||
```java
|
||||
int x = a.f();
|
||||
@@ -325,7 +313,6 @@ int x = a.f();
|
||||
上例中方法 `f` 的返回值类型必须和变量 `x` 的类型兼容 。调用方法的行为有时被称为向对象发送消息。面向对象编程可以总结为：向对象发送消息。
|
||||
|
||||
<!-- The Argument List -->
|
||||
|
||||
#### 参数列表
|
||||
|
||||
方法参数列表指定了传递给方法的信息。正如你可能猜到的，这些信息就像 Java 中的其他所有信息 ，以对象的形式传递。参数列表必须指定每个对象的类型和名称。同样，我们并没有直接处理对象，而是在传递对象引用 [^5] 。但是引用的类型必须是正确的。如果方法需要 String 参数，则必须传入 String，否则编译器将报错。
|
||||
@@ -336,7 +323,7 @@ int storage(String s) {
|
||||
}
|
||||
```
|
||||
|
||||
此方法计算并返回某个字符串所占的字节数。参数 `s` 的类型为 **String** 。将 s 传递给 `storage()` 后，我们可以把它看作和任何其他对象一样，可以向它发送消息。在这里，我们调用 `length()` 方法，它是一个 String 方法，返回字符串中的字符数。字符串中每个字符的大小为16位或2个字节。你还看到了 **return** 关键字，它执行两项操作。首先，它意味着“方法执行结束”。其次，如果方法有返回值，那么该值就紧跟 **return** 语句之后。这里，返回值是通过计算
|
||||
此方法计算并返回某个字符串所占的字节数。参数 `s` 的类型为 **String** 。将 s 传递给 `storage()` 后，我们可以把它看作和任何其他对象一样，可以向它发送消息。在这里，我们调用 `length()` 方法，它是一个 String 方法，返回字符串中的字符数。字符串中每个字符的大小为 16 位或 2 个字节。你还看到了 **return** 关键字，它执行两项操作。首先，它意味着“方法执行结束”。其次，如果方法有返回值，那么该值就紧跟 **return** 语句之后。这里，返回值是通过计算
|
||||
|
||||
```java
|
||||
s.length() * 2
|
||||
@@ -365,7 +352,6 @@ void nothing2() {
|
||||
|
||||
上面的描述可能会让你感觉程序只不过是一堆包含各种方法的对象，在这些方法中，将对象作为参数并发送消息给其他对象。大部分情况下确实如此。但在下一章的运算符中我们将会学习如何在方法中做出决策来完成更底层、详细的工作。对于本章，知道如何发送消息就够了。
|
||||
|
||||
|
||||
<!-- Writing a Java Program -->
|
||||
## 程序编写
|
||||
|
||||
@@ -377,11 +363,11 @@ void nothing2() {
|
||||
|
||||
Java 采取了一种新的方法避免了以上这些问题：为一个类库生成一个明确的名称，Java 创建者希望我们反向使用自己的网络域名，因为域名通常是唯一的。因此我的域名是 MindviewInc.com，所以我将我的 foibles 类库命名为 com.mindviewinc.utility.foibles。反转域名后，`.` 用来代表子目录的划分。
|
||||
|
||||
在 Java 1.0 和 Java 1.1 中，域扩展名 com，edu，org，net 等按惯例大写，因此类库中会出现这样类似的名称：Com.mindviewinc.utility.foibles。然而，在 Java 2 的开发过程中，他们发现这会导致问题，所以现在整个包名都是小写的。此机制意味着所有文件都自动存在于自己的命名空间中，文件中的每个类都具有唯一标识符。这样，Java 语言可以防止名称冲突。
|
||||
在 Java 1.0 和 Java 1.1 中，域扩展名 com、 edu、 org 和 net 等按惯例大写，因此类库中会出现这样类似的名称：com.mindviewinc.utility.foibles。然而，在 Java 2 的开发过程中，他们发现这会导致问题，所以现在整个包名都是小写的。此机制意味着所有文件都自动存在于自己的命名空间中，文件中的每个类都具有唯一标识符。这样，Java 语言可以防止名称冲突。
|
||||
|
||||
使用反向 URL 是一种新的命名空间方法，在此之前尚未有其他语言这么做过。Java 中有许多这些“创造性”地解决问题的方法。正如你想象，如果我们未经测试就添加一个功能并用于生产，那么在将来发现该功能的问题再想纠正，通常为时已晚（有些错误太严重了就得从语言中删除新功能。）
|
||||
|
||||
使用反向 URL 将命名空间与文件路径相关联不会导致BUG，但它却给源代码管理带来麻烦。例如在 `com.mindviewinc.utility.foibles` 这样的目录结构中，我们创建了 `com`、`mindviewinc` 空目录。它们存在的唯一目的就是用来表示这个反向的 URL。
|
||||
使用反向 URL 将命名空间与文件路径相关联不会导致BUG，但它却给源代码管理带来麻烦。例如在 `com.mindviewinc.utility.foibles` 这样的目录结构中，我们创建了 `com` 和 `mindviewinc` 空目录。它们存在的唯一目的就是用来表示这个反向的 URL。
|
||||
|
||||
这种方式似乎为我们在编写 Java 程序中的某个问题打开了大门。空目录填充了深层次结构，它们不仅用于表示反向 URL，还用于捕获其他信息。这些长路径基本上用于存储有关目录中的内容的数据。如果你希望以最初设计的方式使用目录，这种方法可以从“令人沮丧”到“令人抓狂”，对于生产级的 Java 代码，你必须使用专门为此设计的 IDE 来管理代码。例如 NetBeans，Eclipse 或 IntelliJ IDEA。实际上，这些 IDE 都为我们管理和创建深层次空目录结构。
|
||||
|
||||
@@ -390,7 +376,6 @@ Java 采取了一种新的方法避免了以上这些问题：为一个类库生
|
||||
<!-- Using Other Components -->
|
||||
#### 使用其他组件
|
||||
|
||||
|
||||
无论何时在程序中使用预先定义好的类，编译器都必须找到该类。最简单的情况下，该类存在于被调用的源代码文件中。此时我们使用该类 —— 即使该类在文件的后面才会被定义（Java 消除了所谓的“前向引用”问题）。而如果一个类位于其他文件中，又会怎样呢？你可能认为编译器应该足够智能去找到它，但这样是有问题的。想象一下，假如你要使用某个类，但目录中存在多个同名的类（可能用途不同）。或者更糟糕的是，假设你正在编写程序，在构建过程中，你想将某个新类添加到类库中，但却与已有的类名称冲突。
|
||||
|
||||
要解决此问题，你必须通过使用 **import** 关键字来告诉 Java 编译器具体要使用的类。**import** 指示编译器导入一个包，也就是一个类库（在其他语言中，一个库不仅包含类，还可能包括函数和数据，但请记住 Java 中的所有代码都必须写在类里）。大多数时候，我们都在使用 Java 标准库中的组件。有了这些构件，你就不必写一长串的反转域名。例如：
|
||||
@@ -408,7 +393,6 @@ import java.util.*;
|
||||
本书中的示例很小，为简单起见，我们通常会使用 `.*` 形式略过导入。然而，许多教程书籍都会要求程序员逐一导入每个类。
|
||||
|
||||
<!-- The static Keyword -->
|
||||
|
||||
#### static关键字
|
||||
|
||||
类是对象的外观及行为方式的描述。通常只有在使用 `new` 创建那个类的对象后，数据存储空间才被分配，对象的方法才能供外界调用。这种方式在两种情况下是不足的。
|
||||
@@ -470,7 +454,6 @@ Incrementable.increment()；
|
||||
相比非静态的对象，`static` 属性改变了数据创建的方式。同样，当 `static` 关键字修饰方法时，它允许我们无需创建对象就可以直接通过类的引用来调用该方法。正如我们所知，`static` 关键字的这些特性对于应用程序入口点的 `main()` 方法尤为重要。
|
||||
|
||||
<!-- Your First Java Program -->
|
||||
|
||||
## 小试牛刀
|
||||
|
||||
最后，我们开始编写第一个完整的程序。我们使用 Java 标准库中的 **Date** 类来展示一个字符串和日期。
|
||||
@@ -566,7 +549,6 @@ java.io.tmpdir=C:\Users\Bruce\AppData\Local\Temp\
|
||||
`main()` 方法中的第一行会输出所有的系统属性，也就是环境信息。 **list()** 方法将结果发送给它的参数 **System.out**。在本书的后面，我们还会接触到将结果输出到其他地方，例如文件中。另外，我们还可以请求特定的属性。该例中我们使用到了 **user.name** 和 **java.library.path**。
|
||||
|
||||
<!-- Compiling and Running -->
|
||||
|
||||
### 编译和运行
|
||||
|
||||
要编译和运行本书中的代码示例，首先必须具有 Java 编程环境。 第二章的示例中描述了安装过程。如果你遵循这些说明，那么你将会在不受 Oracle 的限制的条件下用到 Java 开发工具包（JDK）。如果你使用其他开发系统，请查看该系统的文档以确定如何编译和运行程序。 第二章还介绍了如何安装本书的示例。
|
||||
@@ -589,15 +571,14 @@ java HelloDate
|
||||
<!-- Coding Style -->
|
||||
## 编码风格
|
||||
|
||||
|
||||
Java 编程语言编码规范（Code Conventions for the Java Programming Language）[^10] 要求类名的首字母大写。 如果类名是由多个单词构成的，则每个单词的首字母都应大写（不采用下划线来分隔）例如：
|
||||
|
||||
```java
|
||||
class AllTheColorsOfTheRainbow {
|
||||
// ...
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
有时称这种命名风格叫“驼峰命名法”。对于几乎所有其他方法，字段（成员变量）和对象引用名都采用驼峰命名的方式，但是它们的首字母不需要大写。代码示例：
|
||||
|
||||
```java
|
||||
@@ -613,13 +594,10 @@ class AllTheColorsOfTheRainbow {
|
||||
|
||||
在 Oracle 的官方类库中，花括号的位置同样遵循和本书中上述示例相同的规范。
|
||||
|
||||
|
||||
## 本章小结
|
||||
|
||||
|
||||
本章向你展示了简单的 Java 程序编写以及该语言相关的基本概念。到目前为止，我们的示例都只是些简单的顺序执行。在接下来的两章里，我们将会接触到 Java 的一些基本操作符，以及如何去控制程序执行的流程。
|
||||
|
||||
|
||||
[^1]: 这里可能有争议。有人说这是一个指针，但这假定了一个潜在的实现。此外，Java 引用的语法更类似于 C++ 引用而非指针。在 《Thinking in Java》 的第 1 版中，我发明了一个新术语叫“句柄”（handle），因为 C++ 引用和Java 引用有一些重要的区别。作为一个从 C++ 的过来人，我不想混淆 Java 可能的最大受众 —— C++ 程序员。在《Thinking in Java》的第 2 版中，我认为“引用”（reference）是更常用的术语，从 C++ 转过来的人除了引用的术语之外，还有很多东西需要处理，所以他们不妨双脚都跳进去。但是，也有些人甚至不同意“引用”。在某书中我读到一个观点：Java 支持引用传递的说法是完全错误的，因为 Java 对象标识符（根据该作者）实际上是“对象引用”（object references），并且一切都是值传递。所以你不是通过引用传递，而是“通过值传递对象引用。人们可以质疑我的这种解释的准确性，但我认为我的方法简化了对概念的理解而又没对语言造成伤害（嗯，语言专家可能会说我骗你，但我会说我只是对此进行了适当的抽象。）
|
||||
|
||||
[^2]: 大多数微处理器芯片都有额外的高速缓冲存储器，但这是按照传统存储器而不是寄存器。
|
||||
@@ -628,7 +606,7 @@ class AllTheColorsOfTheRainbow {
|
||||
|
||||
[^4]: 静态方法，我们很快就能接触到，它可以在没有对象的情况下直接被类调用。
|
||||
|
||||
[^5]: 通常除了前面提到的“特殊”数据类型 boolean，char，byte，short，int，long，float 和 double。通常来说，传递对象就意味者传递对象的引用。
|
||||
[^5]: 通常除了前面提到的“特殊”数据类型 boolean、 char、 byte、 short、 int、 long、 float 和 double。通常来说，传递对象就意味者传递对象的引用。
|
||||
|
||||
[^6]: 静态方法在使用之前不需要创建对象，因此它们不能直接调用非静态的成员或方法（因为非静态成员和方法必须要先实例化为对象才可以被使用）。
|
||||
|
||||
@@ -639,6 +617,6 @@ class AllTheColorsOfTheRainbow {
|
||||
[^9]: 对于本书中编译和运行命令行的每个程序，你可能还需要设置 CLASSPATH 。
|
||||
|
||||
[^10]: 为了保持本书的代码排版紧凑，我并没完全遵守规范，但我尽量会做到符合 Java 标准。
|
||||
<!-- 分页 -->
|
||||
|
||||
<div style="page-break-after: always;"></div>
|
||||
<!-- 分页 -->
|
||||
<div style="page-break-after: always;"></div>
|
||||
@@ -3,27 +3,22 @@
|
||||
<!-- Operators -->
|
||||
# 第四章 运算符
|
||||
|
||||
|
||||
>运算符操纵数据。
|
||||
|
||||
Java 是从 C++ 的基础上做了一些改进和简化发展而成的。对于 C/C++ 程序员来说，Java 的运算符并不陌生。如果你已了解 C 或 C++，大可以跳过本章和下一章，直接阅读 Java 与 C/C++ 不同的地方。
|
||||
|
||||
如果理解这两章的内容对你来说还有点困难，那么我推荐你先了解下 《Thinking in C》 再继续后面的学习。 这本书现在可以在 [www.OnJava8.com](http://www.OnJava8.com]) 上免费下载。它的内容包含音频讲座、幻灯片、练习和解答，专门用于帮助你快速掌握学习 Java 所需的基础知识。
|
||||
|
||||
|
||||
<!-- Using-Java-Operators -->
|
||||
## 使用说明
|
||||
## 使用Java运算符
|
||||
|
||||
|
||||
运算符接受一个或多个参数并生成新值。这个参数与普通方法调用的形式不同，但效果是相同的。加法 `+`，减法 `-`，乘法 `*`，除法 `/` 以及赋值 `=` 在任何编程语言中的工作方式都是类似的。所有运算符都能根据自己的运算对象生成一个值。除此以外，一些运算符可改变运算对象的值，这叫作“副作用”（**Side Effect**）。运算符最常见的用途就是修改自己的运算对象，从而产生副作用。但要注意生成的值亦可由没有副作用的运算符生成。
|
||||
运算符接受一个或多个参数并生成新值。这个参数与普通方法调用的形式不同，但效果是相同的。加法 `+`、减法 `-`、乘法 `*`、除法 `/` 以及赋值 `=` 在任何编程语言中的工作方式都是类似的。所有运算符都能根据自己的运算对象生成一个值。除此以外，一些运算符可改变运算对象的值，这叫作“副作用”（**Side Effect**）。运算符最常见的用途就是修改自己的运算对象，从而产生副作用。但要注意生成的值亦可由没有副作用的运算符生成。
|
||||
|
||||
几乎所有运算符都只能操作基本类型（Primitives）。唯一的例外是 `=`、`==` 和 `!=`，它们能操作所有对象（这也是令人混淆的一个地方）。除此以外，**String** 类支持 `+` 和 `+=`。
|
||||
|
||||
<!-- Precedence -->
|
||||
|
||||
## 优先级
|
||||
|
||||
|
||||
运算符的优先级决定了存在多个运算符时一个表达式各部分的运算顺序。Java 对运算顺序作出了特别的规定。其中，最简单的规则就是乘法和除法在加法和减法之前完成。程序员经常都会忘记其他优先级规则，所以应该用括号明确规定运算顺序。代码示例:
|
||||
|
||||
```java
|
||||
@@ -40,7 +35,7 @@ public class Precedence {
|
||||
}
|
||||
```
|
||||
|
||||
输出结果:
|
||||
输出结果:
|
||||
|
||||
```
|
||||
a = 5
|
||||
@@ -52,13 +47,11 @@ public class Precedence {
|
||||
我们注意到，在 `System.out.println()` 语句中使用了 `+` 运算符。 但是在这里 `+` 代表的意思是字符串连接符。编译器会将 `+` 连接的非字符串尝试转换为字符串。上例中的输出结果说明了 a 和 b 都已经被转化成了字符串。
|
||||
|
||||
<!-- Assignment -->
|
||||
|
||||
## 赋值
|
||||
|
||||
运算符的赋值是由符号 `=` 完成的。它代表着获取 `=` 右边的值并赋给左边的变量。右边可以是任何常量、变量或者可产生一个返回值的表达式。但左边必须是一个明确的、已命名的变量。也就是说，必须要有一个物理的空间来存放右边的值。举个例子来说，可将一个常数赋给一个变量（A = 4），但不可将任何东西赋给一个常数（比如不能 4 = A）。
|
||||
|
||||
运算符的赋值是由符号 `=` 完成的。它代表着获取 `=` 右边的值并赋给左边的变量。右边可以是任何常量、变量或者可产生一个返回值的表达式。但左边必须是一个明确的、已命名的变量。也就是说，必须要有一个物理的空间来存放右边的值。举个例子来说，可将一个常数赋给一个变量（ A = 4 ），但不可将任何东西赋给一个常数（比如不能 4 = A）。
|
||||
|
||||
基本类型的赋值都是直接的，而不像对象，赋予的只是其内存的引用。举个例子，a = b ，如果 b 是基本类型，那么 赋值操作会将 b 的值复制一份给变量 a， 此后若 a 的值发生改变是不会影响到 b 的。作为一名程序员，这应该成为我们的常识。
|
||||
基本类型的赋值都是直接的，而不像对象，赋予的只是其内存的引用。举个例子，a = b ，如果 b 是基本类型，那么赋值操作会将 b 的值复制一份给变量 a， 此后若 a 的值发生改变是不会影响到 b 的。作为一名程序员，这应该成为我们的常识。
|
||||
|
||||
如果是为对象赋值，那么结果就不一样了。对一个对象进行操作时，我们实际上操作的是它的引用。所以我们将右边的对象赋予给左边时，赋予的只是该对象的引用。此时，两者指向的堆中的对象还是同一个。代码示例：
|
||||
|
||||
@@ -96,7 +89,7 @@ public class Assignment {
|
||||
3: t1.level: 27, t2.level: 27
|
||||
```
|
||||
|
||||
这是一个简单的 `Tank` 类，在 `main()` 方法创建了 2 个实例对象。 两个对象的 `level` 属性分别被赋予不同的值。 然后，t2 的值被赋予给 t1。在许多编程语言里，预期的结果是 t1 和 t2 的值会一直相对独立。但是，在 Java 中，由于赋予的只是对象的引用，改变 t1 也就改变了 t2。 这是因为 t1 和 t2 此时指向的是堆中同一个对象。（t1 原始对象的引用在 t2 赋值给其时丢失，它引用的对象会在垃圾回收时被清理）。
|
||||
这是一个简单的 `Tank` 类，在 `main()` 方法创建了两个实例对象。 两个对象的 `level` 属性分别被赋予不同的值。 然后，t2 的值被赋予给 t1。在许多编程语言里，预期的结果是 t1 和 t2 的值会一直相对独立。但是，在 Java 中，由于赋予的只是对象的引用，改变 t1 也就改变了 t2。 这是因为 t1 和 t2 此时指向的是堆中同一个对象。（t1 原始对象的引用在 t2 赋值给其时丢失，它引用的对象会在垃圾回收时被清理）。
|
||||
|
||||
这种现象通常称为别名（aliasing），这是 Java 处理对象的一种基本方式。但是假若你不想出现这里的别名引起混淆的话，你可以这么做。代码示例：
|
||||
|
||||
@@ -143,14 +136,12 @@ public class PassObject {
|
||||
在许多编程语言中，方法 `f()` 似乎会在内部复制其参数 **Letter y**。但是一旦传递了一个引用，那么实际上 `y.c ='z';` 是在方法 `f()` 之外改变对象。别名现象以及其解决方案是个复杂的问题，在附录中有包含：[对象传递和返回](./Appendix-Passing-and-Returning-Objects.md)。意识到这一点，我们可以警惕类似的陷阱。
|
||||
|
||||
<!-- Mathematical Operators -->
|
||||
|
||||
## 算术运算符
|
||||
|
||||
Java 的基本算术运算符与其他大多编程语言是相同的。其中包括加号 `+`、减号 `-`、除号 `/`、乘号 `*` 以及取模 `%`（从整数除法中获得余数）。整数除法会直接砍掉小数，而不是进位。
|
||||
|
||||
Java 也用一种与 C++ 相同的简写形式同时进行运算和赋值操作，由运算符后跟等号表示，并且与语言中的所有运算符一致（只要有意义）。 可用 x += 4 来表示：将 x 的值加上4的结果再赋值给 x。更多代码示例：
|
||||
|
||||
|
||||
```java
|
||||
// operators/MathOps.java
|
||||
// The mathematical operators
|
||||
@@ -233,7 +224,6 @@ u /= v : 9.940527
|
||||
为了生成随机数字，程序首先创建一个 **Random** 对象。不带参数的 **Random** 对象会利用当前的时间用作随机数生成器的“种子”（seed），从而为程序的每次执行生成不同的输出。在本书的示例中，重要的是每个示例末尾的输出尽可能一致，以便可以使用外部工具进行验证。所以我们通过在创建 **Random** 对象时提供种子（随机数生成器的初始化值，其始终为特定种子值产生相同的序列），让程序每次执行都生成相同的随机数，如此以来输出结果就是可验证的 [^1]。 若需要生成随机值，可删除代码示例中的种子参数。该对象通过调用方法 `nextInt()` 和 `nextFloat()`（还可以调用 `nextLong()` 或 `nextDouble()`），使用 **Random** 对象生成许多不同类型的随机数。`nextInt()` 的参数设置生成的数字的上限，下限为零，为了避免零除的可能性，结果偏移1。
|
||||
|
||||
<!-- Unary Minus and Plus Operators -->
|
||||
|
||||
### 一元加减运算符
|
||||
|
||||
一元加 `+` 减 `-` 运算符的操作和二元是相同的。编译器可自动识别使用何种方式解析运算：
|
||||
@@ -257,10 +247,8 @@ x = a * (-b);
|
||||
一元减号可以得到数据的负值。一元加号的作用相反，不过它唯一能影响的就是把较小的数值类型自动转换为 **int** 类型。
|
||||
|
||||
<!-- Auto-Increment-and-Decrement -->
|
||||
|
||||
## 递增和递减
|
||||
|
||||
|
||||
和 C 语言类似，Java 提供了许多快捷运算方式。快捷运算可使代码可读性，可写性都更强。其中包括递增 `++` 和递减 `--`，意为“增加或减少一个单位”。举个例子来说，假设 a 是一个 **int** 类型的值，则表达式 `++a` 就等价于 `a = a + 1`。 递增和递减运算符不仅可以修改变量，还可以生成变量的值。
|
||||
|
||||
每种类型的运算符，都有两个版本可供选用；通常将其称为“前缀”和“后缀”。“前递增”表示 `++` 运算符位于变量或表达式的前面；而“后递增”表示 `++` 运算符位于变量的后面。类似地，“前递减”意味着 `--` 运算符位于变量的前面；而“后递减”意味着 `--` 运算符位于变量的后面。对于前递增和前递减（如 `++a` 或 `--a`），会先执行递增/减运算，再返回值。而对于后递增和后递减（如 `a++` 或 `a--`），会先返回值，再执行递增/减运算。代码示例：
|
||||
@@ -298,15 +286,12 @@ i: 1
|
||||
|
||||
C++ 名称来自于递增运算符，暗示着“比 C 更进一步”。在早期的 Java 演讲中，*Bill Joy*（Java 作者之一）说“**Java = C++ --**”（C++ 减减），意味着 Java 在 C++ 的基础上减少了许多不必要的东西，因此语言更简单。随着进一步地学习，我们会发现 Java 的确有许多地方相对 C++ 来说更简便，但是在其他方面，难度并不会比 C++ 小多少。
|
||||
|
||||
|
||||
<!-- Relational-Operators -->
|
||||
## 关系运算符
|
||||
|
||||
|
||||
关系运算符会通过产生一个布尔（**boolean**）结果来表示操作数之间的关系。如果关系为真，则结果为 **true**，如果关系为假，则结果为 **false**。关系运算符包括小于 `<`，大于 `>`，小于或等于 `<=`，大于或等于 `>=`，等于 `==` 和不等于 `！=`。`==` 和 `!=` 可用于所有基本类型，但其他运算符不能用于基本类型 **boolean**，因为布尔值只能表示 **true** 或 **false**，所以比较它们之间的“大于”或“小于”没有意义。
|
||||
|
||||
<!-- Testing Object Equivalence -->
|
||||
|
||||
### 测试对象等价
|
||||
|
||||
关系运算符 `==` 和 `!=` 同样适用于所有对象之间的比较运算，但它们比较的内容却经常困扰 Java 的初学者。下面是代码示例：
|
||||
@@ -330,7 +315,7 @@ true
|
||||
false
|
||||
```
|
||||
|
||||
表达式 `System.out.println(n1 == n2)` 将会输出比较的结果。因为两个 **Integer** 对象相同，所以先输出 **true**，再输出 **false**。但是，尽管对象的内容一样，对象的引用却不一样。`==` 和 `!=` 比较的是对象引用，所以输出实际上应该是先输出 **false**，再输出 **true**（译者注：如果你把47改成128，那么打印的结果就是这样，因为 Integer 内部维护着一个 IntegerCache 的缓存，默认缓存范围是 [-128, 127]，所以 [-128, 127] 之间的值用 `==` 和 `!=` 比较也能能到正确的结果，但是不推荐用关系运算符比较，具体见 JDK 中的 Integer 类源码）。
|
||||
表达式 `System.out.println(n1 == n2)` 将会输出比较的结果。因为两个 **Integer** 对象相同，所以先输出 **true**，再输出 **false**。但是，尽管对象的内容一样，对象的引用却不一样。`==` 和 `!=` 比较的是对象引用，所以输出实际上应该是先输出 **false**，再输出 **true**（译者注：如果你把 47 改成 128，那么打印的结果就是这样，因为 Integer 内部维护着一个 IntegerCache 的缓存，默认缓存范围是 [-128, 127]，所以 [-128, 127] 之间的值用 `==` 和 `!=` 比较也能能到正确的结果，但是不推荐用关系运算符比较，具体见 JDK 中的 Integer 类源码）。
|
||||
|
||||
那么怎么比较两个对象的内容是否相同呢？你必须使用所有对象（不包括基本类型）中都存在的 `equals()` 方法，下面是如何使用 `equals()` 方法的示例：
|
||||
|
||||
@@ -381,7 +366,6 @@ false
|
||||
大多数 Java 库类通过覆写 `equals()` 方法比较对象的内容而不是其引用。
|
||||
|
||||
<!-- Logical Operators -->
|
||||
|
||||
## 逻辑运算符
|
||||
|
||||
每个逻辑运算符 `&&` （**AND**）、`||`（**OR**）和 `!`（**非**）根据参数的逻辑关系生成布尔值 `true` 或 `false`。下面的代码示例使用了关系运算符和逻辑运算符：
|
||||
@@ -430,12 +414,11 @@ i != j is true
|
||||
(i < 10) || (j < 10) is false
|
||||
```
|
||||
|
||||
在 Java 逻辑运算中，我们不能像 C/C++ 那样使用非布尔值， 而仅能使用 **AND**、**OR**、**NOT**。上面的例子中，我们将使用非布尔值的表达式注释掉了（你可以看到表达式前面是 //-）。但是，后续的表达式使用关系比较生成布尔值，然后对结果使用了逻辑运算。请注意，如果在预期为 **String** 类型的位置使用 **boolean** 类型的值，则结果会自动转为适当的文本格式（即 "true" 或 "false" 字符串）。
|
||||
在 Java 逻辑运算中，我们不能像 C/C++ 那样使用非布尔值， 而仅能使用 **AND**、 **OR**、 **NOT**。上面的例子中，我们将使用非布尔值的表达式注释掉了（你可以看到表达式前面是 //-）。但是，后续的表达式使用关系比较生成布尔值，然后对结果使用了逻辑运算。请注意，如果在预期为 **String** 类型的位置使用 **boolean** 类型的值，则结果会自动转为适当的文本格式（即 "true" 或 "false" 字符串）。
|
||||
|
||||
我们可以将前一个程序中 **int** 的定义替换为除 **boolean** 之外的任何其他基本数据类型。但请注意，**float** 类型的数值比较非常严格，只要两个数字的最小位不同则两个数仍然不相等；只要数字最小位是大于 0 的，那么它就不等于 0。
|
||||
|
||||
<!-- Short-Circuiting -->
|
||||
|
||||
### 短路
|
||||
|
||||
逻辑运算符支持一种称为“短路”（short-circuiting）的现象。整个表达式会在运算到可以明确结果时就停止并返回结果，这意味着该逻辑表达式的后半部分不会被执行到。代码示例：
|
||||
@@ -491,10 +474,8 @@ test1（0）&& test2（2）&& test3（2）
|
||||
所以，运用“短路”可以节省部分不必要的运算，从而提高程序潜在的性能。
|
||||
|
||||
<!-- Literals -->
|
||||
|
||||
## 字面值常量
|
||||
|
||||
|
||||
通常，当我们向程序中插入一个字面值常量（**Literal**）时，编译器会确切地识别它的类型。当类型不明确时，必须辅以字面值常量关联来帮助编译器识别。代码示例：
|
||||
|
||||
```java
|
||||
@@ -563,7 +544,6 @@ bll: 101111101011111010111110101111
|
||||
|
||||
在文本值的后面添加字符可以让编译器识别该文本值的类型。对于 **Long** 型数值，结尾使用大写 `L` 或小写 `l` 皆可（不推荐使用 `l`，因为容易与阿拉伯数值 1 混淆）。大写 `F` 或小写 `f` 表示 **float** 浮点数。大写 `D` 或小写 `d` 表示 **double** 双精度。
|
||||
|
||||
|
||||
十六进制（以 16 为基数），适用于所有整型数据类型，由前导 `0x` 或 `0X` 表示，后跟 0-9 或 a-f （大写或小写）。如果我们在初始化某个类型的数值时，赋值超出其范围，那么编译器会报错（不管值的数字形式如何）。在上例的代码中，**char**、**byte** 和 **short** 的值已经是最大了。如果超过这些值，编译器将自动转型为 **int**，并且提示我们需要声明强制转换（强制转换将在本章后面定义），意味着我们已越过该类型的范围界限。
|
||||
|
||||
八进制（以 8 为基数）由 0~7 之间的数字和前导零 `0` 表示。
|
||||
@@ -573,13 +553,10 @@ Java 7 引入了二进制的字面值常量，由前导 `0b` 或 `0B` 表示，
|
||||
使用整型数值类型时，显示其二进制形式会很有用。在 Long 型和 Integer 型中这很容易实现，调用其静态的 `toBinaryString()` 方法即可。 但是请注意，若将较小的类型传递给 **Integer.**`tobinarystring()` 时，类型将自动转换为 **int**。
|
||||
|
||||
<!-- Underscores in Literals -->
|
||||
|
||||
### 下划线
|
||||
|
||||
|
||||
Java 7 中有一个深思熟虑的补充：我们可以在数字字面量中包含下划线 `_`，以使结果更清晰。这对于大数值的分组特别有用。代码示例：
|
||||
|
||||
|
||||
```java
|
||||
// operators/Underscores.java
|
||||
public class Underscores {
|
||||
@@ -604,7 +581,6 @@ public class Underscores {
|
||||
7fe9b7aa
|
||||
```
|
||||
|
||||
|
||||
下面是合理使用的规则：
|
||||
|
||||
1. 仅限单 `_`，不能多条相连。
|
||||
@@ -612,13 +588,12 @@ public class Underscores {
|
||||
3. `F`、`D` 和 `L`的前后禁止出现 `_`。
|
||||
4. 二进制前导 `b` 和 十六进制 `x` 前后禁止出现 `_`。
|
||||
|
||||
[1] 注意 `％n`的使用。熟悉 C 风格的程序员可能习惯于看到 `\n` 来表示换行符。问题在于它给你的是一个“Unix风格”的换行符。此外，如果我们使用的是 Windows，则必须指定 `\r\n`。这种差异的包袱应该由编程语言来解决。这就是Java用 `％n` 实现的可以忽略平台间差异而生成适当的换行符，但只有当你使用 `System.out.printf()` 或 `System.out.format()` 时。对于 `System.out.println()`，我们仍然必须使用 `\n`；如果你使用 `％n`，`println()` 只会输出 `％n` 而不是换行符。
|
||||
[1] 注意 `％n`的使用。熟悉 C 风格的程序员可能习惯于看到 `\n` 来表示换行符。问题在于它给你的是一个“Unix风格”的换行符。此外，如果我们使用的是 Windows，则必须指定 `\r\n`。这种差异的包袱应该由编程语言来解决。这就是 Java 用 `％n` 实现的可以忽略平台间差异而生成适当的换行符，但只有当你使用 `System.out.printf()` 或 `System.out.format()` 时。对于 `System.out.println()`，我们仍然必须使用 `\n`；如果你使用 `％n`，`println()` 只会输出 `％n` 而不是换行符。
|
||||
|
||||
<!-- Exponential Notation -->
|
||||
|
||||
### 指数计数法
|
||||
|
||||
指数总是采用一种我认为很不直观的记号方法:
|
||||
指数总是采用一种我认为很不直观的记号方法:
|
||||
|
||||
```java
|
||||
// operators/Exponents.java
|
||||
@@ -643,9 +618,9 @@ public class Exponents {
|
||||
4.7E48
|
||||
```
|
||||
|
||||
在科学与工程学领域，**e** 代表自然对数的基数，约等于 2.718 （Java 里用一种更精确的 **double** 值 **Math.E** 来表示自然对数）。指数表达式 "1.39 x e-43"，意味着“1.39 × 2.718 的-43次方”。然而，自 FORTRAN 语言发明后，人们自然而然地觉得e 代表 “10的几次幂”。这种做法显得颇为古怪，因为 FORTRAN 最初是为科学与工程领域设计的。
|
||||
在科学与工程学领域，**e** 代表自然对数的基数，约等于 2.718 （Java 里用一种更精确的 **double** 值 **Math.E** 来表示自然对数）。指数表达式 "1.39 x e-43"，意味着 “1.39 × 2.718 的 -43 次方”。然而，自 FORTRAN 语言发明后，人们自然而然地觉得e 代表 “10 的几次幂”。这种做法显得颇为古怪，因为 FORTRAN 最初是为科学与工程领域设计的。
|
||||
|
||||
理所当然，它的设计者应对这样的混淆概念持谨慎态度 [^2]。但不管怎样，这种特别的表达方法在 C，C++ 以及现在的 Java 中顽固地保留下来了。所以倘若习惯 e 作为自然对数的基数使用，那么在 Java 中看到类似“1.39e-43f”这样的表达式时，请转换你的思维，从程序设计的角度思考它；它真正的含义是“1.39 × 10的-43次方”。
|
||||
理所当然，它的设计者应对这样的混淆概念持谨慎态度 [^2]。但不管怎样，这种特别的表达方法在 C，C++ 以及现在的 Java 中顽固地保留下来了。所以倘若习惯 e 作为自然对数的基数使用，那么在 Java 中看到类似“1.39e-43f”这样的表达式时，请转换你的思维，从程序设计的角度思考它；它真正的含义是 “1.39 × 10 的 -43 次方”。
|
||||
|
||||
注意如果编译器能够正确地识别类型，就不必使用后缀字符。对于下述语句：
|
||||
|
||||
@@ -662,10 +637,8 @@ float f4 = 1e-43f; //10 的幂数
|
||||
编译器通常会将指数作为 **double** 类型来处理，所以假若没有这个后缀字符 `f`，编译器就会报错，提示我们应该将 **double** 型转换成 **float** 型。
|
||||
|
||||
<!-- Bitwise-Operators -->
|
||||
|
||||
## 位运算符
|
||||
|
||||
|
||||
位运算符允许我们操作一个整型数字中的单个二进制位。位运算符会对两个整数对应的位执行布尔代数，从而产生结果。
|
||||
|
||||
位运算源自 C 语言的底层操作。我们经常要直接操纵硬件，频繁设置硬件寄存器内的二进制位。Java 的设计初衷是电视机顶盒嵌入式开发，所以这种底层的操作仍被保留了下来。但是，你可能不会使用太多位运算。
|
||||
@@ -676,16 +649,13 @@ float f4 = 1e-43f; //10 的幂数
|
||||
|
||||
我们将 **Boolean** 类型被视为“单位值”（one-bit value），所以它多少有些独特的地方。我们可以对 boolean 型变量执行与、或、异或运算，但不能执行非运算（大概是为了避免与逻辑“非”混淆）。对于布尔值，位运算符具有与逻辑运算符相同的效果，只是它们不会中途“短路”。此外，针对布尔值进行的位运算为我们新增了一个“异或”逻辑运算符，它并未包括在逻辑运算符的列表中。在移位表达式中，禁止使用布尔值，原因将在下面解释。
|
||||
|
||||
|
||||
<!-- Shift Operators -->
|
||||
## 移位运算符
|
||||
|
||||
|
||||
移位运算符面向的运算对象也是二进制的“位”。它们只能用于处理整数类型（基本类型的一种）。左移位运算符 `<<` 能将其左边的运算对象向左移动右侧指定的位数（在低位补 0）。右移位运算符 `>>` 则相反。右移位运算符有“正”、“负”值：若值为正，则在高位插入 0；若值为负，则在高位插入 1。Java 也添加了一种“不分正负”的右移位运算符（>>>），它使用了“零扩展”（zero extension）：无论正负，都在高位插入 0。这一运算符是 C/C++ 没有的。
|
||||
|
||||
如果移动 **char**、**byte** 或 **short**，则会在移动发生之前将其提升为 **int**，结果为 **int**。仅使用右侧的 5 个低阶位。这可以防止我们移动超过 **int** 范围的位数。若对一个 **long** 值进行处理，最后得到的结果也是 **long**。
|
||||
|
||||
|
||||
移位可以与等号 `<<=` 或 `>>=` 或 `>>>=` 组合使用。左值被替换为其移位运算后的值。但是，问题来了，当无符号右移与赋值相结合时，若将其与 **byte** 或 **short** 一起使用的话，则结果错误。取而代之的是，它们被提升为 **int** 型并右移，但在重新赋值时被截断。在这种情况下，结果为 -1。下面是代码示例：
|
||||
|
||||
```java
|
||||
@@ -836,22 +806,19 @@ i >>> 5, int: 97591828, binary:
|
||||
...
|
||||
```
|
||||
|
||||
|
||||
结尾的两个方法 `printBinaryInt()` 和 `printBinaryLong()` 分别操作一个 **int** 和 **long** 值，并转换为二进制格式输出，同时附有简要的文字说明。除了演示 **int** 和 **long** 的所有位运算符的效果之外，本示例还显示 **int** 和 **long** 的最小值、最大值、+1 和 -1 值，以便我们了解它们的形式。注意高位代表符号：0 表示正，1 表示负。上面显示了 **int** 部分的输出。数字的二进制表示称为有符号的两个补数。
|
||||
|
||||
|
||||
<!-- Ternary-if-else-Operator -->
|
||||
## 三元运算符
|
||||
|
||||
三元运算符，也称为条件运算符。这种运算符比较罕见，因为它有三个运算对象。但它确实属于运算符的一种，因为它最终也会生成一个值。这与本章后一节要讲述的普通 **if-else** 语句是不同的。下面是它的表达式格式：
|
||||
|
||||
**布尔表达式 ? 值1 : 值2**
|
||||
**布尔表达式 ? 值 1 : 值 2**
|
||||
|
||||
若表达式计算为 **true**，则返回结果 **值1** ；如果表达式的计算为 **false**，则返回结果 **值2**。
|
||||
若表达式计算为 **true**，则返回结果 **值 1** ；如果表达式的计算为 **false**，则返回结果 **值 2**。
|
||||
|
||||
当然，也可以换用普通的 **if-else** 语句（在后面介绍），但三元运算符更加简洁。作为三元运算符的创造者， C 自诩为一门简练的语言。三元运算符的引入多半就是为了高效编程，但假若我们打算频繁使用它的话，还是先多作一些思量： 它易于产生可读性差的代码。与 **if-else** 不同的是，三元运算符是有返回结果的。请看下面的代码示例：
|
||||
|
||||
|
||||
```java
|
||||
// operators/TernaryIfElse.java
|
||||
public class TernaryIfElse {
|
||||
@@ -887,7 +854,6 @@ static int standardIfElse(int i) {
|
||||
|
||||
可以看出，`ternary()` 中的代码更简短。然而，**standardIfElse()** 中的代码更易理解且不要求更多的录入。所以我们在挑选三元运算符时，请务必权衡一下利弊。
|
||||
|
||||
|
||||
<!-- String-Operator-+-and-+= -->
|
||||
## 字符串运算符
|
||||
|
||||
@@ -927,10 +893,8 @@ x, y, z (summed) = 3
|
||||
请注意主方法中的最后一个例子：我们经常会看到一个空字符串 `""` 跟着一个基本类型的数据。这样可以隐式地将其转换为字符串，以代替繁琐的显式调用方法（如这里可以使用 **Integer.toString()**）。
|
||||
|
||||
<!-- Common-Pitfalls-When-Using-Operators -->
|
||||
|
||||
## 常见陷阱
|
||||
|
||||
|
||||
使用运算符时很容易犯的一个错误是，在还没搞清楚表达式的计算方式时就试图忽略括号 `()`。在 Java 中也一样。 在 C++ 中你甚至可能犯这样极端的错误.代码示例：
|
||||
|
||||
```java
|
||||
@@ -945,7 +909,6 @@ while(x = y) {
|
||||
|
||||
在 C/C++ 里，类似的一个问题还有使用按位“与” `&` 和“或” `|` 运算，而非逻辑“与” `&&` 和“或” `||`。就象 `=` 和 `==` 一样，键入一个字符当然要比键入两个简单。在 Java 中，编译器同样可防止这一点，因为它不允许我们强行使用另一种并不符的类型。
|
||||
|
||||
|
||||
<!-- Casting-Operators -->
|
||||
## 类型转换
|
||||
|
||||
@@ -972,7 +935,7 @@ public class Casting {
|
||||
|
||||
当然，为了程序逻辑清晰或提醒自己留意，我们也可以显式地类型转换。在其他情况下，类型转换型只有在代码编译时才显出其重要性。在 C/C++ 中，类型转换有时会让人头痛。在 Java 里，类型转换则是一种比较安全的操作。但是，若将数据类型进行“向下转换”（**Narrowing Conversion**）的操作（将容量较大的数据类型转换成容量较小的类型），可能会发生信息丢失的危险。此时，编译器会强迫我们进行转型，好比在提醒我们：该操作可能危险，若你坚持让我这么做，那么对不起，请明确需要转换的类型。 对于“向上转换”（**Widening conversion**），则不必进行显式的类型转换，因为较大类型的数据肯定能容纳较小类型的数据，不会造成任何信息的丢失。
|
||||
|
||||
除了布尔类型的数据， Java 允许任何基本类型的数据转换为另一种基本类型的数据。此外，类是不能进行类型转换的。为了将一个类转换为另一个类型，需要使用特殊的方法（后面将会学习到如何在父子类之间进行向上/向下转型，例如，“橡树”可以转换为“树”，反之亦然。而对于“岩石”是无法转换为“树”的）。
|
||||
除了布尔类型的数据，Java 允许任何基本类型的数据转换为另一种基本类型的数据。此外，类是不能进行类型转换的。为了将一个类转换为另一个类型，需要使用特殊的方法（后面将会学习到如何在父子类之间进行向上/向下转型，例如，“橡树”可以转换为“树”，反之亦然。而对于“岩石”是无法转换为“树”的）。
|
||||
|
||||
<!-- Truncation and Rounding -->
|
||||
### 截断和舍入
|
||||
@@ -1037,20 +1000,16 @@ Math.round(fbelow): 0
|
||||
<!-- Promotion -->
|
||||
### 类型提升
|
||||
|
||||
|
||||
你会发现，如果我们对小于 **int** 的基本数据类型（即 **char**、**byte** 或 **short**）执行任何算术或按位操作，这些值会在执行操作之前类型提升为 **int**，并且结果值的类型为 **int**。若想重新使用较小的类型，必须使用强制转换（由于重新分配回一个较小的类型，结果可能会丢失精度）。通常，表达式中最大的数据类型是决定表达式结果的数据类型。**float** 型和 **double** 型相乘，结果是 **double** 型的；**int** 和 **long** 相加，结果是 **long** 型。
|
||||
|
||||
|
||||
<!-- Java-Has-No-sizeof -->
|
||||
## Java没有sizeof
|
||||
|
||||
|
||||
在 C/C++ 中，经常需要用到 `sizeof()` 方法来获取数据项被分配的字节大小。C/C++ 中使用 `sizeof()` 最有说服力的原因是为了移植性，不同数据在不同机器上可能有不同的大小，所以在进行大小敏感的运算时，程序员必须对这些类型有多大做到心中有数。例如，一台计算机可用 32 位来保存整数，而另一台只用 16 位保存。显然，在第一台机器中，程序可保存更大的值。所以，移植是令 C/C++ 程序员颇为头痛的一个问题。
|
||||
|
||||
Java 不需要 ` sizeof()` 方法来满足这种需求，因为所有类型的大小在不同平台上是相同的。我们不必考虑这个层次的移植问题 —— Java 本身就是一种“与平台无关”的语言。
|
||||
|
||||
<!-- A-Compendium-of-Operators -->
|
||||
|
||||
## 运算符总结
|
||||
|
||||
上述示例分别向我们展示了哪些基本类型能被用于特定的运算符。基本上，下面的代码示例是对上述所有示例的重复，只不过概括了所有的基本类型。这个文件能被正确地编译，因为我已经把编译不通过的那部分用注释 `//` 过滤了。代码示例：
|
||||
@@ -1491,7 +1450,7 @@ public class Overflow {
|
||||
|
||||
输出结果：
|
||||
|
||||
```java
|
||||
```text
|
||||
big = 2147483647
|
||||
bigger = -4
|
||||
```
|
||||
@@ -1500,7 +1459,6 @@ bigger = -4
|
||||
|
||||
对于 **char**，**byte** 或者 **short**，混合赋值并不需要类型转换。即使为它们执行转型操作，也会获得与直接算术运算相同的结果。另外，省略类型转换可以使代码显得更加简练。总之，除 **boolean** 以外，其他任何两种基本类型间都可进行类型转换。当我们进行向下转换类型时，需要注意结果的范围是否溢出，否则我们就很可能在不知不觉中丢失精度。
|
||||
|
||||
|
||||
<!-- Summary -->
|
||||
## 本章小结
|
||||
|
||||
@@ -1508,8 +1466,7 @@ bigger = -4
|
||||
|
||||
[^1]: 我在 *Pomona College* 大学读过两年本科，在那里 47 被称之为“魔法数字”（*magic number*），详见 [维基百科](https://en.wikipedia.org/wiki/47_(number)) 。
|
||||
|
||||
[^2]: *John Kirkham* 说过：“自 1960 年我开始在 IBM 1620 上开始编程起，至 1970 年之间，FORTRAN 一直都是一种全大写的编程语言。这可能是因为许多早期的输入设备都是旧的电传打字机，使用了5 位波特码，没有小写字母的功能。指数符号中的 e 也总是大写的，并且从未与自然对数底数 e 混淆，自然对数底数 e 总是小写的。 e 简单地代表指数，通常 10 是基数。那时，八进制也被程序员广泛使用。虽然我从未见过它的用法，但如果我看到一个指数符号的八进制数，我会认为它是以 8 为基数的。我记得第一次看到指数使用小写字母 e 是在 20 世纪 70 年代末，我也发现它令人困惑。这个问题出现的时候，小写字母悄悄进入了 Fortran。如果你真的想使用自然对数底，我们实际上有一些函数要使用，但是它们都是大写的。”
|
||||
|
||||
[^2]: *John Kirkham* 说过：“自 1960 年我开始在 IBM 1620 上开始编程起，至 1970 年之间，FORTRAN 一直都是一种全大写的编程语言。这可能是因为许多早期的输入设备都是旧的电传打字机，使用了 5 位波特码，没有小写字母的功能。指数符号中的 e 也总是大写的，并且从未与自然对数底数 e 混淆，自然对数底数 e 总是小写的。 e 简单地代表指数，通常 10 是基数。那时，八进制也被程序员广泛使用。虽然我从未见过它的用法，但如果我看到一个指数符号的八进制数，我会认为它是以 8 为基数的。我记得第一次看到指数使用小写字母 e 是在 20 世纪 70 年代末，我也发现它令人困惑。这个问题出现的时候，小写字母悄悄进入了 Fortran。如果你真的想使用自然对数底，我们实际上有一些函数要使用，但是它们都是大写的。”
|
||||
|
||||
<!-- 分页 -->
|
||||
<div style="page-break-after: always;"></div>
|
||||
<div style="page-break-after: always;"></div>
|
||||
@@ -1112,14 +1112,295 @@ Mouse=2}
|
||||
<!-- Registered Factories -->
|
||||
## 注册工厂
|
||||
|
||||
从 `Pet` 层次结构生成对象的问题是，每当向层次结构中添加一种新类型的 `Pet` 时，必须记住将其添加到 `LiteralPetCreator.java` 中的条目中。在一个定期添加更多类的系统中，这可能会成为问题。
|
||||
|
||||
你可能会考虑向每个子类添加静态初始值设定项，因此初始值设定项会将其类添加到某个列表中。不幸的是，静态初始值设定项仅在首次加载类时调用，因此存在鸡和蛋的问题：生成器的列表中没有类，因此它无法创建该类的对象，因此类不会被加载并放入列表中。
|
||||
|
||||
基本上，你必须自己手工创建列表（除非你编写了一个工具来搜索和分析源代码，然后创建和编译列表）。所以你能做的最好的事情就是把列表集中放在一个明显的地方。层次结构的基类可能是最好的地方。
|
||||
|
||||
我们在这里所做的另一个更改是使用*工厂方法*设计模式将对象的创建推迟到类本身。工厂方法可以以多态方式调用，并为你创建适当类型的对象。事实证明，`java.util.function.Supplier` 用 `T get()` 描述了原型工厂方法。协变返回类型允许 `get()` 为 `Supplier` 的每个子类实现返回不同的类型。
|
||||
|
||||
在本例中，基类 `Part` 包含一个工厂对象的静态列表，列表成员类型为 `Supplier<Part>`。对于应该由 `get()` 方法生成的类型的工厂，通过将它们添加到 `prototypes` 列表向基类“注册”。奇怪的是，这些工厂本身就是对象的实例。此列表中的每个对象都是用于创建其他对象的*原型*：
|
||||
|
||||
```java
|
||||
// typeinfo/RegisteredFactories.java
|
||||
// 注册工厂到基础类
|
||||
import java.util.*;
|
||||
import java.util.function.*;
|
||||
import java.util.stream.*;
|
||||
|
||||
class Part implements Supplier<Part> {
|
||||
@Override
|
||||
public String toString() {
|
||||
return getClass().getSimpleName();
|
||||
}
|
||||
|
||||
static List<Supplier<? extends Part>> prototypes =
|
||||
Arrays.asList(
|
||||
new FuelFilter(),
|
||||
new AirFilter(),
|
||||
new CabinAirFilter(),
|
||||
new OilFilter(),
|
||||
new FanBelt(),
|
||||
new PowerSteeringBelt(),
|
||||
new GeneratorBelt()
|
||||
);
|
||||
|
||||
private static Random rand = new Random(47);
|
||||
public Part get() {
|
||||
int n = rand.nextInt(prototypes.size());
|
||||
return prototypes.get(n).get();
|
||||
}
|
||||
}
|
||||
|
||||
class Filter extends Part {}
|
||||
|
||||
class FuelFilter extends Filter {
|
||||
@Override
|
||||
public FuelFilter get() { return new FuelFilter(); }
|
||||
}
|
||||
|
||||
class AirFilter extends Filter {
|
||||
@Override
|
||||
public AirFilter get() { return new AirFilter(); }
|
||||
}
|
||||
|
||||
class CabinAirFilter extends Filter {
|
||||
@Override
|
||||
public CabinAirFilter get() {
|
||||
return new CabinAirFilter();
|
||||
}
|
||||
}
|
||||
|
||||
class OilFilter extends Filter {
|
||||
@Override
|
||||
public OilFilter get() { return new OilFilter(); }
|
||||
}
|
||||
|
||||
class Belt extends Part {}
|
||||
|
||||
class FanBelt extends Belt {
|
||||
@Override
|
||||
public FanBelt get() { return new FanBelt(); }
|
||||
}
|
||||
|
||||
class GeneratorBelt extends Belt {
|
||||
@Override
|
||||
public GeneratorBelt get() {
|
||||
return new GeneratorBelt();
|
||||
}
|
||||
}
|
||||
|
||||
class PowerSteeringBelt extends Belt {
|
||||
@Override
|
||||
public PowerSteeringBelt get() {
|
||||
return new PowerSteeringBelt();
|
||||
}
|
||||
}
|
||||
|
||||
public class RegisteredFactories {
|
||||
public static void main(String[] args) {
|
||||
Stream.generate(new Part())
|
||||
.limit(10)
|
||||
.forEach(System.out::println);
|
||||
}
|
||||
}
|
||||
|
||||
/* 输出:
|
||||
GeneratorBelt
|
||||
CabinAirFilter
|
||||
GeneratorBelt
|
||||
AirFilter
|
||||
PowerSteeringBelt
|
||||
CabinAirFilter
|
||||
FuelFilter
|
||||
PowerSteeringBelt
|
||||
PowerSteeringBelt
|
||||
FuelFilter
|
||||
*/
|
||||
```
|
||||
|
||||
并非层次结构中的所有类都应实例化；这里的 `Filter` 和 `Belt` 只是分类器，这样你就不会创建任何一个类的实例，而是只创建它们的子类（请注意，如果尝试这样做，你将获得 `Part` 基类的行为）。
|
||||
|
||||
因为 `Part implements Supplier<Part>`，`Part` 通过其 `get()` 方法供应其他 `Part`。如果为基类 `Part` 调用 `get()`（或者如果 `generate()` 调用 `get()`），它将创建随机特定的 `Part` 子类型，每个子类型最终都从 `Part` 继承，并重写相应的 `get()` 以生成它们中的一个。
|
||||
|
||||
<!-- Instanceof vs. Class Equivalence -->
|
||||
## 类的等价比较
|
||||
|
||||
When you are querying for type information, there's an important difference between either form of `instanceof` (that is, `instanceof` or `isInstance()`, which produce equivalent results) and the direct comparison of the `Class` objects. Here's an example that demonstrates the difference:
|
||||
|
||||
```java
|
||||
// typeinfo/FamilyVsExactType.java
|
||||
// instanceof 与 class 的差别
|
||||
// {java typeinfo.FamilyVsExactType}
|
||||
package typeinfo;
|
||||
|
||||
class Base {}
|
||||
class Derived extends Base {}
|
||||
|
||||
public class FamilyVsExactType {
|
||||
static void test(Object x) {
|
||||
System.out.println(
|
||||
"Testing x of type " + x.getClass());
|
||||
System.out.println(
|
||||
"x instanceof Base " + (x instanceof Base));
|
||||
System.out.println(
|
||||
"x instanceof Derived " + (x instanceof Derived));
|
||||
System.out.println(
|
||||
"Base.isInstance(x) " + Base.class.isInstance(x));
|
||||
System.out.println(
|
||||
"Derived.isInstance(x) " +
|
||||
Derived.class.isInstance(x));
|
||||
System.out.println(
|
||||
"x.getClass() == Base.class " +
|
||||
(x.getClass() == Base.class));
|
||||
System.out.println(
|
||||
"x.getClass() == Derived.class " +
|
||||
(x.getClass() == Derived.class));
|
||||
System.out.println(
|
||||
"x.getClass().equals(Base.class)) "+
|
||||
(x.getClass().equals(Base.class)));
|
||||
System.out.println(
|
||||
"x.getClass().equals(Derived.class)) " +
|
||||
(x.getClass().equals(Derived.class)));
|
||||
}
|
||||
public static void main(String[] args) {
|
||||
test(new Base());
|
||||
test(new Derived());
|
||||
}
|
||||
}
|
||||
/* 输出:
|
||||
Testing x of type class typeinfo.Base
|
||||
x instanceof Base true
|
||||
x instanceof Derived false
|
||||
Base.isInstance(x) true
|
||||
Derived.isInstance(x) false
|
||||
x.getClass() == Base.class true
|
||||
x.getClass() == Derived.class false
|
||||
x.getClass().equals(Base.class)) true
|
||||
x.getClass().equals(Derived.class)) false
|
||||
Testing x of type class typeinfo.Derived
|
||||
x instanceof Base true
|
||||
x instanceof Derived true
|
||||
Base.isInstance(x) true
|
||||
Derived.isInstance(x) true
|
||||
x.getClass() == Base.class false
|
||||
x.getClass() == Derived.class true
|
||||
x.getClass().equals(Base.class)) false
|
||||
x.getClass().equals(Derived.class)) true
|
||||
*/
|
||||
```
|
||||
|
||||
`test()` 方法使用两种形式的 `instanceof` 对其参数执行类型检查。然后，它获取 `Class` 引用，并使用 `==` 和 `equals()` 测试 `Class` 对象的相等性。令人放心的是，`instanceof` 和 `isInstance()` 产生的结果与 `equals()` 和 `==` 完全相同。但测试本身得出了不同的结论。与类型的概念一致，`instanceof` 说的是“你是这个类，还是从这个类派生的类？”。另一方面，如果使用 `==` 比较实际的 `Class` 对象，则与继承无关 —— 它要么是确切的类型，要么不是。
|
||||
|
||||
<!-- Reflection: Runtime Class Information -->
|
||||
## 反射：运行时类信息
|
||||
|
||||
## 内省：反射运行时类信息
|
||||
如果你不知道对象的确切类型，RTTI 会告诉你。但是，有一个限制：必须在编译时知道类型，才能使用 RTTI 检测它，并对信息做一些有用的事情。换句话说，编译器必须知道你使用的所有类。
|
||||
|
||||
起初，这看起来并没有那么大的限制，但是假设你被赋予了一个对不在程序空间中的对象的引用。实际上，该对象的类在编译时甚至对程序都不可用。也许你从磁盘文件或网络连接中获得了大量的字节，并被告知这些字节代表一个类。由于这个类在编译器为你的程序生成代码后很长时间才会出现，你如何使用这样的类？
|
||||
|
||||
在传统编程环境中，这是一个牵强的场景。但是，当我们进入一个更大的编程世界时，会有一些重要的情况发生。第一个是基于组件的编程，你可以在应用程序构建器*集成开发环境*中使用*快速应用程序开发*（RAD）构建项目。这是一种通过将表示组件的图标移动到窗体上来创建程序的可视化方法。然后，通过在程序时设置这些组件的一些值来配置这些组件。这种设计时配置要求任何组件都是可实例化的，它公开自己的部分，并且允许读取和修改其属性。此外，处理*图形用户界面*（GUI）事件的组件必须公开有关适当方法的信息，以便 IDE 可以帮助程序员覆盖这些事件处理方法。反射提供了检测可用方法并生成方法名称的机制。
|
||||
|
||||
在运行时发现类信息的另一个令人信服的动机是提供跨网络在远程平台上创建和执行对象的能力。这称为*远程方法调用*（RMI），它使 Java 程序的对象分布在许多机器上。这种分布有多种原因。如果你想加速一个计算密集型的任务，你可以把它分解成小块放到空闲的机器上。或者你可以将处理特定类型任务的代码（例如，多层次客户机/服务器体系结构中的“业务规则”）放在特定的机器上，这样机器就成为描述这些操作的公共存储库，并且可以很容易地更改它以影响系统中的每个人。分布式计算还支持专门的硬件，这些硬件可能擅长于某个特定的任务——例如矩阵转换——但对于通用编程来说不合适或过于昂贵。
|
||||
|
||||
类 `Class` 支持*反射*的概念，以及 `java.lang.reflect` 库，其中包含类 `Field`、`Method` 和 `Constructor`（每一个都实现了 `Member` 接口）。这些类型的对象由 JVM 在运行时创建，以表示未知类中的对应成员。然后，可以使用 `Constructor` 创建新对象，`get()` 和 `set()` 方法读取和修改与 `Field` 对象关联的字段，`invoke()` 方法调用与 `Method` 对象关联的方法。此外，还可以调用便利方法 `getFields()`、`getMethods()`、`getConstructors()` 等，以返回表示字段、方法和构造函数的对象数组。（你可以通过在 JDK 文档中查找类 `Class` 来了解更多信息。）因此，匿名对象的类信息可以在运行时完全确定，编译时不需要知道任何信息。
|
||||
|
||||
重要的是要意识到反射没有什么魔力。当你使用反射与未知类型的对象交互时，JVM 将查看该对象，并看到它属于特定的类（就像普通的 RTTI）。在对其执行任何操作之前，必须加载 `Class` 对象。因此，该特定类型的 `.class` 文件必须在本地计算机上或通过网络对 JVM 仍然可用。因此，RTTI 和反射的真正区别在于，使用 RTTI 时，编译器在编译时会打开并检查 `.class` 文件。换句话说，你可以用“正常”的方式调用一个对象的所有方法。通过反射，`.class` 文件在编译时不可用；它由运行时环境打开并检查。
|
||||
|
||||
### 类方法提取器
|
||||
|
||||
通常，你不会直接使用反射工具，但它们可以帮助你创建更多的动态代码。反射是用来支持其他 Java 特性的，例如对象序列化（参见[附录：对象序列化](#ch040.xhtml#appendix-object-serialization)）。但是，有时动态提取有关类的信息很有用。
|
||||
|
||||
考虑一个类方法提取器。查看类定义的源代码或 JDK 文档，只显示*在该类定义中*定义或重写的方法。但是，可能还有几十个来自基类的可用方法。找到它们既单调又费时。
|
||||
|
||||
```java
|
||||
// typeinfo/ShowMethods.java
|
||||
// 使用反射展示一个类的所有方法，甚至包括定义在基类中方法
|
||||
// {java ShowMethods ShowMethods}
|
||||
import java.lang.reflect.*;
|
||||
import java.util.regex.*;
|
||||
|
||||
public class ShowMethods {
|
||||
private static String usage =
|
||||
"usage:\n" +
|
||||
"ShowMethods qualified.class.name\n" +
|
||||
"To show all methods in class or:\n" +
|
||||
"ShowMethods qualified.class.name word\n" +
|
||||
"To search for methods involving 'word'";
|
||||
|
||||
private static Pattern p = Pattern.compile("\\w+\\.");
|
||||
public static void main(String[] args) {
|
||||
|
||||
if(args.length < 1) {
|
||||
System.out.println(usage);
|
||||
System.exit(0);
|
||||
}
|
||||
int lines = 0;
|
||||
try {
|
||||
Class<?> c = Class.forName(args[0]);
|
||||
Method[] methods = c.getMethods();
|
||||
Constructor[] ctors = c.getConstructors();
|
||||
if(args.length == 1) {
|
||||
for(Method method : methods)
|
||||
System.out.println(
|
||||
p.matcher(
|
||||
method.toString()).replaceAll(""));
|
||||
for(Constructor ctor : ctors)
|
||||
System.out.println(
|
||||
p.matcher(ctor.toString()).replaceAll(""));
|
||||
lines = methods.length + ctors.length;
|
||||
} else {
|
||||
for(Method method : methods)
|
||||
if(method.toString().contains(args[1])) {
|
||||
System.out.println(p.matcher(
|
||||
method.toString()).replaceAll(""));
|
||||
lines++;
|
||||
}
|
||||
for(Constructor ctor : ctors)
|
||||
if(ctor.toString().contains(args[1])) {
|
||||
System.out.println(p.matcher(
|
||||
ctor.toString()).replaceAll(""));
|
||||
lines++;
|
||||
}
|
||||
}
|
||||
} catch(ClassNotFoundException e) {
|
||||
System.out.println("No such class: " + e);
|
||||
}
|
||||
}
|
||||
}
|
||||
/* 输出:
|
||||
public static void main(String[])
|
||||
public final void wait() throws InterruptedException
|
||||
public final void wait(long,int) throws
|
||||
InterruptedException
|
||||
public final native void wait(long) throws
|
||||
InterruptedException
|
||||
public boolean equals(Object)
|
||||
public String toString()
|
||||
public native int hashCode()
|
||||
public final native Class getClass()
|
||||
public final native void notify()
|
||||
public final native void notifyAll()
|
||||
public ShowMethods()
|
||||
*/
|
||||
```
|
||||
|
||||
`Class` 方法 `getmethods()` 和'getconstructors()` 分别返回 `Method` 数组和 `Constructor` 数组。这些类中的每一个都有进一步的方法来解析它们所表示的方法的名称、参数和返回值。但你也可以像这里所做的那样，使用 `toString()`，生成带有整个方法签名的 `String`。代码的其余部分提取命令行信息，确定特定签名是否与目标 `String`（使用 `indexOf()`）匹配，并使用正则表达式（在 [Strings](#ch021.xhtml#strings) 一章中介绍）删除名称限定符。
|
||||
|
||||
编译时无法知道 `Class.forName()` 生成的结果，因此所有方法签名信息都是在运行时提取的。如果你研究 JDK 反射文档，你将看到有足够的支持来实际设置和对编译时完全未知的对象进行方法调用（本书后面有这样的例子）。虽然最初你可能认为你永远都不需要这样做，但是反射的全部价值可能会令人惊讶。
|
||||
|
||||
上面的输出来自命令行：
|
||||
|
||||
```java
|
||||
java ShowMethods ShowMethods
|
||||
```
|
||||
|
||||
输出包含一个 `public` 无参数构造函数，即使未定义构造函数。你看到的构造函数是由编译器自动合成的。如果将 `ShowMethods` 设置为非 `public` 类（即只有包级访问权），则合成的无参数构造函数将不再显示在输出中。自动为合成的无参数构造函数授予与类相同的访问权。
|
||||
|
||||
尝试运行 `java ShowMethods java.lang.String`，并附加一个 `char`、`int`、`String` 等参数。
|
||||
|
||||
编程时，当你不记得某个类是否有特定的方法，并且不想在 JDK 文档中搜索索引或类层次结构时，或者如果你不知道该类是否可以对 `Color` 对象执行任何操作时，该工具能节省不少时间。
|
||||
|
||||
<!-- Dynamic Proxies -->
|
||||
## 动态代理
|
||||
|
||||
Reference in New Issue
Block a user