免费注册 登录
»专业资料»IT/计算机»计算机软件及应用»Thinking in Java (Java 编程思想).pdf
收起/展开

Thinking in Java (Java 编程思想)

文档类型:pdf 上传时间:2018-06-07 文档页数:887页 文档大小:4.32 M 文档浏览:19959次 文档下载:4次 所需积分:0 学币 文档评分:3.0星

Thinking in Java (Java 编程思想)内容摘要: 目錄Introduction1.1写在前面的话1.2引言1.3第1章 对象入门1.41.1 抽象的进步1.4.11.2 对象的接口1.4.21.3 实现方案的隐藏1.4.31.4 方案的重复使用1.4.41.5 继承:重新使用接口1.4.51.6 多形对象的互换使用1.4.61.7 对象的创建和存在时间1.4.71.8 违例控制:解决错误1.4.81.9 多线程1.4.91.10 永久性1.4.101.11 Java和因特网1.4.111.12 分析和设计1.4.121.13 Java还是C++1.4.13第2章 一切都是对象1.52.1 用句柄操纵对象1.5.12.2 所有对象都必须创建1.5.22.3 绝对不要清除对象1.5.32.4 新建数据类型:类1.5.42.5 方法、自变量和返回值1.5.52.6 构建Java程序1.5.62.7 我们的第一个Java程序1.5.72.8 注释和嵌入文档1.5.82.9 编码样式1.5.92.10 总结1.5.102.11 练习1.5.11第3章 控制程序流程1.613.1 使用Java运算符1.6.13.2 执行控制1.6.23.3 总结1.6.33.4 练习1.6.4第4章 初始化和清除1.74.1 用构建器自动初始化1.7.14.2 方法过载1.7.24.3 清除:收尾和垃圾收集1.7.34.4 成员初始化1.7.44.5 数组初始化1.7.54.6 总结1.7.64.7 练习1.7.7第5章 隐藏实施过程1.85.1 包:库单元1.8.15.2 Java访问指示符1.8.25.3 接口与实现1.8.35.4 类访问1.8.45.5 总结1.8.55.6 练习1.8.6第6章 类再生1.96.1 合成的语法1.9.16.2 继承的语法1.9.26.3 合成与继承的结合1.9.36.4 到底选择合成还是继承1.9.46.5 protected1.9.56.6 累积开发1.9.66.7 上溯造型1.9.76.8 final关键字1.9.86.9 初始化和类装载1.9.96.10 总结1.9.106.11 练习1.9.11第7章 多形性1.107.1 上溯造型1.10.17.2 深入理解1.10.227.3 覆盖与过载1.10.37.4 抽象类和方法1.10.47.5 接口1.10.57.6 内部类1.10.67.7 构建器和多形性1.10.77.8 通过继承进行设计1.10.87.9 总结1.10.97.10 练习1.10.10第8章 对象的容纳1.118.1 数组1.11.18.2 集合1.11.28.3 枚举器(反复器)1.11.38.4 集合的类型1.11.48.5 排序1.11.58.6 通用集合库1.11.68.7 新集合1.11.78.8 总结1.11.88.9 练习1.11.9第9章 违例差错控制1.129.1 基本违例1.12.19.2 违例的捕获1.12.29.3 标准Java违例1.12.39.4 创建自己的违例1.12.49.5 违例的限制1.12.59.6 用finally清除1.12.69.7 构建器1.12.79.8 违例匹配1.12.89.9 总结1.12.99.10 练习1.12.10第10章 Java IO系统1.1310.1 输入和输出1.13.110.2 增添属性和有用的接口1.13.210.3 本身的缺陷:RandomAccessFile1.13.3310.4 File类1.13.410.5 IO流的典型应用1.13.510.6 StreamTokenizer1.13.610.7 Java 1.1的IO流1.13.710.8 压缩1.13.810.9 对象序列化1.13.910.10 总结1.13.1010.11 练习1.13.11第11章 运行期类型鉴定1.1411.1 对RTTI的需要1.14.111.2 RTTI语法1.14.211.3 反射:运行期类信息1.14.311.4 总结1.14.411.5 练习1.14.5第12章 传递和返回对象1.1512.1 传递句柄1.15.112.2 制作本地副本1.15.212.3 克隆的控制1.15.312.4 只读类1.15.412.5 总结1.15.512.6 练习1.15.6第13章 创建窗口和程序片1.16第14章 多线程1.1714.1 反应灵敏的用户界面1.17.114.2 共享有限的资源1.17.214.3 堵塞1.17.314.4 优先级1.17.414.5 回顾runnable1.17.514.6 总结1.17.614.7 练习1.17.7第15章 网络编程1.1815.1 机器的标识1.18.115.2 套接字1.18.215.3 服务多个客户1.18.3415.4 数据报1.18.415.5 一个Web应用1.18.515.6 Java与CGI的沟通1.18.615.7 用JDBC连接数据库1.18.715.8 远程方法1.18.815.9 总结1.18.915.10 练习1.18.10第16章 设计范式1.1916.1 范式的概念1.19.116.2 观察器范式1.19.216.3 模拟垃圾回收站1.19.316.4 改进设计1.19.416.5 抽象的应用1.19.516.6 多重派遣1.19.616.7 访问器范式1.19.716.8 RTTI真的有害吗1.19.816.9 总结1.19.916.10 练习1.19.10第17章 项目1.2017.1 文字处理1.20.117.2 方法查找工具1.20.217.3 复杂性理论1.20.317.4 总结1.20.417.5 练习1.20.5附录A 使用非JAVA代码1.21附录B 对比C++和Java1.22附录C Java编程规则1.23附录D 性能1.24附录E 关于垃圾收集的一些话1.25附录F 推荐读物1.265IntroductionThinking in Java (Java 编程思想)本书来自网络,http://woquanke.com 整理成电子书,支持PDF,ePub,Mobi格式,方便大家下载阅读。阅读地址:https://woquanke.com/books/java下载地址:https://www.gitbook.com/book/quanke/think-in-java/github地址:https://github.com/quanke/think-in-java编辑:http://woquanke.com第13章没有编辑,觉得没有意义,Java的GUI先在应用少,有时间在编辑好。。。编辑整理辛苦,还望大神们点一下star ,抚平我虚荣的心更多请关注我的微信公众号:Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:106写在前面的话写在前面的话我的兄弟Todd目前正在进行从硬件到编程领域的工作转变。我曾提醒他下一次大革命的重点将是遗传工程。 我们的微生物技术将能制造食品、燃油和塑料;它们都是清洁的,不会造成污染,而且能使人类进一步透视物理世界的奥秘。我认为相比之下电脑的进步会显得微不足道。但随后,我又意识到自己正在犯一些科幻作家常犯的错误:在技术中迷失了(这种事情在科幻小说里常有发生)!如果是一名有经验的作家,就知道绝对不能就事论事,必须以人为中心。遗传对我们的生命有非常大的影响,但不能十分确定它能抹淡计算机革命——或至少信息革命——的影响。信息涉及人相互间的沟通:的确,汽车和轮子的发明都非常重要,但它们最终亦如此而已。真正重要的还是我们与世界的关系,而其中最关键的就是通信。这本书或许能说明一些问题。许多人认为我有点儿大胆或者稍微有些狂妄,居然把所有家当都摆到了Web上。“这样做还有谁来买它呢?”他们问。假如我是一个十分守旧的人,那么绝对不这样干。但我确实不想再沿原来的老路再写一本计算机参考书了。我不知道最终会发生什么事情,但的确认为这是我对一本书作出的最明智的一个决定。至少有一件事是可以肯定的,人们开始向我发送纠错反馈。这是一个令人震惊的体验,因为读者会看到书中的每一个角落,并揪出那些藏匿得很深的技术及语法错误。这样一来,和其他以传统方式发行的书不同,我就能及时改正已知的所有类别的错误,而不是让它们最终印成铅字,堂而皇之地出现在各位的面前。俗话说,“当局者迷,旁观者清”。人们对书中的错误是非常敏感的,往往毫不客气地指出:“我想这样说是错误的,我的看法是……”。在我仔细研究后,往往发现自己确实有不当之处,而这是当初写作时根本没有意识到的(检查多少遍也不行)。我意识到这是群体力量的一个可喜的反映,它使这本书显得的确与众不同。但我随之又听到了另一个声音:“好吧,你在那儿放的电子版的确很有创意,但我想要的是从真正的出版社那里印刷的一个版本!”事实上,我作出了许多努力,让它用普通打印机机就能得到很好的阅读效果,但仍然不象真正印刷的书那样正规。许多人不想在屏幕上看完整本书,也不喜欢拿着一叠纸阅读。无论打印格式有多么好,这些人喜欢是仍然是真正的“书”(激光打印机的墨盒也太贵了一点)。现在看来,计算机的革命仍未使出版界完全走出传统的模式。但是,有一个学生向我推荐了未来出版的一种模式:书籍将首先在互联网上出版,然后只有在绝对必要的前提下,才会印刷到纸张上。目前,为数众多的书籍销售都不十分理想,许多出版社都在亏本。但如采用这种方式出版,就显得灵活得多,也更容易保证赢利。这本书也从另一个角度也给了我深刻的启迪。我刚开始的时候以为Java“只是另一种程序设计语言”。这个想法在许多情况下都是成立的。但随着时间的推移,我对它的学习也愈加深入,开始意识到它的基本宗旨与我见过的其他所有语言都有所区别。7写在前面的话程序设计与对复杂性的操控有很大的关系:对一个准备解决的问题,它的复杂程度取决用于解决它的机器的复杂程度。正是由于这一复杂性的存在,我们的程序设计项目屡屡失败。对于我以前接触过的所有编程语言,它们都没能跳过这一框框,由此决定了它们的主要设计目标就是克服程序开发与维护中的复杂性。当然,许多语言在设计时就已考虑到了复杂性的问题。但从另一角度看,实际设计时肯定会有另一些问题浮现出来,需把它们考虑到这个复杂性的问题里。不可避免地,其他那些问题最后会变成最让程序员头痛的。例如,C++必须同C保持向后兼容(使C程序员能尽快地适应新环境),同时又要保证编程的效率。C++在这两个方面都设计得很好,为其赢得了不少的声誉。但它们同时也暴露出了额外的复杂性,阻碍了某些项目的成功实现(当然,你可以责备程序员和管理层,但假如一种语言能通过捕获你的错误而提供帮助,它为什么不那样做呢?)。作为另一个例子,Visual Basic(VB)同当初的BASIC有关的紧密的联系。而BASIC并没有打算设计成一种能全面解决问题的语言,所以堆加到VB身上的所有扩展都造成了令人头痛和难于管理和维护的语法。另一方面,C++、VB和其他如Smalltalk之类的语言均在复杂性的问题上下了一番功夫。由此得到的结果便是,它们在解决特定类型的问题时是非常成功的。 在理解到Java最终的目标是减轻程序员的负担时,我才真正感受到了震憾,尽管它的潜台词好象是说:“除了缩短时间和减小产生健壮代码的难度以外,我们不关心其他任何事情。”在目前这个初级阶段,达到那个目标的后果便是代码不能特别快地运行(尽管有许多保证都说Java终究有一天会运行得多么快),但它确实将开发时间缩短到令人惊讶的地步——几乎只有创建一个等效C++程序一半甚至更短的时间。这段节省下来的时间可以产生更大的效益,但Java并不仅止于此。它甚至更上一层楼,将重要性越来越明显的一切复杂任务都封装在内,比如网络程序和多线程处理等等。Java的各种语言特性和库在任何时候都能使那些任务轻而易举完成。而且最后,它解决了一些真正有些难度的复杂问题:跨平台程序、动态代码改换以及安全保护等等。换在从前,其中任何每一个都能使你头大如斗。所以不管我们见到了什么性能问题,Java的保证仍然是非常有效的:它使程序员显著提高了程序设计的效率!在我看来,编程效率提升后影响最大的就是Web。网络程序设计以前非常困难,而Java使这个问题迎刃而解(而且Java也在不断地进步,使解决这类问题变得越来越容易)。网络程序的设计要求我们相互间更有效率地沟通,而且至少要比电话通信来得便宜(仅仅电子函件就为许多公司带来了好处)。随着我们网上通信越来越频繁,令人震惊的事情会慢慢发生,而且它们令人吃惊的程度绝不亚于当初工业革命给人带来的震憾。在各个方面:创建程序;按计划编制程序;构造用户界面,使程序能与用户沟通;在不同类型的机器上运行程序;以及方便地编写程序,使其能通过因特网通信——Java提高了人与人之间的“通信带宽”。而且我认为通信革命的结果可能并不单单是数量庞大的比特到处传来传去那么简单。我们认为认清真正的革命发生在哪里,因为人和人之间的交流变得更方便了——个体与个体之间,个体与组之间,组与组之间,甚至在星球之间。有人预言下一次大革命的发生就是由于足够多的人和足够多的相互连接造成的,而这种革命是以整个世界为基础发生的。Java可能是、也可能不是促成那次革命的直接因素,但我在这里至少感觉自己在做一些有意义的工作——尝试教会大家一种重要的语言!Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:108写在前面的话9引言引言同人类任何语言一样,Java为我们提供了一种表达思想的方式。如操作得当,同其他方式相比,随着问题变得愈大和愈复杂,这种表达方式的方便性和灵活性会显露无遗。不可将Java简单想象成一系列特性的集合;如孤立地看,有些特性是没有任何意义的。只有在考虑“设计”、而非考虑简单的编码时,才可真正体会到Java的强大。为了按这种方式理解Java,首先必须掌握它与编程的一些基本概念。本书讨论了编程问题、它们为何会成为问题以及Java用以解决它们的方法。所以,我对每一章的解释都建立在如何用语言解决一种特定类型的问题基础上。按这种方式,我希望引导您一步一步地进入Java的世界,使其最终成为您最自然的一种语言。贯穿本书,我试图在您的大脑里建立一个模型——或者说一个“知识结构”。这样可加深对语言的理解。若遇到难解之处,应学会把它填入这个模型的对应地方,然后自行演绎出答案。事实上,学习任何语言时,脑海里有一个现成的知识结构往往会起到事半功倍的效果。1. 前提本书假定读者对编程多少有些熟悉。应已知道程序是一系列语句的集合,知道子程序/函数/宏是什么,知道象“If”这样的控制语句,也知道象“while”这样的循环结构。注意这些东西在大量语言里都是类似的。假如您学过一种宏语言,或者用过Perl之类的工具,那么它们的基本概念并无什么区别。总之,只要能习惯基本的编程概念,就可顺利阅读本书。当然,C/C++程序员在阅读时能占到更多的便宜。但即使不熟悉C,一样不要把自己排除在外(尽管以后的学习要付出更大的努力)。我会讲述面向对象编程的概念,以及Java的基本控制机制,所以不用担心自己会打不好基础。况且,您需要学习的第一类知识就会涉及到基本的流程控制语句。尽管经常都会谈及C和C++语言的一些特性,但并没有打算使它们成为内部参考,而是想帮助所有程序员都能正确地看待那两种语言。毕竟,Java是从它们那里衍生出来的。我将试着尽可能地简化这些引用和参考,并合理地解释一名非C/C++程序员通常不太熟悉的内容。2. Java的学习在我第一本书《Using C++》面市的几乎同一时间(Osborne/McGraw-Hill于1989年出版),我开始教授那种语言。程序设计语言的教授已成为我的专业。自1989年以来,我便在世界各地见过许多昏昏欲睡、满脸茫然以及困惑不解的面容。开始在室内面向较少的一组人授课以后,我从作业中发现了一些特别的问题。即使那些上课面带会心的微笑或者频频点头的学生,对许多问题也存在认识上的混淆。在过去几年间的“软件开发会议”上,由我主持C++分组讨论会(现在变成了Java讨论会)。有的演讲人试图在很短的时间内向听众灌输过多的主10引言题。所以到最后,尽管听众的水平都还可以,而且提供的材料也很充足,但仍然损失了一部分听众。这可能是由于问得太多了,但由于我是那些采取传统授课方式的人之一,所以很想使每个人都能跟上讲课进度。有段时间,我编制了大量教学简报。经过不断的试验和修订(或称“反复”,这是在Java程序设计中非常有用的一项技术),最后成功地在一门课程中集成了从我的教学经验中总结出来的所有东西——我在很长一段时间里都在使用。其中由一系列离散的、易于消化的小步骤组成,而且每个小课程结束后都有一些适当的练习。我目前已在Java公开研讨会上公布了这一课程,大家可到http://www.BruceEckel.com了解详情(对研讨会的介绍也以CD-ROM的形式提供,具体信息可在同样的Web站点找到)。从每一次研讨会收到的反馈都帮助我修改及重新制订学习材料的重心,直到我最后认为它成为一个完善的教学载体为止。但本书并非仅仅是一本教科书——我尝试在其中装入尽可能多的信息,并按照主题进行了有序的分类。无论如何,这本书的主要宗旨是为那些独立学习的人士服务,他们正准备深入一门新的程序设计语言,而没有太大的可能参加此类专业研讨会。3. 目标就象我的前一本书《Thinking in C++》一样,这本书面向语言的教授进行了良好的结构与组织。特别地,我的目标是建立一套有序的机制,可帮助我在自己的研讨会上更好地进行语言教学。在我思考书中的一章时,实际上是在想如何教好一堂课。我的目标是得到一系列规模适中的教学模块,可以在合理的时间内教完。随后是一些精心挑选的练习,可以在课堂上当即完成。在这本书中,我想达到的目标总结如下:(1) 每一次都将教学内容向前推进一小步,便于读者在继续后面的学习前消化前面的内容。(2) 采用的示例尽可能简短。当然,这样做有时会妨碍我解决“现实世界”的问题。但我同时也发现对那些新手来说,如果他们能理解每一个细节,那么一般会产生更大的学习兴趣。而假如他们一开始就被要解决的问题的深度和广度所震惊,那么一般都不会收到很好的学习效果。另外在实际教学过程中,对能够摘录的代码数量是有严重限制的。另一方面,这样做无疑会有些人会批评我采用了“不真实的例子”,但只要能起到良好的效果,我宁愿接受这一指责。(3) 要揭示的特性按照我精心挑选的顺序依次出场,而且尽可能符合读者的思想历程。当然,我不可能永远都做到这一点;在那些情况下,会给出一段简要的声明,指出这个问题。(4) 只把我认为有助于理解语言的东西介绍给读者,而不是把我知道的一切东西都抖出来,这并非藏私。我认为信息的重要程度是存在一个合理的层次的。有些情况是95%的程序员都永远不必了解的。如强行学习,只会干扰他们的正常思维,从而加深语言在他们面前表现出来11引言的难度。以C语言为例,假如你能记住运算符优先次序表(我从来记不住),那么就可以写出更“聪明”的代码。但再深入想一层,那也会使代码的读者/维护者感到困扰。所以忘了那些次序吧,在拿不准的时候加上括号即可。(5) 每一节都有明确的学习重点,所以教学时间(以及练习的间隔时间)非常短。这样做不仅能保持读者思想的活跃,也能使问题更容易理解,对自己的学习产生更大的信心。(6) 提供一个坚实的基础,使读者能充分理解问题,以便更容易转向一些更加困难的课程和书籍。4. 联机文档由Sun微系统公司提供的Java语言和库(可免费下载)配套提供了电子版的用户帮助手册,可用Web浏览器阅读。此外,由其他厂商开发的几乎所有类似产品都有一套等价的文档系统。而目前出版的与Java有关的几乎所有书籍都重复了这份文档。所以你要么已经拥有了它,要么需要下载。所以除非特别必要,否则本书不会重复那份文档的内容。因为一般地说,用Web浏览器查找与类有关的资料比在书中查找方便得多(电子版的东西更新也快)。只有在需要对文档进行补充,以便你能理解一个特定的例子时,本书才会提供有关类的一些附加说明。5. 章节本书在设计时认真考虑了人们学习Java语言的方式。在我授课时,学生们的反映有效地帮助了我认识哪些部分是比较困难的,需特别加以留意。我也曾经一次讲述了太多的问题,但得到的教训是:假如包括了大量新特性,就需要对它们全部作出解释,而这特别容易加深学生们的混淆。因此,我进行了大量努力,使这本书一次尽可能地少涉及一些问题。所以,我在书中的目标是让每一章都讲述一种语言特性,或者只讲述少数几个相互关联的特性。这样一来,读者在转向下一主题时,就能更容易地消化前面学到的知识。下面列出对本书各章的一个简要说明,它们与我实际进行的课堂教学是对应的。(1) 第1章:对象入门这一章是对面向对象的程序设计(OOP)的一个综述,其中包括对“什么是对象”之类的基本问题的回答,并讲述了接口与实现、抽象与封装、消息与函数、继承与合成以及非常重要的多形性的概念。这一章会向大家提出一些对象创建的基本问题,比如构建器、对象存在于何处、创建好后把它们置于什么地方以及魔术般的垃圾收集器(能够清除不再需要的对象)。要介绍的另一些问题还包括通过违例实现的错误控制机制、反应灵敏的用户界面的多线程处理以及连网和因特网等等。大家也会从中了解到是什么使得Java如此特别,它为什么取得了这么大的成功,以及与面向对象的分析与设计有关的问题。(2) 第2章:一切都是对象12引言本章将大家带到可以着手写自己的第一个Java程序的地方,所以必须对一些基本概念作出解释,其中包括对象“句柄”的概念;怎样创建一个对象;对基本数据类型和数组的一个介绍;作用域以及垃圾收集器清除对象的方式;如何将Java中的所有东西都归为一种新数据类型(类),以及如何创建自己的类;函数、自变量以及返回值;名字的可见度以及使用来自其他库的组件;static关键字;注释和嵌入文档等等。(3) 第3章:控制程序流程本章开始介绍起源于C和C++,由Java继承的所有运算符。除此以外,还要学习运算符一些不易使人注意的问题,以及涉及造型、升迁以及优先次序的问题。随后要讲述的是基本的流程控制以及选择运算,这些是几乎所有程序设计语言都具有的特性:用if-else实现选择;用for和while实现循环;用break和continue以及Java的标签式break和contiune(它们被认为是Java中“不见的gogo”)退出循环;以及用switch实现另一种形式的选择。尽管这些与C和C++中见到的有一定的共通性,但多少存在一些区别。除此以外,所有示例都是完整的Java示例,能使大家很快地熟悉Java的外观。(4) 第4章:初始化和清除本章开始介绍构建器,它的作用是担保初始化的正确实现。对构建器的定义要涉及函数过载的概念(因为可能同时有几个构建器)。随后要讨论的是清除过程,它并非肯定如想象的那么简单。用完一个对象后,通常可以不必管它,垃圾收集器会自动介入,释放由它占据的内存。这里详细探讨了垃圾收集器以及它的一些特点。在这一章的最后,我们将更贴近地观察初始化过程:自动成员初始化、指定成员初始化、初始化的顺序、static(静态)初始化以及数组初始化等等。(5) 第5章:隐藏实现过程本章要探讨将代码封装到一起的方式,以及在库的其他部分隐藏时,为什么仍有一部分处于暴露状态。首先要讨论的是package和import关键字,它们的作用是进行文件级的封装(打包)操作,并允许我们构建由类构成的库(类库)。此时也会谈到目录路径和文件名的问题。本章剩下的部分将讨论public,private以及protected三个关键字、“友好”访问的概念以及各种场合下不同访问控制级的意义。(6) 第6章:类再生继承的概念是几乎所有OOP语言中都占有重要的地位。它是对现有类加以利用,并为其添加新功能的一种有效途径(同时可以修改它,这是第7章的主题)。通过继承来重复使用原有的代码时(再生),一般需要保持“基础类”不变,只是将这儿或那儿的东西串联起来,以达到预期的效果。然而,继承并不是在现有类基础上制造新类的唯一手段。通过“合成”,亦可将一个对象嵌入新类。在这一章中,大家将学习在Java中重复使用代码的这两种方法,以及具体如何运用。(7) 第7章:多形性13引言若由你自己来干,可能要花9个月的时间才能发现和理解多形性的问题,这一特性实际是OOP一个重要的基础。通过一些小的、简单的例子,读者可知道如何通过继承来创建一系列类型,并通过它们共有的基础类对那个系列中的对象进行操作。通过Java的多形性概念,同一系列中的所有对象都具有了共通性。这意味着我们编写的代码不必再依赖特定的类型信息。这使程序更易扩展,包容力也更强。由此,程序的构建和代码的维护可以变得更方便,付出的代价也会更低。此外,Java还通过“接口”提供了设置再生关系的第三种途径。这儿所谓的“接口”是对对象物理“接口”一种纯粹的抽象。一旦理解了多形性的概念,接口的含义就很容易解释了。本章也向大家介绍了Java 1.1的“内部类”。(8) 第8章:对象的容纳对一个非常简单的程序来说,它可能只拥有一个固定数量的对象,而且对象的“生存时间”或者“存在时间”是已知的。但是通常,我们的程序会在不定的时间创建新对象,只有在程序运行时才可了解到它们的详情。此外,除非进入运行期,否则无法知道所需对象的数量,甚至无法得知它们确切的类型。为解决这个常见的程序设计问题,我们需要拥有一种能力,可在任何时间、任何地点创建任何数量的对象。本章的宗旨便是探讨在使用对象的同时用来容纳它们的一些Java工具:从简单的数组到复杂的集合(数据结构),如Vector和Hashtable等。最后,我们还会深入讨论新型和改进过的Java 1.2集合库。(9) 第9章:违例差错控制Java最基本的设计宗旨之一便是组织错误的代码不会真的运行起来。编译器会尽可能捕获问题。但某些情况下,除非进入运行期,否则问题是不会被发现的。这些问题要么属于编程错误,要么则是一些自然的出错状况,它们只有在作为程序正常运行的一部分时才会成立。Java为此提供了“违例控制”机制,用于控制程序运行时产生的一切问题。这一章将解释try、catch、throw、throws以及finally等关键字在Java中的工作原理。并讲述什么时候应当“掷”出违例,以及在捕获到违例后该采取什么操作。此外,大家还会学习Java的一些标准违例,如何构建自己的违例,违例发生在构建器中怎么办,以及违例控制器如何定位等等。(10) 第10章:Java IO系统理论上,我们可将任何程序分割为三部分:输入、处理和输出。这意味着IO(输入/输出)是所有程序最为关键的部分。在这一章中,大家将学习Java为此提供的各种类,如何用它们读写文件、内存块以及控制台等。“老”IO和Java 1.1的“新”IO将得到着重强调。除此之外,本节还要探讨如何获取一个对象、对其进行“流式”加工(使其能置入磁盘或通过网络传送)以及重新构建它等等。这些操作在Java的1.1版中都可以自动完成。另外,我们也要讨论Java 1.1的压缩库,它将用在Java的归档文件格式中(JAR)。(11) 第11章:运行期类型鉴定若只有指向基础类的一个句柄,Java的运行期类型标鉴定(RTTI)使我们能获知一个对象的准确类型是什么。一般情况下,我们需要有意忽略一个对象的准确类型,让Java的动态绑定机制(多形性)为那一类型实现正确的行为。但在某些场合下,对于只有一个基础句柄的对14引言象,我们仍然特别有必要了解它的准确类型是什么。拥有这个资料后,通常可以更有效地执行一次特殊情况下的操作。本章将解释RTTI的用途、如何使用以及在适当的时候如何放弃它。此外,Java 1.1的“反射”特性也会在这里得到介绍。(12) 第12章:传递和返回对象由于我们在Java中同对象沟通的唯一途径是“句柄”,所以将对象传递到一个函数里以及从那个函数返回一个对象的概念就显得非常有趣了。本章将解释在函数中进出时,什么才是为了管理对象需要了解的。同时也会讲述String(字串)类的概念,它用一种不同的方式解决了同样的问题。(13) 第13章:创建窗口和程序片Java配套提供了“抽象Windows工具包”(AWT)。这实际是一系列类的集合,能以一种可移植的形式解决视窗操纵问题。这些窗口化程序既可以程序片的形式出现,亦可作为独立的应用程序使用。本章将向大家介绍AWT以及网上程序片的创建过程。我们也会探讨AWT的优缺点以及Java 1.1在GUI方面的一些改进。同时,重要的“Java Beans”技术也会在这里得到强调。Java Beans是创建“快速应用开发”(RAD)程序构造工具的重要基础。我们最后介绍的是Java 1.2的“Swing”库——它使Java的UI组件得到了显著的改善。(14) 第14章:多线程Java提供了一套内建的机制,可提供对多个并发子任务的支持,我们称其为“线程”。这线程均在单一的程序内运行。除非机器安装了多个处理器,否则这就是多个子任务的唯一运行方式。尽管还有别的许多重要用途,但在打算创建一个反应灵敏的用户界面时,多线程的运用显得尤为重要。举个例子来说,在采用了多线程技术后,尽管当时还有别的任务在执行,但用户仍然可以毫无阻碍地按下一个按钮,或者键入一些文字。本章将对Java的多线程处理机制进行探讨,并介绍相关的语法。(15) 第15章 网络编程开始编写网络应用时,就会发现所有Java特性和库仿佛早已串联到了一起。本章将探讨如何通过因特网通信,以及Java用以辅助此类编程的一些类。此外,这里也展示了如何创建一个Java程序片,令其同一个“通用网关接口”(CGI)程序通信;揭示了如何用C++编写CGI程序;也讲述了与Java 1.1的“Java数据库连接”(JDBC)和“远程方法调用”(RMI)有关的问题。(16) 第16章 设计范式本章将讨论非常重要、但同时也是非传统的“范式”程序设计概念。大家会学习设计进展过程的一个例子。首先是最初的方案,然后经历各种程序逻辑,将方案不断改革为更恰当的设计。通过整个过程的学习,大家可体会到使设计思想逐渐变得清晰起来的一种途径。(17) 第17章 项目15引言本章包括了一系列项目,它们要么以本书前面讲述的内容为基础,要么对以前各章进行了一番扩展。这些项目显然是书中最复杂的,它们有效演示了新技术和类库的应用。 有些主题似乎不太适合放到本书的核心位置,但我发现有必要在教学时讨论它们,这些主题都放入了本书的附录。(18) 附录A:使用非Java代码对一个完全能够移植的Java程序,它肯定存在一些严重的缺陷:速度太慢,而且不能访问与具体平台有关的服务。若事先知道程序要在什么平台上使用,就可考虑将一些操作变成“固有方法”,从而显著加快执行速度。这些“固有方法”实际是一些特殊的函数,以另一种程序设计语言写成(目前仅支持C/C++)。Java还可通过另一些途径提供对非Java代码的支持,其中包括CORBA。本附录将详细介绍这些特性,以便大家能创建一些简单的例子,同非Java代码打交道。(19) 附录B:对比C++和Java对一个C++程序员,他应该已经掌握了面向对象程序设计的基本概念,而且Java语法对他来说无疑是非常眼熟的。这一点是明显的,因为Java本身就是从C++衍生而来。但是,C++和Java之间的确存在一些显著的差异。这些差异意味着Java在C++基础上作出的重大改进。一旦理解了这些差异,就能理解为什么说Java是一种杰出的语言。这一附录便是为这个目的设立的,它讲述了使Java与C++明显有别的一些重要特性。(20) 附录C:Java编程规则本附录提供了大量建议,帮助大家进行低级程序设计和代码编写。(21) 附录D:性能通过这个附录的学习,大家可发现自己Java程序中存在的瓶颈,并可有效地改善执行速度。(22) 附录E:关于垃圾收集的一些话这个附录讲述了用于实现垃圾收集的操作和方法。(23) 附录F:推荐读物列出我感觉特别有用的一系列Java参考书。6. 练习为巩固对新知识的掌握,我发现简单的练习特别有用。所以读者在每一章结束时都能找到一系列练习。 大多数练习都很简单,在合理的时间内可以完成。如将本书作为教材,可考虑在课堂内完成。老师要注意观察,确定所有学生都已消化了讲授的内容。有些练习要难些,他们是为那些有兴趣深入的读者准备的。大多数练习都可在较短时间内做完,有效地检测和加深您的知识。有些题目比较具有挑战性,但都不会太麻烦。事实上,练习中碰到的问题在实际应用中也会经常碰到。16引言7. 多媒体CD-ROM本书配套提供了一片多媒体CD-ROM,可单独购买及使用。它与其他计算机书籍的普通配套CD不同,那些CD通常仅包含了书中用到的源码(本书的源码可从www.BruceEckel.com免费下载)。本CD-ROM是一个独立的产品,包含了一周“Hads-OnJava”培训课程的全部内容。这是一个由Bruce Eckel讲授的、长度在15小时以上的课程,含500张以上的演示幻灯片。该课程建立在这本书的基础上,所以是非常理想的一个配套产品。CD-ROM包含了本书的两个版本:(1) 本书一个可打印的版本,与下载版完全一致。(2) 为方便读者在屏幕上阅读和索引,CD-ROM提供了一个独特的超链接版本。这些超链接包括:■230个章、节和小标题链接■3600个索引链接CD-ROM刻录了600MB以上的数据。我相信它已对所谓“物超所值”进行了崭新的定义。CD-ROM包含了本书打印版的所有东西,另外还有来自五天快速入门课程的全部材料。我相信它建立了一个新的书刊品质评定标准。若想单独购买此CD-ROM,只能从Web站点www.BruceEckel.com处直接订购。8. 源代码本书所有源码都作为保留版权的免费软件提供,可以独立软件包的形式获得,亦可从http://www.BruceEckel.com下载。为保证大家获得的是最新版本,我用这个正式站点发行代码以及本书电子版。亦可在其他站点找到电子书和源码的镜像版(有些站点已在http://www.BruceEckel.com处列出)。但无论如何,都应检查正式站点,确定镜像版确实是最新的版本。可在课堂和其他教育场所发布这些代码。版权的主要目标是保证源码得到正确的引用,并防止在未经许可的情况下,在印刷材料中发布代码。通常,只要源码获得了正确的引用,则在大多数媒体中使用本书的示例都没有什么问题。在每个源码文件中,都能发现下述版本声明文字:16-17页程序可在自己的开发项目中使用代码,并可在课堂上引用(包括学习材料)。但要确定版权声明在每个源文件中得到了保留。17引言9. 编码样式在本书正文中,标识符(函数、变量和类名)以粗体印刷。大多数关键字也采用粗体——除了一些频繁用到的关键字(若全部采用粗体,会使页面拥挤难看,比如那些“类”)。对于本书的示例,我采用了一种特定的编码样式。该样式得到了大多数Java开发环境的支持。该样式问世已有几年的时间,最早起源于Bjarne Stroustrup先生在《The C++Programming Language》里采用的样式(Addison-Wesley 1991年出版,第2版)。由于代码样式目前是个敏感问题,极易招致数小时的激烈辩论,所以我在这儿只想指出自己并不打算通过这些示例建立一种样式标准。之所以采用这些样式,完全出于我自己的考虑。由于Java是一种形式非常自由的编程语言,所以读者完全可以根据自己的感觉选用了适合的编码样式。本书的程序是由字处理程序包括在正文中的,它们直接取自编译好的文件。所以,本书印刷的代码文件应能正常工作,不会造成编译器错误。会造成编译错误的代码已经用注释//!标出。所以很容易发现,也很容易用自动方式进行测试。读者发现并向作者报告的错误首先会在发行的源码中改正,然后在本书的更新版中校订(所有更新都会在Web站点http://www.BruceEckel.com处出现)。10. Java版本尽管我用几家厂商的Java开发平台对本书的代码进行了测试,但在判断代码行为是否正确时,却通常以Sun公司的Java开发平台为准。当您读到本书时,Sun应已发行了Java的三个重要版本:1.0,1.1及1.2(Sun声称每9个月就会发布一个主要更新版本)。就我看,1.1版对Java语言进行了显著改进,完全应标记成2.0版(由于1.1已作出了如此大的修改,真不敢想象2.0版会出现什么变化)。然而,它的1.2版看起来最终将Java推入了一个全盛时期,特别是其中考虑到了用户界面工具。本书主要讨论了1.0和1.1版,1.2版有部分内容涉及。但在有些时候,新方法明显优于老方法。此时,我会明显偏向于新方法,通常教给大家更好的方法,而完全忽略老方法。然而,有的新方法要以老方法为基础,所以不可避免地要从老方法入手。这一特点尤以AWT为甚,因为那儿不仅存在数量众多的老式Java 1.0代码,有的平台仍然只支持Java 1.0。我会尽量指出哪些特性是哪个版本特有的。大家会注意到我并未使用子版本号,比如1.1.1。至本书完稿为止,Sun公司发布的最后一个1.0版是1.02;而1.1的最后版本是1.1.5(Java 1.2仍在做β测试)。在这本书中,我只会提到Java 1.0,Java 1.1及Java 1.2,避免由于子版本编号过多造成的键入和印刷错误。11. 课程和培训18引言我的公司提供了一个五日制的公共培训课程,以本书的内容为基础。每章的内容都代表着一堂课,并附有相应的课后练习,以便巩固学到的知识。一些辅助用的幻灯片可在本书的配套光盘上找到,最大限度地方便各位读者。欲了解更多的情况,请访问:http://www.BruceEckel.com或发函至:Bruce@EckelObjects.com我的公司也提供了咨询服务,指导客户完成整个开发过程——特别是您的单位首次接触Java开发的时候。12. 错误无论作者花多大精力来避免,错误总是从意想不到的地方冒出来。如果您认为自己发现了一个错误,请在源文件(可在 http://www.BruceEckel.com 处找到)里指出有可能是错误的地方,填好我们提供的表单。将您推荐的纠错方法通过电子函件发给Bruce@EckelObjects.com。经适当的核对与处理,Web站点的电子版以及本书的下一个印刷版本会作出相应的改正。具体格式如下:(1) 在主题行(Subject)写上“TIJ Correction”(去掉引号),以便您的函件进入对应的目录。(2) 在函件正文,采用下述形式:find: 在这里写一个单行字串,以便我们搜索错误所在的地方Comment: 在这里可写多行批注正文,最好以“here's how I think it shoud read”开头###其中,“###”指出批注正文的结束。这样一来,我自己设计的一个纠错工具就能对原始正文来一次“搜索”,而您建议的纠错方法会在随后的一个窗口中弹出。 若希望在本书的下一版添加什么内容,或对书中的练习题有什么意见,也欢迎您指出。我们感谢您的所有意见。13. 封面设计《Thinking in Java》一书封面的创作灵感来源于American Arts & CraftsMovement(美洲艺术&手工艺品运动)。这一运动起始于世纪之交,1900到1920年达到了顶峰。它起源于英格兰,具有一定的历史背景。当时正是机器革命产生的风暴席卷整个大陆的时候,而且受到维多利亚地区强烈装饰风格的巨大影响。Arts&Crafts强调的是原始风格,回归自然的初衷是整个运动的核心。那时对手工制作推崇备至,手工艺人特别得到尊重。正因为如此,人们远远避开现代工具的使用。这场运动对整个艺术界造成了深远的影响,直至今天仍受到人们的怀19引言念。特别是我们面临又一次世纪之交,强烈的怀旧情绪难免涌上心来。计算机发展至今,已走过了很长的一段路。我们更迫切地感到:软件设计中最重要的是设计者本身,而不是流水化的代码编制。如设计者本身的素质和修养不高,那么最多只是“生产”代码的工具而已。我以同样的眼光来看待Java:作为一种将程序员从操作系统繁琐机制中解放出来的尝试,它的目的是使人们成为真正的“软件艺术家”。无论作者还是本书的封面设计者(自孩提时代就是我的朋友)都从这一场运动中获得了灵感。所以接下来的事情就非常简单了,要么自己设计,要么直接采用来自那个时期的作品。此外,封面向大家展示了一个收集箱,自然学者可能用它展示自己的昆虫标本。我们认为这些昆虫都是“对象”,全部置于更大的“收集箱”对象里,再统一置入“封面”这个对象里。它向我们揭示了面向对象编程技术最基本的“集合”概念。当然,作为一名程序员,大家对于“昆虫”或“虫”是非常敏感的(“虫”在英语里是Bug,后指程序错误)。这里的“虫”已被抓获,在一只广口瓶中杀死,最后禁闭于一个小的展览盒里——暗示Java有能力寻找、显示和消除程序里的“虫”(这是Java最具特色的特性之一)。14. 致谢首先,感谢Doyle Street Cohousing Community(道尔街住房社区)容忍我花两年的时间来写这本书(其实他们一直都在容忍我的“胡做非为”)。非常感谢Kevin和Sonda Donovan,是他们把科罗拉多Crested Butte市这个风景优美的地方租给我,使我整个夏天都能安心写作。感谢Crested Butte友好的居民;以及Rocky Mountain Biological Laboratory(岩石山生物实验室),他们的工作人员总是面带微笑。这是我第一次找代理人出书,但却绝没有后悔。谢谢“摩尔文学代理公司”的Claudette Moore小姐。是她强大的信心与毅力使我最终梦想成真。我的头两本书是与Osborne/McGraw-Hill出版社的编辑Jeff Pepper合作出版的。Jeff又在正确的地方和正确的时间出现在了Prentice-Hall出版社,是他为了清除了所有可能遇到的障碍,也使我感受了一次愉快的出书经历。谢谢你,Jeff——你对我非常重要。要特别感谢Gen Kiyooka和他的Digigami公司,我用的Web服务器就是他们提供的;也要感谢Scott Callaway,服务器是由他负责维护的。在我学习Web的过程中,一个服务器无疑是相当有价值的帮助。谢谢Cay Horstmann(《Core Java》一书的副编辑,Prentice Hall于1997年出版)、D'ArcySmith(Symantec公司)和Paul Tyma(《Java Primer Plus》一书的副编辑,The WaiteGroup于1996年出版),感谢他们帮助我澄清语言方面的一些概念。感谢那些在“Java软件开发会议”上我的Java小组发言的同志们,以及我教授过的那些学生,他们提出的问题使我的教案愈发成熟起来。特别感谢Larry和Tina O'Brien,是他们将这本书和我的教学内容制成一张教学CD-ROM(关于这方面的问题,http://www.BruceEckel.com有更多的答案)。20引言有许多人送来了纠错报告,我真的很感激所有这些朋友,但特别要对下面这些人说声谢谢:Kevin Raulerson(发现了多处重大错误),Bob Resendes(发现的错误令人难以置信),John Pinto,Joe Dante,Joe Sharp,David Combs(许多语法和表达不清的地方),Dr.Robert Stephenson,Franklin Chen,Zev Griner,David Karr,Leander A. Stroschein,Steve Clark,Charles A. Lee,AustinMaher,Dennis P. Roth,Roque Oliveira,DouglasDunn,Dejan Ristic,NeilGalarneau,David B. Malkovsky,Steve Wilkinson,以及其他许多热心读者。为了使这本书在欧洲发行,Prof. Ir. Marc Meurrens进行了大量工作。有一些技术人员曾走进我的生活,他们后来都和我成了朋友。最不寻常的是他们全是素食主义者,平时喜欢练习瑜珈功,以及另一些形式的精神训练。我在练习了以后,觉得对我保持精力的旺盛非常有好处。他们是Kraig Brockschmidt,GenKiyooka和Andrea provaglio,是这些朋友帮我了解了Java和程序设计在意大利的情况。 显然,在Delphi上的一些经验使我更容易理解Java,因为它们有许多概念和语言设计决定是相通的。我的Delphi朋友提供了许多帮助,使我能够洞察一些不易为人注意的编程环境。他们是Marco Cantu(另一个意大利人——难道会说拉丁语的人在学习Java时有得天独厚的优势?)、Neil Rubenking(他最喜欢瑜珈/素食/禅道,但也非常喜欢计算机)以及Zack Urlocker(是我游历世界时碰面次数最多的一位同志)。我的朋友Richard Hale Shaw(以及Kim)的一些意见和支持发挥了非常关键的作用。Richard和我花了数月的时间将教学内容合并到一起,并探讨如何使学生感受到最完美的学习体验。也要感谢KoAnn Vikoren,Eric Eaurot,DeborahSommers,Julie Shaw,Nicole Freeman,Cindy Blair,Barbara Hanscome,Regina Ridley,Alex Dunne以及MFI其他可敬的成员。书籍设计、封面设计以及封面照片是由我的朋友Daniel Will-Harris制作的。他是一位著名的作家和设计家(http://www.WillHarris.com),在初中的时候就已显露出了过人的数学天赋。但是,小样是由我制作的,所以录入错误都是我的。我是用Microsoft Word 97 for Windows来写这本书,并用它生成小样。正文字体采用的是Bitstream Carmina;标题采用BitstreamCalligraph 421(www.bitstream.com);每章开头的符号采用的是来自P22的LeonardoExtras(http://www.p22.com);封面字体采用ITC Rennie Marckintosh。 感谢为我提供编译器程序的一些著名公司:Borland,Microsoft,Symantec,Sybase/Powersoft/Watcom以及Sun。特别感谢我的老师和我所有的学生(他们也是我的老师),其中最有趣的一位写作老师是Gabrielle Rico(《Writing the Natural Way》一书的作者,Putnam于1983年出版)。曾向我提供过支持的朋友包括(当然还不止):Andrew Binstock,SteveSinofsky,JDHildebrandt,Tom Keffer,Brian McElhinney,Brinkley Barr,《Midnight Engineering》杂志社的Bill Gates,Larry Constantine和LucyLockwood,Greg Perry,Dan Putterman,ChristiWestphal,Gene Wang,DaveMayer,David Intersimone,Andrea Rosenfield,ClaireSawyers,另一些意大利朋友(Laura Fallai,Corrado,Ilsa和Cristina Giustozzi),Chris和Laura Strand,Almquists,Brad Jerbic,Marilyng Cvitanic,Mabrys,Haflingers,21引言Pollocks,Peter Vinci,Robbins Families,Moelter Families(和McMillans),MichaelWilk,Dave Stoner,Laurie Adams,Cranstons,Larry Fogg,Mike和Karen Sequeira,Gary Entsminger和Allison Brody,KevinDonovan和Sonda Eastlack,Chester和ShannonAndersen,Joe Lordi,Dave和Brenda Bartlett,David Lee,Rentschlers,Sudeks,Dick,Patty和Lee Eckel,Lynn和Todd以及他们的家人。最后,当然还有我的爸爸和妈妈。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:1022第1章 对象入门第1章 对象入门“为什么面向对象的编程会在软件开发领域造成如此震憾的影响?”面向对象编程(OOP)具有多方面的吸引力。对管理人员,它实现了更快和更廉价的开发与维护过程。对分析与设计人员,建模处理变得更加简单,能生成清晰、易于维护的设计方案。对程序员,对象模型显得如此高雅和浅显。此外,面向对象工具以及库的巨大威力使编程成为一项更使人愉悦的任务。每个人都可从中获益,至少表面如此。如果说它有缺点,那就是掌握它需付出的代价。思考对象的时候,需要采用形象思维,而不是程序化的思维。与程序化设计相比,对象的设计过程更具挑战性——特别是在尝试创建可重复使用(可再生)的对象时。过去,那些初涉面向对象编程领域的人都必须进行一项令人痛苦的选择:(1) 选择一种诸如Smalltalk的语言,“出师”前必须掌握一个巨型的库。(2) 选择几乎根本没有库的C++(注释①),然后深入学习这种语言,直至能自行编写对象库。①:幸运的是,这一情况已有明显改观。现在有第三方库以及标准的C++库供选用。事实上,很难很好地设计出对象——从而很难设计好任何东西。因此,只有数量相当少的“专家”能设计出最好的对象,然后让其他人享用。对于成功的OOP语言,它们不仅集成了这种语言的语法以及一个编译程序(编译器),而且还有一个成功的开发环境,其中包含设计优良、易于使用的库。所以,大多数程序员的首要任务就是用现有的对象解决自己的应用问题。本章的目标就是向大家揭示出面向对象编程的概念,并证明它有多么简单。本章将向大家解释Java的多项设计思想,并从概念上解释面向对象的程序设计。但要注意在阅读完本章后,并不能立即编写出全功能的Java程序。所有详细的说明和示例会在本书的其他章节慢慢道来。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:10231.1 抽象的进步1.1 抽象的进步所有编程语言的最终目的都是提供一种“抽象”方法。一种较有争议的说法是:解决问题的复杂程度直接取决于抽象的种类及质量。这儿的“种类”是指准备对什么进行“抽象”?汇编语言是对基础机器的少量抽象。后来的许多“命令式”语言(如FORTRAN,BASIC和C)是对汇编语言的一种抽象。与汇编语言相比,这些语言已有了长足的进步,但它们的抽象原理依然要求我们着重考虑计算机的结构,而非考虑问题本身的结构。在机器模型(位于“方案空间”)与实际解决的问题模型(位于“问题空间”)之间,程序员必须建立起一种联系。这个过程要求人们付出较大的精力,而且由于它脱离了编程语言本身的范围,造成程序代码很难编写,而且要花较大的代价进行维护。由此造成的副作用便是一门完善的“编程方法”学科。为机器建模的另一个方法是为要解决的问题制作模型。对一些早期语言来说,如LISP和APL,它们的做法是“从不同的角度观察世界”——“所有问题都归纳为列表”或“所有问题都归纳为算法”。PROLOG则将所有问题都归纳为决策链。对于这些语言,我们认为它们一部分是面向基于“强制”的编程,另一部分则是专为处理图形符号设计的。每种方法都有自己特殊的用途,适合解决某一类的问题。但只要超出了它们力所能及的范围,就会显得非常笨拙。面向对象的程序设计在此基础上则跨出了一大步,程序员可利用一些工具表达问题空间内的元素。由于这种表达非常普遍,所以不必受限于特定类型的问题。我们将问题空间中的元素以及它们在方案空间的表示物称作“对象”(Object)。当然,还有一些在问题空间没有对应体的其他对象。通过添加新的对象类型,程序可进行灵活的调整,以便与特定的问题配合。所以在阅读方案的描述代码时,会读到对问题进行表达的话语。与我们以前见过的相比,这无疑是一种更加灵活、更加强大的语言抽象方法。总之,OOP允许我们根据问题来描述问题,而不是根据方案。然而,仍有一个联系途径回到计算机。每个对象都类似一台小计算机;它们有自己的状态,而且可要求它们进行特定的操作。与现实世界的“对象”或者“物体”相比,编程“对象”与它们也存在共通的地方:它们都有自己的特征和行为。Alan Kay总结了Smalltalk的五大基本特征。这是第一种成功的面向对象程序设计语言,也是Java的基础语言。通过这些特征,我们可理解“纯粹”的面向对象程序设计方法是什么样的:(1) 所有东西都是对象。可将对象想象成一种新型变量;它保存着数据,但可要求它对自身进行操作。理论上讲,可从要解决的问题身上提出所有概念性的组件,然后在程序中将其表达为一个对象。(2) 程序是一大堆对象的组合;通过消息传递,各对象知道自己该做些什么。为了向对象发出请求,需向那个对象“发送一条消息”。更具体地讲,可将消息想象为一个调用请求,它调用的是从属于目标对象的一个子例程或函数。(3) 每个对象都有自己的存储空间,可容纳其他对象。或者说,通过封装现有对象,可制作出新型对象。所以,尽管对象的概念非常简单,但在程序中却可达到任意高的复杂程度。241.1 抽象的进步(4) 每个对象都有一种类型。根据语法,每个对象都是某个“类”的一个“实例”。其中,“类”(Class)是“类型”(Type)的同义词。一个类最重要的特征就是“能将什么消息发给它?”。(5) 同一类所有对象都能接收相同的消息。这实际是别有含义的一种说法,大家不久便能理解。由于类型为“圆”(Circle)的一个对象也属于类型为“形状”(Shape)的一个对象,所以一个圆完全能接收形状消息。这意味着可让程序代码统一指挥“形状”,令其自动控制所有符合“形状”描述的对象,其中自然包括“圆”。这一特性称为对象的“可替换性”,是OOP最重要的概念之一。一些语言设计者认为面向对象的程序设计本身并不足以方便解决所有形式的程序问题,提倡将不同的方法组合成“多形程序设计语言”(注释②)。②:参见Timothy Budd编著的《Multiparadigm Programming in Leda》,Addison-Wesley1995年出版。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:10251.2 对象的接口1.2 对象的接口亚里士多德或许是认真研究“类型”概念的第一人,他曾谈及“鱼类和鸟类”的问题。在世界首例面向对象语言Simula-67中,第一次用到了这样的一个概念:所有对象——尽管各有特色——都属于某一系列对象的一部分,这些对象具有通用的特征和行为。在Simula-67中,首次用到了class这个关键字,它为程序引入了一个全新的类型(clas和type通常可互换使用;注释③)。③:有些人进行了进一步的区分,他们强调“类型”决定了接口,而“类”是那个接口的一种特殊实现方式。Simula是一个很好的例子。正如这个名字所暗示的,它的作用是“模拟”(Simulate)象“银行出纳员”这样的经典问题。在这个例子里,我们有一系列出纳员、客户、帐号以及交易等。每类成员(元素)都具有一些通用的特征:每个帐号都有一定的余额;每名出纳都能接收客户的存款;等等。与此同时,每个成员都有自己的状态;每个帐号都有不同的余额;每名出纳都有一个名字。所以在计算机程序中,能用独一无二的实体分别表示出纳员、客户、帐号以及交易。这个实体便是“对象”,而且每个对象都隶属一个特定的“类”,那个类具有自己的通用特征与行为。因此,在面向对象的程序设计中,尽管我们真正要做的是新建各种各样的数据“类型”(Type),但几乎所有面向对象的程序设计语言都采用了“class”关键字。当您看到“type”这个字的时候,请同时想到“class”;反之亦然。建好一个类后,可根据情况生成许多对象。随后,可将那些对象作为要解决问题中存在的元素进行处理。事实上,当我们进行面向对象的程序设计时,面临的最大一项挑战性就是:如何在“问题空间”(问题实际存在的地方)的元素与“方案空间”(对实际问题进行建模的地方,如计算机)的元素之间建立理想的“一对一”对应或映射关系。如何利用对象完成真正有用的工作呢?必须有一种办法能向对象发出请求,令其做一些实际的事情,比如完成一次交易、在屏幕上画一些东西或者打开一个开关等等。每个对象仅能接受特定的请求。我们向对象发出的请求是通过它的“接口”(Interface)定义的,对象的“类型”或“类”则规定了它的接口形式。“类型”与“接口”的等价或对应关系是面向对象程序设计的基础。 下面让我们以电灯泡为例:261.2 对象的接口Light lt = new Light();lt.on();在这个例子中,类型/类的名称是Light,可向Light对象发出的请求包括包括打开(on)、关闭(off)、变得更明亮(brighten)或者变得更暗淡(dim)。通过简单地声明一个名字(lt),我们为Light对象创建了一个“句柄”。然后用new关键字新建类型为Light的一个对象。再用等号将其赋给句柄。为了向对象发送一条消息,我们列出句柄名(lt),再用一个句点符号(.)把它同消息名称(on)连接起来。从中可以看出,使用一些预先定义好的类时,我们在程序里采用的代码是非常简单和直观的。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:10271.3 实现方案的隐藏1.3 实现方案的隐藏为方便后面的讨论,让我们先对这一领域的从业人员作一下分类。从根本上说,大致有两方面的人员涉足面向对象的编程:“类创建者”(创建新数据类型的人)以及“客户程序员”(在自己的应用程序中采用现成数据类型的人;注释④)。对客户程序员来讲,最主要的目标就是收集一个充斥着各种类的编程“工具箱”,以便快速开发符合自己要求的应用。而对类创建者来说,他们的目标则是从头构建一个类,只向客户程序员开放有必要开放的东西(接口),其他所有细节都隐藏起来。为什么要这样做?隐藏之后,客户程序员就不能接触和改变那些细节,所以原创者不用担心自己的作品会受到非法修改,可确保它们不会对其他人造成影响。④:感谢我的朋友Scott Meyers,是他帮我起了这个名字。“接口”(Interface)规定了可对一个特定的对象发出哪些请求。然而,必须在某个地方存在着一些代码,以便满足这些请求。这些代码与那些隐藏起来的数据便叫作“隐藏的实现”。站在程式化程序编写(Procedural Programming)的角度,整个问题并不显得复杂。一种类型含有与每种可能的请求关联起来的函数。一旦向对象发出一个特定的请求,就会调用那个函数。我们通常将这个过程总结为向对象“发送一条消息”(提出一个请求)。对象的职责就是决定如何对这条消息作出反应(执行相应的代码)。对于任何关系,重要一点是让牵连到的所有成员都遵守相同的规则。创建一个库时,相当于同客户程序员建立了一种关系。对方也是程序员,但他们的目标是组合出一个特定的应用(程序),或者用您的库构建一个更大的库。若任何人都能使用一个类的所有成员,那么客户程序员可对那个类做任何事情,没有办法强制他们遵守任何约束。即便非常不愿客户程序员直接操作类内包含的一些成员,但倘若未进行访问控制,就没有办法阻止这一情况的发生——所有东西都会暴露无遗。有两方面的原因促使我们控制对成员的访问。第一个原因是防止程序员接触他们不该接触的东西——通常是内部数据类型的设计思想。若只是为了解决特定的问题,用户只需操作接口即可,毋需明白这些信息。我们向用户提供的实际是一种服务,因为他们很容易就可看出哪些对自己非常重要,以及哪些可忽略不计。进行访问控制的第二个原因是允许库设计人员修改内部结构,不用担心它会对客户程序员造成什么影响。例如,我们最开始可能设计了一个形式简单的类,以便简化开发。以后又决定进行改写,使其更快地运行。若接口与实现方法早已隔离开,并分别受到保护,就可放心做到这一点,只要求用户重新链接一下即可。Java采用三个显式(明确)关键字以及一个隐式(暗示)关键字来设置类边界:public,private,protected以及暗示性的friendly。若未明确指定其他关键字,则默认为后者。这些关键字的使用和含义都是相当直观的,它们决定了谁能使用后续的定义内容。“public”(公共)意味着后续的定义任何人均可使用。而在另一方面,“private”(私有)意味着除您自己、类型281.3 实现方案的隐藏的创建者以及那个类型的内部函数成员,其他任何人都不能访问后续的定义信息。private在您与客户程序员之间竖起了一堵墙。若有人试图访问私有成员,就会得到一个编译期错误。“friendly”(友好的)涉及“包装”或“封装”(Package)的概念——即Java用来构建库的方法。若某样东西是“友好的”,意味着它只能在这个包装的范围内使用(所以这一访问级别有时也叫作“包装访问”)。“protected”(受保护的)与“private”相似,只是一个继承的类可访问受保护的成员,但不能访问私有成员。继承的问题不久就要谈到。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:10291.4 方案的重复使用1.4 方案的重复使用创建并测试好一个类后,它应(从理想的角度)代表一个有用的代码单位。但并不象许多人希望的那样,这种重复使用的能力并不容易实现;它要求较多的经验以及洞察力,这样才能设计出一个好的方案,才有可能重复使用。许多人认为代码或设计方案的重复使用是面向对象的程序设计提供的最伟大的一种杠杆。为重复使用一个类,最简单的办法是仅直接使用那个类的对象。但同时也能将那个类的一个对象置入一个新类。我们把这叫作“创建一个成员对象”。新类可由任意数量和类型的其他对象构成。无论如何,只要新类达到了设计要求即可。这个概念叫作“组织”——在现有类的基础上组织一个新类。有时,我们也将组织称作“包含”关系,比如“一辆车包含了一个变速箱”。对象的组织具有极大的灵活性。新类的“成员对象”通常设为“私有”(Private),使用这个类的客户程序员不能访问它们。这样一来,我们可在不干扰客户代码的前提下,从容地修改那些成员。也可以在“运行期”更改成员,这进一步增大了灵活性。后面要讲到的“继承”并不具备这种灵活性,因为编译器必须对通过继承创建的类加以限制。由于继承的重要性,所以在面向对象的程序设计中,它经常被重点强调。作为新加入这一领域的程序员,或许早已先入为主地认为“继承应当随处可见”。沿这种思路产生的设计将是非常笨拙的,会大大增加程序的复杂程度。相反,新建类的时候,首先应考虑“组织”对象;这样做显得更加简单和灵活。利用对象的组织,我们的设计可保持清爽。一旦需要用到继承,就会明显意识到这一点。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:10301.5 继承:重新使用接口1.5 继承:重新使用接口就其本身来说,对象的概念可为我们带来极大的便利。它在概念上允许我们将各式各样数据和功能封装到一起。这样便可恰当表达“问题空间”的概念,不用刻意遵照基础机器的表达方式。在程序设计语言中,这些概念则反映为具体的数据类型(使用class关键字)。我们费尽心思做出一种数据类型后,假如不得不又新建一种类型,令其实现大致相同的功能,那会是一件非常令人灰心的事情。但若能利用现成的数据类型,对其进行“克隆”,再根据情况进行添加和修改,情况就显得理想多了。“继承”正是针对这个目标而设计的。但继承并不完全等价于克隆。在继承过程中,若原始类(正式名称叫作基础类、超类或父类)发生了变化,修改过的“克隆”类(正式名称叫作继承类或者子类)也会反映出这种变化。在Java语言中,继承是通过extends关键字实现的 使用继承时,相当于创建了一个新类。这个新类不仅包含了现有类型的所有成员(尽管private成员被隐藏起来,且不能访问),但更重要的是,它复制了基础类的接口。也就是说,可向基础类的对象发送的所有消息亦可原样发给衍生类的对象。根据可以发送的消息,我们能知道类的类型。这意味着衍生类具有与基础类相同的类型!为真正理解面向对象程序设计的含义,首先必须认识到这种类型的等价关系。由于基础类和衍生类具有相同的接口,所以那个接口必须进行特殊的设计。也就是说,对象接收到一条特定的消息后,必须有一个“方法”能够执行。若只是简单地继承一个类,并不做其他任何事情,来自基础类接口的方法就会直接照搬到衍生类。这意味着衍生类的对象不仅有相同的类型,也有同样的行为,这一后果通常是我们不愿见到的。有两种做法可将新得的衍生类与原来的基础类区分开。第一种做法十分简单:为衍生类添加新函数(功能)。这些新函数并非基础类接口的一部分。进行这种处理时,一般都是意识到基础类不能满足我们的要求,所以需要添加更多的函数。这是一种最简单、最基本的继承用法,大多数时候都可完美地解决我们的问题。然而,事先还是要仔细调查自己的基础类是否真的需要这些额外的函数。1.5.1 改善基础类尽管extends关键字暗示着我们要为接口“扩展”新功能,但实情并非肯定如此。为区分我们的新类,第二个办法是改变基础类一个现有函数的行为。我们将其称作“改善”那个函数。为改善一个函数,只需为衍生类的函数建立一个新定义即可。我们的目标是:“尽管使用的函数接口未变,但它的新版本具有不同的表现”。1.5.2 等价与类似关系针对继承可能会产生这样的一个争论:继承只能改善原基础类的函数吗?若答案是肯定的,则衍生类型就是与基础类完全相同的类型,因为都拥有完全相同的接口。这样造成的结果就是:我们完全能够将衍生类的一个对象换成基础类的一个对象!可将其想象成一种“纯替换”。311.5 继承:重新使用接口在某种意义上,这是进行继承的一种理想方式。此时,我们通常认为基础类和衍生类之间存在一种“等价”关系——因为我们可以理直气壮地说:“圆就是一种几何形状”。为了对继承进行测试,一个办法就是看看自己是否能把它们套入这种“等价”关系中,看看是否有意义。但在许多时候,我们必须为衍生类型加入新的接口元素。所以不仅扩展了接口,也创建了一种新类型。这种新类型仍可替换成基础类型,但这种替换并不是完美的,因为不可在基础类里访问新函数。我们将其称作“类似”关系;新类型拥有旧类型的接口,但也包含了其他函数,所以不能说它们是完全等价的。举个例子来说,让我们考虑一下制冷机的情况。假定我们的房间连好了用于制冷的各种控制器;也就是说,我们已拥有必要的“接口”来控制制冷。现在假设机器出了故障,我们把它换成一台新型的冷、热两用空调,冬天和夏天均可使用。冷、热空调“类似”制冷机,但能做更多的事情。由于我们的房间只安装了控制制冷的设备,所以它们只限于同新机器的制冷部分打交道。新机器的接口已得到了扩展,但现有的系统并不知道除原始接口以外的任何东西。认识了等价与类似的区别后,再进行替换时就会有把握得多。尽管大多数时候“纯替换”已经足够,但您会发现在某些情况下,仍然有明显的理由需要在衍生类的基础上增添新功能。通过前面对这两种情况的讨论,相信大家已心中有数该如何做。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:10321.6 多形对象的互换使用1.6 多形对象的互换使用通常,继承最终会以创建一系列类收场,所有类都建立在统一的接口基础上。我们用一幅颠倒的树形图来阐明这一点(注释⑤):⑤:这儿采用了“统一记号法”,本书将主要采用这种方法。对这样的一系列类,我们要进行的一项重要处理就是将衍生类的对象当作基础类的一个对象对待。这一点是非常重要的,因为它意味着我们只需编写单一的代码,令其忽略类型的特定细节,只与基础类打交道。这样一来,那些代码就可与类型信息分开。所以更易编写,也更易理解。此外,若通过继承增添了一种新类型,如“三角形”,那么我们为“几何形状”新类型编写的代码会象在旧类型里一样良好地工作。所以说程序具备了“扩展能力”,具有“扩展性”。 以上面的例子为基础,假设我们用Java写了这样一个函数:void doStuff(Shape s) {s.erase();// ...s.draw();}这个函数可与任何“几何形状”(Shape)通信,所以完全独立于它要描绘(draw)和删除(erase)的任何特定类型的对象。如果我们在其他一些程序里使用doStuff()函数:Circle c = new Circle();Triangle t = new Triangle();Line l = new Line();doStuff(c);doStuff(t);doStuff(l);331.6 多形对象的互换使用那么对doStuff()的调用会自动良好地工作,无论对象的具体类型是什么。 这实际是一个非常有用的编程技巧。请考虑下面这行代码:doStuff(c);此时,一个Circle(圆)句柄传递给一个本来期待Shape(形状)句柄的函数。由于圆是一种几何形状,所以doStuff()能正确地进行处理。也就是说,凡是doStuff()能发给一个Shape的消息,Circle也能接收。所以这样做是安全的,不会造成错误。 我们将这种把衍生类型当作它的基本类型处理的过程叫作“Upcasting”(上溯造型)。其中,“cast”(造型)是指根据一个现成的模型创建;而“Up”(向上)表明继承的方向是从“上面”来的——即基础类位于顶部,而衍生类在下方展开。所以,根据基础类进行造型就是一个从上面继承的过程,即“Upcasting”。在面向对象的程序里,通常都要用到上溯造型技术。这是避免去调查准确类型的一个好办法。请看看doStuff()里的代码:s.erase();// ...s.draw();注意它并未这样表达:“如果你是一个Circle,就这样做;如果你是一个Square,就那样做;等等”。若那样编写代码,就需检查一个Shape所有可能的类型,如圆、矩形等等。这显然是非常麻烦的,而且每次添加了一种新的Shape类型后,都要相应地进行修改。在这儿,我们只需说:“你是一种几何形状,我知道你能将自己删掉,即erase();请自己采取那个行动,并自己去控制所有的细节吧。”1.6.1 动态绑定在doStuff()的代码里,最让人吃惊的是尽管我们没作出任何特殊指示,采取的操作也是完全正确和恰当的。我们知道,为Circle调用draw()时执行的代码与为一个Square或Line调用draw()时执行的代码是不同的。但在将draw()消息发给一个匿名Shape时,根据Shape句柄当时连接的实际类型,会相应地采取正确的操作。这当然令人惊讶,因为当Java编译器为doStuff()编译代码时,它并不知道自己要操作的准确类型是什么。尽管我们确实可以保证最终会为Shape调用erase(),为Shape调用draw(),但并不能保证为特定的Circle,Square或者Line调用什么。然而最后采取的操作同样是正确的,这是怎么做到的呢?将一条消息发给对象时,如果并不知道对方的具体类型是什么,但采取的行动同样是正确的,这种情况就叫作“多形性”(Polymorphism)。对面向对象的程序设计语言来说,它们用以实现多形性的方法叫作“动态绑定”。编译器和运行期系统会负责对所有细节的控制;我们只需知道会发生什么事情,而且更重要的是,如何利用它帮助自己设计程序。有些语言要求我们用一个特殊的关键字来允许动态绑定。在C++中,这个关键字是virtual。在Java中,我们则完全不必记住添加一个关键字,因为函数的动态绑定是自动进行的。所以在将一条消息发给对象时,我们完全可以肯定对象会采取正确的行动,即使其中涉及上溯造型341.6 多形对象的互换使用之类的处理。1.6.2 抽象的基础类和接口设计程序时,我们经常都希望基础类只为自己的衍生类提供一个接口。也就是说,我们不想其他任何人实际创建基础类的一个对象,只对上溯造型成它,以便使用它们的接口。为达到这个目的,需要把那个类变成“抽象”的——使用abstract关键字。若有人试图创建抽象类的一个对象,编译器就会阻止他们。这种工具可有效强制实行一种特殊的设计。亦可用abstract关键字描述一个尚未实现的方法——作为一个“根”使用,指出:“这是适用于从这个类继承的所有类型的一个接口函数,但目前尚没有对它进行任何形式的实现。”抽象方法也许只能在一个抽象类里创建。继承了一个类后,那个方法就必须实现,否则继承的类也会变成“抽象”类。通过创建一个抽象方法,我们可以将一个方法置入接口中,不必再为那个方法提供可能毫无意义的主体代码。interface(接口)关键字将抽象类的概念更延伸了一步,它完全禁止了所有的函数定义。“接口”是一种相当有效和常用的工具。另外如果自己愿意,亦可将多个接口都合并到一起(不能从多个普通class或abstract class中继承)。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:10351.7 对象的创建和存在时间1.7 对象的创建和存在时间1.7 对象的创建和存在时间从技术角度说,OOP(面向对象程序设计)只是涉及抽象的数据类型、继承以及多形性,但另一些问题也可能显得非常重要。本节将就这些问题进行探讨。最重要的问题之一是对象的创建及破坏方式。对象需要的数据位于哪儿,如何控制对象的“存在时间”呢?针对这个问题,解决的方案是各异其趣的。C++认为程序的执行效率是最重要的一个问题,所以它允许程序员作出选择。为获得最快的运行速度,存储以及存在时间可在编写程序时决定,只需将对象放置在堆栈(有时也叫作自动或定域变量)或者静态存储区域即可。这样便为存储空间的分配和释放提供了一个优先级。某些情况下,这种优先级的控制是非常有价值的。然而,我们同时也牺牲了灵活性,因为在编写程序时,必须知道对象的准确的数量、存在时间、以及类型。如果要解决的是一个较常规的问题,如计算机辅助设计、仓储管理或者空中交通控制,这一方法就显得太局限了。第二个方法是在一个内存池中动态创建对象,该内存池亦叫“堆”或者“内存堆”。若采用这种方式,除非进入运行期,否则根本不知道到底需要多少个对象,也不知道它们的存在时间有多长,以及准确的类型是什么。这些参数都在程序正式运行时才决定的。若需一个新对象,只需在需要它的时候在内存堆里简单地创建它即可。由于存储空间的管理是运行期间动态进行的,所以在内存堆里分配存储空间的时间比在堆栈里创建的时间长得多(在堆栈里创建存储空间一般只需要一个简单的指令,将堆栈指针向下或向下移动即可)。由于动态创建方法使对象本来就倾向于复杂,所以查找存储空间以及释放它所需的额外开销不会为对象的创建造成明显的影响。除此以外,更大的灵活性对于常规编程问题的解决是至关重要的。C++允许我们决定是在写程序时创建对象,还是在运行期间创建,这种控制方法更加灵活。大家或许认为既然它如此灵活,那么无论如何都应在内存堆里创建对象,而不是在堆栈中创建。但还要考虑另外一个问题,亦即对象的“存在时间”或者“生存时间”(Lifetime)。若在堆栈或者静态存储空间里创建一个对象,编译器会判断对象的持续时间有多长,到时会自动“破坏”或者“清除”它。程序员可用两种方法来破坏一个对象:用程序化的方式决定何时破坏对象,或者利用由运行环境提供的一种“垃圾收集器”特性,自动寻找那些不再使用的对象,并将其清除。当然,垃圾收集器显得方便得多,但要求所有应用程序都必须容忍垃圾收集器的存在,并能默许随垃圾收集带来的额外开销。但这并不符合C++语言的设计宗旨,所以未能包括到C++里。但Java确实提供了一个垃圾收集器(Smalltalk也有这样的设计;尽管Delphi默认为没有垃圾收集器,但可选择安装;而C++亦可使用一些由其他公司开发的垃圾收集产品)。本节剩下的部分将讨论操纵对象时要考虑的另一些因素。1.7.1 集合与继承器361.7 对象的创建和存在时间针对一个特定问题的解决,如果事先不知道需要多少个对象,或者它们的持续时间有多长,那么也不知道如何保存那些对象。既然如此,怎样才能知道那些对象要求多少空间呢?事先上根本无法提前知道,除非进入运行期。在面向对象的设计中,大多数问题的解决办法似乎都有些轻率——只是简单地创建另一种类型的对象。用于解决特定问题的新型对象容纳了指向其他对象的句柄。当然,也可以用数组来做同样的事情,那是大多数语言都具有的一种功能。但不能只看到这一点。这种新对象通常叫作“集合”(亦叫作一个“容器”,但AWT在不同的场合应用了这个术语,所以本书将一直沿用“集合”的称呼。在需要的时候,集合会自动扩充自己,以便适应我们在其中置入的任何东西。所以我们事先不必知道要在一个集合里容下多少东西。只需创建一个集合,以后的工作让它自己负责好了。幸运的是,设计优良的OOP语言都配套提供了一系列集合。在C++中,它们是以“标准模板库”(STL)的形式提供的。Object Pascal用自己的“可视组件库”(VCL)提供集合。Smalltalk提供了一套非常完整的集合。而Java也用自己的标准库提供了集合。在某些库中,一个常规集合便可满足人们的大多数要求;而在另一些库中(特别是C++的库),则面向不同的需求提供了不同类型的集合。例如,可以用一个矢量统一对所有元素的访问方式;一个链接列表则用于保证所有元素的插入统一。所以我们能根据自己的需要选择适当的类型。其中包括集、队列、散列表、树、堆栈等等。所有集合都提供了相应的读写功能。将某样东西置入集合时,采用的方式是十分明显的。有一个叫作“推”(Push)、“添加”(Add)或其他类似名字的函数用于做这件事情。但将数据从集合中取出的时候,方式却并不总是那么明显。如果是一个数组形式的实体,比如一个矢量(Vector),那么也许能用索引运算符或函数。但在许多情况下,这样做往往会无功而返。此外,单选定函数的功能是非常有限的。如果想对集合中的一系列元素进行操纵或比较,而不是仅仅面向一个,这时又该怎么办呢?办法就是使用一个“继续器”(Iterator),它属于一种对象,负责选择集合内的元素,并把它们提供给继承器的用户。作为一个类,它也提供了一级抽象。利用这一级抽象,可将集合细节与用于访问那个集合的代码隔离开。通过继承器的作用,集合被抽象成一个简单的序列。继承器允许我们遍历那个序列,同时毋需关心基础结构是什么——换言之,不管它是一个矢量、一个链接列表、一个堆栈,还是其他什么东西。这样一来,我们就可以灵活地改变基础数据,不会对程序里的代码造成干扰。Java最开始(在1.0和1.1版中)提供的是一个标准继承器,名为Enumeration(枚举),为它的所有集合类提供服务。Java 1.2新增一个更复杂的集合库,其中包含了一个名为Iterator的继承器,可以做比老式的Enumeration更多的事情。从设计角度出发,我们需要的是一个全功能的序列。通过对它的操纵,应该能解决自己的问题。如果一种类型的序列即可满足我们的所有要求,那么完全没有必要再换用不同的类型。有两方面的原因促使我们需要对集合作出选择。首先,集合提供了不同的接口类型以及外部行为。堆栈的接口与行为与队列的不同,而队列的接口与行为又与一个集(Set)或列表的不同。利用这个特征,我们解决问题时便有更大的灵活性。371.7 对象的创建和存在时间其次,不同的集合在进行特定操作时往往有不同的效率。最好的例子便是矢量(Vector)和列表(List)的区别。它们都属于简单的序列,拥有完全一致的接口和外部行为。但在执行一些特定的任务时,需要的开销却是完全不同的。对矢量内的元素进行的随机访问(存取)是一种常时操作;无论我们选择的选择是什么,需要的时间量都是相同的。但在一个链接列表中,若想到处移动,并随机挑选一个元素,就需付出“惨重”的代价。而且假设某个元素位于列表较远的地方,找到它所需的时间也会长许多。但在另一方面,如果想在序列中部插入一个元素,用列表就比用矢量划算得多。这些以及其他操作都有不同的执行效率,具体取决于序列的基础结构是什么。在设计阶段,我们可以先从一个列表开始。最后调整性能的时候,再根据情况把它换成矢量。由于抽象是通过继承器进行的,所以能在两者方便地切换,对代码的影响则显得微不足道。最后,记住集合只是一个用来放置对象的储藏所。如果那个储藏所能满足我们的所有需要,就完全没必要关心它具体是如何实现的(这是大多数类型对象的一个基本概念)。如果在一个编程环境中工作,它由于其他因素(比如在Windows下运行,或者由垃圾收集器带来了开销)产生了内在的开销,那么矢量和链接列表之间在系统开销上的差异就或许不是一个大问题。我们可能只需要一种类型的序列。甚至可以想象有一个“完美”的集合抽象,它能根据自己的使用方式自动改变基层的实现方式。1.7.2 单根结构在面向对象的程序设计中,由于C++的引入而显得尤为突出的一个问题是:所有类最终是否都应从单独一个基础类继承。在Java中(与其他几乎所有OOP语言一样),对这个问题的答案都是肯定的,而且这个终级基础类的名字很简单,就是一个“Object”。这种“单根结构”具有许多方面的优点。单根结构中的所有对象都有一个通用接口,所以它们最终都属于相同的类型。另一种方案(就象C++那样)是我们不能保证所有东西都属于相同的基本类型。从向后兼容的角度看,这一方案可与C模型更好地配合,而且可以认为它的限制更少一些。但假期我们想进行纯粹的面向对象编程,那么必须构建自己的结构,以期获得与内建到其他OOP语言里的同样的便利。需添加我们要用到的各种新类库,还要使用另一些不兼容的接口。理所当然地,这也需要付出额外的精力使新接口与自己的设计方案配合(可能还需要多重继承)。为得到C++额外的“灵活性”,付出这样的代价值得吗?当然,如果真的需要——如果早已是C专家,如果对C有难舍的情结——那么就真的很值得。但假如你是一名新手,首次接触这类设计,象Java那样的替换方案也许会更省事一些。单根结构中的所有对象(比如所有Java对象)都可以保证拥有一些特定的功能。在自己的系统中,我们知道对每个对象都能进行一些基本操作。一个单根结构,加上所有对象都在内存堆中创建,可以极大简化参数的传递(这在C++里是一个复杂的概念)。 利用单根结构,我们可以更方便地实现一个垃圾收集器。与此有关的必要支持可安装于基础类中,而垃圾收集器可将适当的消息发给系统内的任何对象。如果没有这种单根结构,而且系统通过一个句柄来操纵对象,那么实现垃圾收集器的途径会有很大的不同,而且会面临许多障碍。381.7 对象的创建和存在时间由于运行期的类型信息肯定存在于所有对象中,所以永远不会遇到判断不出一个对象的类型的情况。这对系统级的操作来说显得特别重要,比如违例控制;而且也能在程序设计时获得更大的灵活性。但大家也可能产生疑问,既然你把好处说得这么天花乱坠,为什么C++没有采用单根结构呢?事实上,这是早期在效率与控制上权衡的一种结果。单根结构会带来程序设计上的一些限制。而且更重要的是,它加大了新程序与原有C代码兼容的难度。尽管这些限制仅在特定的场合会真的造成问题,但为了获得最大的灵活程度,C++最终决定放弃采用单根结构这一做法。而Java不存在上述的问题,它是全新设计的一种语言,不必与现有的语言保持所谓的“向后兼容”。所以很自然地,与其他大多数面向对象的程序设计语言一样,单根结构在Java的设计方案中很快就落实下来。1.7.3 集合库与方便使用集合由于集合是我们经常都要用到的一种工具,所以一个集合库是十分必要的,它应该可以方便地重复使用。这样一来,我们就可以方便地取用各种集合,将其插入自己的程序。Java提供了这样的一个库,尽管它在Java 1.0和1.1中都显得非常有限(Java 1.2的集合库则无疑是一个杰作)。1.下溯造型与模板/通用性为了使这些集合能够重复使用,或者“再生”,Java提供了一种通用类型,以前曾把它叫作“Object”。单根结构意味着、所有东西归根结底都是一个对象”!所以容纳了Object的一个集合实际可以容纳任何东西。这使我们对它的重复使用变得非常简便。 为使用这样的一个集合,只需添加指向它的对象句柄即可,以后可以通过句柄重新使用对象。但由于集合只能容纳Object,所以在我们向集合里添加对象句柄时,它会上溯造型成Object,这样便丢失了它的身份或者标识信息。再次使用它的时候,会得到一个Object句柄,而非指向我们早先置入的那个类型的句柄。所以怎样才能归还它的本来面貌,调用早先置入集合的那个对象的有用接口呢?在这里,我们再次用到了造型(Cast)。但这一次不是在分级结构中上溯造型成一种更“通用”的类型。而是下溯造型成一种更“特殊”的类型。这种造型方法叫作“下溯造型”(Downcasting)。举个例子来说,我们知道在上溯造型的时候,Circle(圆)属于Shape(几何形状)的一种类型,所以上溯造型是安全的。但我们不知道一个Object到底是Circle还是Shape,所以很难保证下溯造型的安全进行,除非确切地知道自己要操作的是什么。但这也不是绝对危险的,因为假如下溯造型成错误的东西,会得到我们称为“违例”(Exception)的一种运行期错误。我们稍后即会对此进行解释。但在从一个集合提取对象句柄时,必须用某种方式准确地记住它们是什么,以保证下溯造型的正确进行。 下溯造型和运行期检查都要求花额外的时间来运行程序,而且程序员必须付出额外的精力。既然如此,我们能不能创建一个“智能”集合,令其知道自己容纳的类型呢?这样做可消除下溯造型的必要391.7 对象的创建和存在时间以及潜在的错误。答案是肯定的,我们可以采用“参数化类型”,它们是编译器能自动定制的类,可与特定的类型配合。例如,通过使用一个参数化集合,编译器可对那个集合进行定制,使其只接受Shape,而且只提取Shape。参数化类型是C++一个重要的组成部分,这部分是C++没有单根结构的缘故。在C++中,用于实现参数化类型的关键字是template(模板)。Java目前尚未提供参数化类型,因为由于使用的是单根结构,所以使用它显得有些笨拙。但这并不能保证以后的版本不会实现,因为“generic”这个词已被Java“保留到将来实现”(在Ada语言中,“generic”被用来实现它的模板)。Java采取的这种关键字保留机制其实经常让人摸不着头脑,很难断定以后会发生什么事情。1.7.4 清除时的困境:由谁负责清除?每个对象都要求资源才能“生存”,其中最令人注目的资源是内存。如果不再需要使用一个对象,就必须将其清除,以便释放这些资源,以便其他对象使用。如果要解决的是非常简单的问题,如何清除对象这个问题并不显得很突出:我们创建对象,在需要的时候调用它,然后将其清除或者“破坏”。但在另一方面,我们平时遇到的问题往往要比这复杂得多。 举个例子来说,假设我们要设计一套系统,用它管理一个机场的空中交通(同样的模型也可能适于管理一个仓库的货柜、或者一套影带出租系统、或者宠物店的宠物房。这初看似乎十分简单:构造一个集合用来容纳飞机,然后创建一架新飞机,将其置入集合。对进入空中交通管制区的所有飞机都如此处理。至于清除,在一架飞机离开这个区域的时候把它简单地删去即可。但事情并没有这么简单,可能还需要另一套系统来记录与飞机有关的数据。当然,和控制器的主要功能不同,这些数据的重要性可能一开始并不显露出来。例如,这条记录反映的可能是离开机场的所有小飞机的飞行计划。所以我们得到了由小飞机组成的另一个集合。一旦创建了一个飞机对象,如果它是一架小飞机,那么也必须把它置入这个集合。然后在系统空闲时期,需对这个集合中的对象进行一些后台处理。问题现在显得更复杂了:如何才能知道什么时间删除对象呢?用完对象后,系统的其他某些部分可能仍然要发挥作用。同样的问题也会在其他大量场合出现,而且在程序设计系统中(如C++),在用完一个对象之后必须明确地将其删除,所以问题会变得异常复杂(注释⑥)。⑥:注意这一点只对内存堆里创建的对象成立(用new命令创建的)。但在另一方面,对这儿描述的问题以及其他所有常见的编程问题来说,都要求对象在内存堆里创建。在Java中,垃圾收集器在设计时已考虑到了内存的释放问题(尽管这并不包括清除一个对象涉及到的其他方面)。垃圾收集器“知道”一个对象在什么时候不再使用,然后会自动释放那个对象占据的内存空间。采用这种方式,另外加上所有对象都从单个根类Object继承的事实,而且由于我们只能在内存堆中以一种方式创建对象,所以Java的编程要比C++的编程简单得多。我们只需要作出少量的抉择,即可克服原先存在的大量障碍。2.垃圾收集器对效率及灵活性的影响401.7 对象的创建和存在时间既然这是如此好的一种手段,为什么在C++里没有得到充分的发挥呢?我们当然要为这种编程的方便性付出一定的代价,代价就是运行期的开销。正如早先提到的那样,在C++中,我们可在堆栈中创建对象。在这种情况下,对象会得以自动清除(但不具有在运行期间随心所欲创建对象的灵活性)。在堆栈中创建对象是为对象分配存储空间最有效的一种方式,也是释放那些空间最有效的一种方式。在内存堆(Heap)中创建对象可能要付出昂贵得多的代价。如果总是从同一个基础类继承,并使所有函数调用都具有“同质多形”特征,那么也不可避免地需要付出一定的代价。但垃圾收集器是一种特殊的问题,因为我们永远不能确定它什么时候启动或者要花多长的时间。这意味着在Java程序执行期间,存在着一种不连贯的因素。所以在某些特殊的场合,我们必须避免用它——比如在一个程序的执行必须保持稳定、连贯的时候(通常把它们叫作“实时程序”,尽管并不是所有实时编程问题都要这方面的要求——注释⑦)。⑦:根据本书一些技术性读者的反馈,有一个现成的实时Java系统(www.newmonics.com)确实能够保证垃圾收集器的效能。C++语言的设计者曾经向C程序员发出请求(而且做得非常成功),不要希望在可以使用C的任何地方,向语言里加入可能对C++的速度或使用造成影响的任何特性。这个目的达到了,但代价就是C++的编程不可避免地复杂起来。Java比C++简单,但付出的代价是效率以及一定程度的灵活性。但对大多数程序设计问题来说,Java无疑都应是我们的首选。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:10411.8 违例控制:解决错误1.8 违例控制:解决错误从最古老的程序设计语言开始,错误控制一直都是设计者们需要解决的一个大问题。由于很难设计出一套完美的错误控制方案,许多语言干脆将问题简单地忽略掉,将其转嫁给库设计人员。对大多数错误控制方案来说,最主要的一个问题是它们严重依赖程序员的警觉性,而不是依赖语言本身的强制标准。如果程序员不够警惕——若比较匆忙,这几乎是肯定会发生的——程序所依赖的错误控制方案便会失效。“违例控制”将错误控制方案内置到程序设计语言中,有时甚至内建到操作系统内。这里的“违例”(Exception)属于一个特殊的对象,它会从产生错误的地方“扔”或“掷”出来。随后,这个违例会被设计用于控制特定类型错误的“违例控制器”捕获。在情况变得不对劲的时候,可能有几个违例控制器并行捕获对应的违例对象。由于采用的是独立的执行路径,所以不会干扰我们的常规执行代码。这样便使代码的编写变得更加简单,因为不必经常性强制检查代码。除此以外,“掷”出的一个违例不同于从函数返回的错误值,也不同于由函数设置的一个标志。那些错误值或标志的作用是指示一个错误状态,是可以忽略的。但违例不能被忽略,所以肯定能在某个地方得到处置。最后,利用违例能够可靠地从一个糟糕的环境中恢复。此时一般不需要退出,我们可以采取某些处理,恢复程序的正常执行。显然,这样编制出来的程序显得更加可靠。Java的违例控制机制与大多数程序设计语言都有所不同。因为在Java中,违例控制模块是从一开始就封装好的,所以必须使用它!如果没有自己写一些代码来正确地控制违例,就会得到一条编译期出错提示。这样可保证程序的连贯性,使错误控制变得更加容易。 注意违例控制并不属于一种面向对象的特性,尽管在面向对象的程序设计语言中,违例通常是用一个对象表示的。早在面向对象语言问世以前,违例控制就已经存在了。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:10421.9 多线程1.9 多线程在计算机编程中,一个基本的概念就是同时对多个任务加以控制。许多程序设计问题都要求程序能够停下手头的工作,改为处理其他一些问题,再返回主进程。可以通过多种途径达到这个目的。最开始的时候,那些拥有机器低级知识的程序员编写一些“中断服务例程”,主进程的暂停是通过硬件级的中断实现的。尽管这是一种有用的方法,但编出的程序很难移植,由此造成了另一类的代价高昂问题。有些时候,中断对那些实时性很强的任务来说是很有必要的。但还存在其他许多问题,它们只要求将问题划分进入独立运行的程序片断中,使整个程序能更迅速地响应用户的请求。在一个程序中,这些独立运行的片断叫作“线程”(Thread),利用它编程的概念就叫作“多线程处理”。多线程处理一个常见的例子就是用户界面。利用线程,用户可按下一个按钮,然后程序会立即作出响应,而不是让用户等待程序完成了当前任务以后才开始响应。最开始,线程只是用于分配单个处理器的处理时间的一种工具。但假如操作系统本身支持多个处理器,那么每个线程都可分配给一个不同的处理器,真正进入“并行运算”状态。从程序设计语言的角度看,多线程操作最有价值的特性之一就是程序员不必关心到底使用了多少个处理器。程序在逻辑意义上被分割为数个线程;假如机器本身安装了多个处理器,那么程序会运行得更快,毋需作出任何特殊的调校。根据前面的论述,大家可能感觉线程处理非常简单。但必须注意一个问题:共享资源!如果有多个线程同时运行,而且它们试图访问相同的资源,就会遇到一个问题。举个例子来说,两个进程不能将信息同时发送给一台打印机。为解决这个问题,对那些可共享的资源来说(比如打印机),它们在使用期间必须进入锁定状态。所以一个线程可将资源锁定,在完成了它的任务后,再解开(释放)这个锁,使其他线程可以接着使用同样的资源。Java的多线程机制已内建到语言中,这使一个可能较复杂的问题变得简单起来。对多线程处理的支持是在对象这一级支持的,所以一个执行线程可表达为一个对象。Java也提供了有限的资源锁定方案。它能锁定任何对象占用的内存(内存实际是多种共享资源的一种),所以同一时间只能有一个线程使用特定的内存空间。为达到这个目的,需要使用synchronized关键字。其他类型的资源必须由程序员明确锁定,这通常要求程序员创建一个对象,用它代表一把锁,所有线程在访问那个资源时都必须检查这把锁。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:10431.10 永久性1.10 永久性创建一个对象后,只要我们需要,它就会一直存在下去。但在程序结束运行时,对象的“生存期”也会宣告结束。尽管这一现象表面上非常合理,但深入追究就会发现,假如在程序停止运行以后,对象也能继续存在,并能保留它的全部信息,那么在某些情况下将是一件非常有价值的事情。下次启动程序时,对象仍然在那里,里面保留的信息仍然是程序上一次运行时的那些信息。当然,可以将信息写入一个文件或者数据库,从而达到相同的效果。但尽管可将所有东西都看作一个对象,如果能将对象声明成“永久性”,并令其为我们照看其他所有细节,无疑也是一件相当方便的事情。Java 1.1提供了对“有限永久性”的支持,这意味着我们可将对象简单地保存到磁盘上,以后任何时间都可取回。之所以称它为“有限”的,是由于我们仍然需要明确发出调用,进行对象的保存和取回工作。这些工作不能自动进行。在Java未来的版本中,对“永久性”的支持有望更加全面。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:10441.11 Java和因特网1.11 Java和因特网既然Java不过另一种类型的程序设计语言,大家可能会奇怪它为什么值得如此重视,为什么还有这么多的人认为它是计算机程序设计的一个里程碑呢?如果您来自一个传统的程序设计背景,那么答案在刚开始的时候并不是很明显。Java除了可解决传统的程序设计问题以外,还能解决World Wide Web(万维网)上的编程问题。1.11.1 什么是Web?Web这个词刚开始显得有些泛泛,似乎“冲浪”、“网上存在”以及“主页”等等都和它拉上了一些关系。甚至还有一种“Internet综合症”的说法,对许多人狂热的上网行为提出了质疑。我们在这里有必要作一些深入的探讨,但在这之前,必须理解客户机/服务器系统的概念,这是充斥着许多令人迷惑的问题的又一个计算领域。1. 客户机/服务器计算客户机/服务器系统的基本思想是我们能在一个统一的地方集中存放信息资源。一般将数据集中保存在某个数据库中,根据其他人或者机器的请求将信息投递给对方。客户机/服务器概述的一个关键在于信息是“集中存放”的。所以我们能方便地更改信息,然后将修改过的信息发放给信息的消费者。将各种元素集中到一起,信息仓库、用于投递信息的软件以及信息及软件所在的那台机器,它们联合起来便叫作“服务器”(Server)。而对那些驻留在远程机器上的软件,它们需要与服务器通信,取回信息,进行适当的处理,然后在远程机器上显示出来,这些就叫作“客户”(Client)。这样看来,客户机/服务器的基本概念并不复杂。这里要注意的一个主要问题是单个服务器需要同时向多个客户提供服务。在这一机制中,通常少不了一套数据库管理系统,使设计人员能将数据布局封装到表格中,以获得最优的使用。除此以外,系统经常允许客户将新信息插入一个服务器。这意味着必须确保客户的新数据不会与其他客户的新数据冲突,或者说需要保证那些数据在加入数据库的时候不会丢失(用数据库的术语来说,这叫作“事务处理”)。客户软件发生了改变之后,它们必须在客户机器上构建、调试以及安装。所有这些会使问题变得比我们一般想象的复杂得多。另外,对多种类型的计算机和操作系统的支持也是一个大问题。最后,性能的问题显得尤为重要:可能会有数百个客户同时向服务器发出请求。所以任何微小的延误都是不能忽视的。为尽可能缓解潜伏的问题,程序员需要谨慎地分散任务的处理负担。一般可以考虑让客户机负担部分处理任务,但有时亦可分派给服务器所在地的其他机器,那些机器亦叫作“中间件”(中间件也用于改进对系统的维护)。所以在具体实现的时候,其他人发布信息这样一个简单的概念可能变得异常复杂。有时甚至会使人产生完全无从着手的感觉。客户机/服务器的概念在这时就可以大显身手了。事实上,大约有一半的程序设计活动都可以采用客户机/服务器的结构。这种系统可负责从处理订单及信用卡交易,一直到发布各类数据的方方面面的任务——股票市场、科学研究、政府451.11 Java和因特网运作等等。在过去,我们一般为单独的问题采取单独的解决方案;每次都要设计一套新方案。这些方案无论创建还是使用都比较困难,用户每次都要学习和适应新界面。客户机/服务器问题需要从根本上加以变革!2. Web是一个巨大的服务器Web实际就是一套规模巨大的客户机/服务器系统。但它的情况要复杂一些,因为所有服务器和客户都同时存在于单个网络上面。但我们没必要了解更进一步的细节,因为唯一要关心的就是一次建立同一个服务器的连接,并同它打交道(即使可能要在全世界的范围内搜索正确的服务器)。最开始的时候,这是一个简单的单向操作过程。我们向一个服务器发出请求,它向我们回传一个文件,由于本机的浏览器软件(亦即“客户”或“客户程序”)负责解释和格式化,并在我们面前的屏幕上正确地显示出来。但人们不久就不满足于只从一个服务器传递网页。他们希望获得完全的客户机/服务器能力,使客户(程序)也能反馈一些信息到服务器。比如希望对服务器上的数据库进行检索,向服务器添加新信息,或者下一份订单等等(这也提供了比以前的系统更高的安全要求)。在Web的发展过程中,我们可以很清晰地看出这些令人心喜的变化。Web浏览器的发展终于迈出了重要的一步:某个信息可在任何类型的计算机上显示出来,毋需任何改动。然而,浏览器仍然显得很原始,在用户迅速增多的要求面前显得有些力不从心。它们的交互能力不够强,而且对服务器和因特网都造成了一定程度的干扰。这是由于每次采取一些要求编程的操作时,必须将信息反馈回服务器,在服务器那一端进行处理。所以完全可能需要等待数秒乃至数分钟的时间才会发现自己刚才拼错了一个单词。由于浏览器只是一个纯粹的查看程序,所以连最简单的计算任务都不能进行(当然在另一方面,它也显得非常安全,因为不能在本机上面执行任何程序,避开了程序错误或者病毒的骚扰)。为解决这个问题,人们采取了许多不同的方法。最开始的时候,人们对图形标准进行了改进,使浏览器能显示更好的动画和视频。为解决剩下的问题,唯一的办法就是在客户端(浏览器)内运行程序。这就叫作“客户端编程”,它是对传统的“服务器端编程”的一个非常重要的拓展。1.11.2 客户端编程(注释⑧)Web最初采用的“服务器-浏览器”方案可提供交互式内容,但这种交互能力完全由服务器提供,为服务器和因特网带来了不小的负担。服务器一般为客户浏览器产生静态网页,由后者简单地解释并显示出来。基本HTML语言提供了简单的数据收集机制:文字输入框、复选框、单选钮、列表以及下拉列表等,另外还有一个按钮,只能由程序规定重新设置表单中的数据,以便回传给服务器。用户提交的信息通过所有Web服务器均能支持的“通用网关接口”(CGI)回传到服务器。包含在提交数据中的文字指示CGI该如何操作。最常见的行动是运行位于服务器的一个程序。那个程序一般保存在一个名为“cgi-bin”的目录中(按下Web页内的一个按钮时,请注意一下浏览器顶部的地址窗,经常都能发现“cgi-bin”的字样)。大多数语言都可用来编制这些程序,但其中最常见的是Perl。这是由于Perl是专为文字的处理及解释而设计的,所以能在任何服务器上安装和使用,无论采用的处理器或操作系统是什么。461.11 Java和因特网⑧:本节内容改编自某位作者的一篇文章。那篇文章最早出现在位于www.mainspring.com的Mainspring上。本节的采用已征得了对方的同意。今天的许多Web站点都严格地建立在CGI的基础上,事实上几乎所有事情都可用CGI做到。唯一的问题就是响应时间。CGI程序的响应取决于需要传送多少数据,以及服务器和因特网两方面的负担有多重(而且CGI程序的启动比较慢)。Web的早期设计者并未预料到当初绰绰有余的带宽很快就变得不够用,这正是大量应用充斥网上造成的结果。例如,此时任何形式的动态图形显示都几乎不能连贯地显示,因为此时必须创建一个GIF文件,再将图形的每种变化从服务器传递给客户。而且大家应该对输入表单上的数据校验有着深刻的体会。原来的方法是我们按下网页上的提交按钮(Submit);数据回传给服务器;服务器启动一个CGI程序,检查用户输入是否有错;格式化一个HTML页,通知可能遇到的错误,并将这个页回传给我们;随后必须回到原先那个表单页,再输入一遍。这种方法不仅速度非常慢,也显得非常繁琐。解决的办法就是客户端的程序设计。运行Web浏览器的大多数机器都拥有足够强的能力,可进行其他大量工作。与此同时,原始的静态HTML方法仍然可以采用,它会一直等到服务器送回下一个页。客户端编程意味着Web浏览器可获得更充分的利用,并可有效改善Web服务器的交互(互动)能力。对客户端编程的讨论与常规编程问题的讨论并没有太大的区别。采用的参数肯定是相同的,只是运行的平台不同:Web浏览器就象一个有限的操作系统。无论如何,我们仍然需要编程,仍然会在客户端编程中遇到大量问题,同时也有很多解决的方案。在本节剩下的部分里,我们将对这些问题进行一番概括,并介绍在客户端编程中采取的对策。1. 插件朝客户端编程迈进的时候,最重要的一个问题就是插件的设计。利用插件,程序员可以方便地为浏览器添加新功能,用户只需下载一些代码,把它们“插入”浏览器的适当位置即可。这些代码的作用是告诉浏览器“从现在开始,你可以进行这些新活动了”(仅需下载这些插入一次)。有些快速和功能强大的行为是通过插件添加到浏览器的。但插件的编写并不是一件简单的任务。在我们构建一个特定的站点时,可能并不希望涉及这方面的工作。对客户端程序设计来说,插件的价值在于它允许专业程序员设计出一种新的语言,并将那种语言添加到浏览器,同时不必经过浏览器原创者的许可。由此可以看出,插件实际是浏览器的一个“后门”,允许创建新的客户端程序设计语言(尽管并非所有语言都是作为插件实现的)。2. 脚本编制语言插件造成了脚本编制语言的爆炸性增长。通过这种脚本语言,可将用于自己客户端程序的源码直接插入HTML页,而对那种语言进行解释的插件会在HTML页显示的时候自动激活。脚本语言一般都倾向于尽量简化,易于理解。而且由于它们是从属于HTML页的一些简单正文,所以只需向服务器发出对那个页的一次请求,即可非常快地载入。缺点是我们的代码全部暴露在人们面前。另一方面,由于通常不用脚本编制语言做过份复杂的事情,所以这个问题暂且可以放在一边。471.11 Java和因特网脚本语言真正面向的是特定类型问题的解决,其中主要涉及如何创建更丰富、更具有互动能力的图形用户界面(GUI)。然而,脚本语言也许能解决客户端编程中80%的问题。你碰到的问题可能完全就在那80%里面。而且由于脚本编制语言的宗旨是尽可能地简化与快速,所以在考虑其他更复杂的方案之前(如Java及ActiveX),首先应想一下脚本语言是否可行。目前讨论得最多的脚本编制语言包括JavaScript(它与Java没有任何关系;之所以叫那个名字,完全是一种市场策略)、VBScript(同Visual Basic很相似)以及Tcl/Tk(来源于流行的跨平台GUI构造语言)。当然还有其他许多语言,也有许多正在开发中。JavaScript也许是目常用的,它得到的支持也最全面。无论NetscapeNavigator,MicrosoftInternet Explorer,还是Opera,目前都提供了对JavaScript的支持。除此以外,市面上讲述JavaScript的书籍也要比讲述其他语言的书多得多。有些工具还能利用JavaScript自动产生网页。当然,如果你已经有Visual Basic或者Tcl/Tk的深厚功底,当然用它们要简单得多,起码可以避免学习新语言的烦恼(解决Web方面的问题就已经够让人头痛了)。3. Java如果说一种脚本编制语言能解决80%的客户端程序设计问题,那么剩下的20%又该怎么办呢?它们属于一些高难度的问题吗?目前最流行的方案就是Java。它不仅是一种功能强大、高度安全、可以跨平台使用以及国际通用的程序设计语言,也是一种具有旺盛生命力的语言。对Java的扩展是不断进行的,提供的语言特性和库能够很好地解决传统语言不能解决的问题,比如多线程操作、数据库访问、连网程序设计以及分布式计算等等。Java通过“程序片”(Applet)巧妙地解决了客户端编程的问题。程序片(或“小应用程序”)是一种非常小的程序,只能在Web浏览器中运行。作为Web页的一部分,程序片代码会自动下载回来(这和网页中的图片差不多)。激活程序片后,它会执行一个程序。程序片的一个优点体现在:通过程序片,一旦用户需要客户软件,软件就可从服务器自动下载回来。它们能自动取得客户软件的最新版本,不会出错,也没有重新安装的麻烦。由于Java的设计原理,程序员只需要创建程序的一个版本,那个程序能在几乎所有计算机以及安装了Java解释器的浏览器中运行。由于Java是一种全功能的编程语言,所以在向服务器发出一个请求之前,我们能先在客户端做完尽可能多的工作。例如,再也不必通过因特网传送一个请求表单,再由服务器确定其中是否存在一个拼写或者其他参数错误。大多数数据校验工作均可在客户端完成,没有必要坐在计算机前面焦急地等待服务器的响应。这样一来,不仅速度和响应的灵敏度得到了极大的提高,对网络和服务器造成的负担也可以明显减轻,这对保障因特网的畅通是至关重要的。与脚本程序相比,Java程序片的另一个优点是它采用编译好的形式,所以客户端看不到源码。当然在另一方面,反编译Java程序片也并不是件难事,而且代码的隐藏一般并不是个重要的问题。大家要注意另外两个重要的问题。正如本书以前会讲到的那样,编译好的Java程序片可能包含了许多模块,所以要多次“命中”(访问)服务器以便下载(在Java 1.1中,这个问题得到了有效的改善——利用Java压缩档,即JAR文件——它允许设计者将所有必要的模块都封装到一起,供用户统一下载)。在另一方面,脚本程序是作为Web页正文的一部分集成到Web页内的。这种程序一般都非常小,可有效减少对服务器的点击数。另一个因素是学481.11 Java和因特网习方面的问题。不管你平时听别人怎么说,Java都不是一种十分容易便可学会的语言。如果你以前是一名Visual Basic程序员,那么转向VBScript会是一种最快捷的方案。由于VBScript可以解决大多数典型的客户机/服务器问题,所以一旦上手,就很难下定决心再去学习Java。如果对脚本编制语言比较熟,那么在转向Java之前,建议先熟悉一下JavaScript或者VBScript,因为它们可能已经能够满足你的需要,不必经历学习Java的艰苦过程。4. ActiveX在某种程度上,Java的一个有力竞争对手应该是微软的ActiveX,尽管它采用的是完全不同的一套实现机制。ActiveX最早是一种纯Windows的方案。经过一家独立的专业协会的努力,ActiveX现在已具备了跨平台使用的能力。实际上,ActiveX的意思是“假如你的程序同它的工作环境正常连接,它就能进入Web页,并在支持ActiveX的浏览器中运行”(IE固化了对ActiveX的支持,而Netscape需要一个插件)。所以,ActiveX并没有限制我们使用一种特定的语言。比如,假设我们已经是一名有经验的Windows程序员,能熟练地使用象C++、VisualBasic或者BorlandDelphi那样的语言,就能几乎不加任何学习地创建出ActiveX组件。事实上,ActiveX是在我们的Web页中使用“历史遗留”代码的最佳途径。5. 安全自动下载和通过因特网运行程序听起来就象是一个病毒制造者的梦想。在客户端的编程中,ActiveX带来了最让人头痛的安全问题。点击一个Web站点的时候,可能会随同HTML网页传回任何数量的东西:GIF文件、脚本代码、编译好的Java代码以及ActiveX组件。有些是无害的;GIF文件不会对我们造成任何危害,而脚本编制语言通常在自己可做的事情上有着很大的限制。Java也设计成在一个安全“沙箱”里在它的程序片中运行,这样可防止操作位于沙箱以外的磁盘或者内存区域。ActiveX是所有这些里面最让人担心的。用ActiveX编写程序就象编制Windows应用程序——可以做自己想做的任何事情。下载回一个ActiveX组件后,它完全可能对我们磁盘上的文件造成破坏。当然,对那些下载回来并不限于在Web浏览器内部运行的程序,它们同样也可能破坏我们的系统。从BBS下载回来的病毒一直是个大问题,但因特网的速度使得这个问题变得更加复杂。目前解决的办法是“数字签名”,代码会得到权威机构的验证,显示出它的作者是谁。这一机制的基础是认为病毒之所以会传播,是由于它的编制者匿名的缘故。所以假如去掉了匿名的因素,所有设计者都不得不为它们的行为负责。这似乎是一个很好的主意,因为它使程序显得更加正规。但我对它能消除恶意因素持怀疑态度,因为假如一个程序便含有Bug,那么同样会造成问题。Java通过“沙箱”来防止这些问题的发生。Java解释器内嵌于我们本地的Web浏览器中,在程序片装载时会检查所有有嫌疑的指令。特别地,程序片根本没有权力将文件写进磁盘,或者删除文件(这是病毒最喜欢做的事情之一)。我们通常认为程序片是安全的。而且由于安全对于营建一套可靠的客户机/服务器系统至关重要,所以会给病毒留下漏洞的所有错误都能很快得到修复(浏览器软件实际需要强行遵守这些安全规则;而有些浏览器则允许我们选择不同的安全级别,防止对系统不同程度的访问)。491.11 Java和因特网大家或许会怀疑这种限制是否会妨碍我们将文件写到本地磁盘。比如,我们有时需要构建一个本地数据库,或将数据保存下来,以便日后离线使用。最早的版本似乎每个人都能在线做任何敏感的事情,但这很快就变得非常不现实(尽管低价“互联网工具”有一天可能会满足大多数用户的需要)。解决的方案是“签了名的程序片”,它用公共密钥加密算法验证程序片确实来自它所声称的地方。当然在通过验证后,签了名的一个程序片仍然可以开始清除你的磁盘。但从理论上说,既然现在能够找到创建人“算帐”,他们一般不会干这种蠢事。Java 1.1为数字签名提供了一个框架,在必要时,可让一个程序片“走”到沙箱的外面来。数字签名遗漏了一个重要的问题,那就是人们在因特网上移动的速度。如下载回一个错误百出的程序,而它很不幸地真的干了某些蠢事,需要多久的时间才能发觉这一点呢?这也许是几天,也可能几周之后。发现了之后,又如何追踪当初肇事的程序呢(以及它当时的责任有多大)?6. 因特网和内联网Web是解决客户机/服务器问题的一种常用方案,所以最好能用相同的技术解决此类问题的一些“子集”,特别是公司内部的传统客户机/服务器问题。对于传统的客户机/服务器模式,我们面临的问题是拥有多种不同类型的客户计算机,而且很难安装新的客户软件。但通过Web浏览器和客户端编程,这两类问题都可得到很好的解决。若一个信息网络局限于一家特定的公司,那么在将Web技术应用于它之后,即可称其为“内联网”(Intranet),以示与国际性的“因特网”(Internet)有别。内联网提供了比因特网更大的安全级别,因为可以物理性地控制对公司内部服务器的使用。说到培训,一般只要人们理解了浏览器的常规概念,就可以非常轻松地掌握网页和程序片之间的差异,所以学习新型系统的开销会大幅度减少。安全问题将我们引入客户端编程领域一个似乎是自动形成的分支。若程序是在因特网上运行,由于无从知晓它会在什么平台上运行,所以编程时要特别留意,防范可能出现的编程错误。需作一些跨平台处理,以及适当的安全防范,比如采用某种脚本语言或者Java。但假如在内联网中运行,面临的一些制约因素就会发生变化。全部机器均为Intel/Windows平台是件很平常的事情。在内联网中,需要对自己代码的质量负责。而且一旦发现错误,就可以马上改正。除此以外,可能已经有了一些“历史遗留”的代码,并用较传统的客户机/服务器方式使用那些代码。但在进行升级时,每次都要物理性地安装一道客户程序。浪费在升级安装上的时间是转移到浏览器的一项重要原因。使用了浏览器后,升级就变得易如反掌,而且整个过程是透明和自动进行的。如果真的是牵涉到这样的一个内联网中,最明智的方法是采用ActiveX,而非试图采用一种新的语言来改写程序代码。面临客户端编程问题令人困惑的一系列解决方案时,最好的方案是先做一次投资/回报分析。请总结出问题的全部制约因素,以及什么才是最快的方案。由于客户端程序设计仍然要编程,所以无论如何都该针对自己的特定情况采取最好的开发途径。这是准备面对程序开发中一些不可避免的问题时,我们可以作出的最佳姿态。1.11.3 服务器端编程501.11 Java和因特网我们的整个讨论都忽略了服务器端编程的问题。如果向服务器发出一个请求,会发生什么事情?大多数时候的请求都是很简单的一个“把这个文件发给我”。浏览器随后会按适当的形式解释这个文件:作为HTML页、一幅图、一个Java程序片、一个脚本程序等等。向服务器发出的较复杂的请求通常涉及到对一个数据库进行操作(事务处理)。其中最常见的就是发出一个数据库检索命令,得到结果后,服务器会把它格式化成HTML页,并作为结果传回来(当然,假如客户通过Java或者某种脚本语言具有了更高的智能,那么原始数据就能在客户端发送和格式化;这样做速度可以更快,也能减轻服务器的负担)。另外,有时需要在数据库中注册自己的名字(比如加入一个组时),或者向服务器发出一份订单,这就涉及到对那个数据库的修改。这类服务器请求必须通过服务器端的一些代码进行,我们称其为“服务器端的编程”。在传统意义上,服务器端编程是用Perl和CGI脚本进行的,但更复杂的系统已经出现。其中包括基于Java的Web服务器,它允许我们用Java进行所有服务器端编程,写出的程序就叫作“小服务程序”(Servlet)。1.11.4 一个独立的领域:应用程序与Java有关的大多数争论都是与程序片有关的。Java实际是一种常规用途的程序设计语言,可解决任何类型的问题,至少理论上如此。而且正如前面指出的,可以用更有效的方式来解决大多数客户机/服务器问题。如果将视线从程序片身上转开(同时放宽一些限制,比如禁止写盘等),就进入了常规用途的应用程序的广阔领域。这种应用程序可独立运行,毋需浏览器,就象普通的执行程序那样。在这儿,Java的特色并不仅仅反应在它的移植能力,也反映在编程本身上。就象贯穿全书都会讲到的那样,Java提供了许多有用的特性,使我们能在较短的时间里创建出比用从前的程序设计语言更健壮的程序。 但要注意任何东西都不是十全十美的,我们为此也要付出一些代价。其中最明显的是执行速度放慢了(尽管可对此进行多方面的调整)。和任何语言一样,Java本身也存在一些限制,使得它不十分适合解决某些特殊的编程问题。但不管怎样,Java都是一种正在快速发展的语言。随着每个新版本的发布,它变得越来越可爱,能充分解决的问题也变得越来越多。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:10511.12 分析和设计1.12 分析和设计面向对象的范式是思考程序设计时一种新的、而且全然不同的方式,许多人最开始都会在如何构造一个项目上皱起了眉头。事实上,我们可以作出一个“好”的设计,它能充分利用OOP提供的所有优点。有关OOP分析与设计的书籍大多数都不尽如人意。其中的大多数书都充斥着莫名其妙的话语、笨拙的笔调以及许多听起来似乎很重要的声明(注释⑨)。我认为这种书最好压缩到一章左右的空间,至多写成一本非常薄的书。具有讽剌意味的是,那些特别专注于复杂事物管理的人往往在写一些浅显、明白的书上面大费周章!如果不能说得简单和直接,一定没多少人喜欢看这方面的内容。毕竟,OOP的全部宗旨就是让软件开发的过程变得更加容易。尽管这可能影响了那些喜欢解决复杂问题的人的生计,但为什么不从一开始就把事情弄得简单些呢?因此,希望我能从开始就为大家打下一个良好的基础,尽可能用几个段落来说清楚分析与设计的问题。⑨:最好的入门书仍然是Grady Booch的《Object-Oriented Design withApplications,第2版本》,Wiely & Sons于1996年出版。这本书讲得很有深度,而且通俗易懂,尽管他的记号方法对大多数设计来说都显得不必要地复杂。1.12.1 不要迷失在整个开发过程中,最重要的事情就是:不要将自己迷失!但事实上这种事情很容易发生。大多数方法都设计用来解决最大范围内的问题。当然,也存在一些特别困难的项目,需要作者付出更为艰辛的努力,或者付出更大的代价。但是,大多数项目都是比较“常规”的,所以一般都能作出成功的分析与设计,而且只需用到推荐的一小部分方法。但无论多么有限,某些形式的处理总是有益的,这可使整个项目的开发更加容易,总比直接了当开始编码好!也就是说,假如你正在考察一种特殊的方法,其中包含了大量细节,并推荐了许多步骤和文档,那么仍然很难正确判断自己该在何时停止。时刻提醒自己注意以下几个问题:(1) 对象是什么?(怎样将自己的项目分割成一系列单独的组件?)(2) 它们的接口是什么?(需要将什么消息发给每一个对象?)在确定了对象和它们的接口后,便可着手编写一个程序。出于对多方面原因的考虑,可能还需要比这更多的说明及文档,但要求掌握的资料绝对不能比这还少。整个过程可划分为四个阶段,阶段0刚刚开始采用某些形式的结构。1.12.2 阶段0:拟出一个计划521.12 分析和设计第一步是决定在后面的过程中采取哪些步骤。这听起来似乎很简单(事实上,我们这儿说的一切都似乎很简单),但很常见的一种情况是:有些人甚至没有进入阶段1,便忙忙慌慌地开始编写代码。如果你的计划本来就是“直接开始开始编码”,那样做当然也无可非议(若对自己要解决的问题已有很透彻的理解,便可考虑那样做)。但最低程度也应同意自己该有个计划。在这个阶段,可能要决定一些必要的附加处理结构。但非常不幸,有些程序员写程序时喜欢随心所欲,他们认为“该完成的时候自然会完成”。这样做刚开始可能不会有什么问题,但我觉得假如能在整个过程中设置几个标志,或者“路标”,将更有益于你集中注意力。这恐怕比单纯地为了“完成工作”而工作好得多。至少,在达到了一个又一个的目标,经过了一个接一个的路标以后,可对自己的进度有清晰的把握,干劲也会相应地提高,不会产生“路遥漫漫无期”的感觉。从我刚开始学习故事结构起(我想有一天能写本小说出来),就一直坚持这种做法,感觉就象简单地让文字“流”到纸上。在我写与计算机有关的东西时,发现结构要比小说简单得多,所以不需要考虑太多这方面的问题。但我仍然制订了整个写作的结构,使自己对要写什么做到心中有数。因此,即使你的计划就是直接开始写程序,仍然需要经历以下的阶段,同时向自己提出一些特定的问题。1.12.3 阶段1:要制作什么? 在上一代程序设计中(即“过程化或程序化设计”),这个阶段称为“建立需求分析和系统规格”。当然,那些操作今天已经不再需要了,或者至少改换了形式。大量令人头痛的文档资料已成为历史。但当时的初衷是好的。需求分析的意思是“建立一系列规则,根据它判断任务什么时候完成,以及客户怎样才能满意”。系统规格则表示“这里是一些具体的说明,让你知道程序需要做什么(而不是怎样做)才能满足要求”。需求分析实际就是你和客户之间的一份合约(即使客户就在本公司内部工作,或者是其他对象及系统)。系统规格是对所面临问题的最高级别的一种揭示,我们依据它判断任务是否完成,以及需要花多长的时间。由于这些都需要取得参与者的一致同意,所以我建议尽可能地简化它们——最好采用列表和基本图表的形式——以节省时间。可能还会面临另一些限制,需要把它们扩充成为更大的文档。我们特别要注意将重点放在这一阶段的核心问题上,不要纠缠于细枝末节。这个核心问题就是:决定采用什么系统。对这个问题,最有价值的工具就是一个名为“使用条件”的集合。对那些采用“假如……,系统该怎样做?”形式的问题,这便是最有说服力的回答。例如,“假如客户需要提取一张现金支票,但当时又没有这么多的现金储备,那么自动取款机该怎样反应?”对这个问题,“使用条件”可以指示自动取款机在那种“条件”下的正确操作。应尽可能总结出自己系统的一套完整的“使用条件”或者“应用场合”。一旦完成这个工作,就相当于摸清了想让系统完成的核心任务。由于将重点放在“使用条件”上,一个很好的效果就是它们总能让你放精力放在最关键的东西上,并防止自己分心于对完成任务关系不大的其他事情上面。也就是说,只要掌握了一套完整的“使用条件”,就可以对自己的系统作出清晰的描述,并转移到下一个阶段。在这一阶段,也有可能无法完全掌握系统日后的各种应用场合,但这也没有关系。只要肯花时间,所有问题都会自然而然暴露出来。不要过份在意系统规格的“完美”,否则也容易产生挫败感和焦燥情绪。531.12 分析和设计在这一阶段,最好用几个简单的段落对自己的系统作出描述,然后围绕它们再进行扩充,添加一些“名词”和“动词”。“名词”自然成为对象,而“动词”自然成为要整合到对象接口中的“方法”。只要亲自试着做一做,就会发现这是多么有用的一个工具;有些时候,它能帮助你完成绝大多数的工作。尽管仍处在初级阶段,但这时的一些日程安排也可能会非常管用。我们现在对自己要构建的东西应该有了一个较全面的认识,所以可能已经感觉到了它大概会花多长的时间来完成。此时要考虑多方面的因素:如果估计出一个较长的日程,那么公司也许决定不再继续下去;或者一名主管已经估算出了这个项目要花多长的时间,并会试着影响你的估计。但无论如何,最好从一开始就草拟出一份“诚实”的时间表,以后再进行一些暂时难以作出的决策。目前有许多技术可帮助我们计算出准确的日程安排(就象那些预测股票市场起落的技术),但通常最好的方法还是依赖自己的经验和直觉(不要忘记,直觉也要建立在经验上)。感觉一下大概需要花多长的时间,然后将这个时间加倍,再加上10%。你的感觉可能是正确的;“也许”能在那个时间里完成。但“加倍”使那个时间更加充裕,“10%”的时间则用于进行最后的推敲和深化。但同时也要对此向上级主管作出适当的解释,无论对方有什么抱怨和修改,只要明确地告诉他们:这样的一个日程安排,只是我的一个估计!1.12.4 阶段2:如何构建?在这一阶段,必须拿出一套设计方案,并解释其中包含的各类对象在外观上是什么样子,以及相互间是如何沟通的。此时可考虑采用一种特殊的图表工具:“统一建模语言”(UML)。请到http://www.rational.com去下载一份UML规格书。作为第1阶段中的描述工具,UML也是很有帮助的。此外,还可用它在第2阶段中处理一些图表(如流程图)。当然并非一定要使用UML,但它对你会很有帮助,特别是在希望描绘一张详尽的图表,让许多人在一起研究的时候。除UML外,还可选择对对象以及它们的接口进行文字化描述(就象我在《Thinking inC++》里说的那样,但这种方法非常原始,发挥的作用亦较有限。我曾有一次非常成功的咨询经历,那时涉及到一小组人的初始设计。他们以前还没有构建过OOP(面向对象程序设计)项目,将对象画在白板上面。我们谈到各对象相互间该如何沟通(通信),并删除了其中的一部分,以及替换了另一部分对象。这个小组(他们知道这个项目的目的是什么)实际上已经制订出了设计方案;他们自己“拥有”了设计,而不是让设计自然而然地显露出来。我在那里做的事情就是对设计进行指导,提出一些适当的问题,尝试作出一些假设,并从小组中得到反馈,以便修改那些假设。这个过程中最美妙的事情就是整个小组并不是通过学习一些抽象的例子来进行面向对象的设计,而是通过实践一个真正的设计来掌握OOP的窍门,而那个设计正是他们当时手上的工作!作出了对对象以及它们的接口的说明后,就完成了第2阶段的工作。当然,这些工作可能并不完全。有些工作可能要等到进入阶段3才能得知。但这已经足够了。我们真正需要关心的是最终找出所有的对象。能早些发现当然好,但OOP提供了足够完美的结构,以后再找出它们也不迟。1.12.5 阶段3:开始创建541.12 分析和设计读这本书的可能是程序员,现在进入的正是你可能最感兴趣的阶段。由于手头上有一个计划——无论它有多么简要,而且在正式编码前掌握了正确的设计结构,所以会发现接下去的工作比一开始就埋头写程序要简单得多。而这正是我们想达到的目的。让代码做到我们想做的事情,这是所有程序项目最终的目标。但切不要急功冒进,否则只有得不偿失。根据我的经验,最后先拿出一套较为全面的方案,使其尽可能设想周全,能满足尽可能多的要求。给我的感觉,编程更象一门艺术,不能只是作为技术活来看待。所有付出最终都会得到回报。作为真正的程序员,这并非可有可无的一种素质。全面的思考、周密的准备、良好的构造不仅使程序更易构建与调试,也使其更易理解和维护,而那正是一套软件赢利的必要条件。 构建好系统,并令其运行起来后,必须进行实际检验,以前做的那些需求分析和系统规格便可派上用场了。全面地考察自己的程序,确定提出的所有要求均已满足。现在一切似乎都该结束了?是吗?1.12.6 阶段4:校订事实上,整个开发周期还没有结束,现在进入的是传统意义上称为“维护”的一个阶段。“维护”是一个比较暧昧的称呼,可用它表示从“保持它按设想的轨道运行”、“加入客户从前忘了声明的功能”或者更传统的“除掉暴露出来的一切臭虫”等等意思。所以大家对“维护”这个词产生了许多误解,有的人认为:凡是需要“维护”的东西,必定不是好的,或者是有缺陷的!因为这个词说明你实际构建的是一个非常“原始”的程序,以后需要频繁地作出改动、添加新的代码或者防止它的落后、退化等。因此,我们需要用一个更合理的词语来称呼以后需要继续的工作。这个词便是“校订”。换言之,“你第一次做的东西并不完善,所以需为自己留下一个深入学习、认知的空间,再回过头去作一些改变”。对于要解决的问题,随着对它的学习和了解愈加深入,可能需要作出大量改动。进行这些工作的一个动力是随着不断的改革优化,终于能够从自己的努力中得到回报,无论这需要经历一个较短还是较长的时期。什么时候才叫“达到理想的状态”呢?这并不仅仅意味着程序必须按要求的那样工作,并能适应各种指定的“使用条件”,它也意味着代码的内部结构应当尽善尽美。至少,我们应能感觉出整个结构都能良好地协调运作。没有笨拙的语法,没有臃肿的对象,也没有一些华而不实的东西。除此以外,必须保证程序结构有很强的生命力。由于多方面的原因,以后对程序的改动是必不可少。但必须确定改动能够方便和清楚地进行。这里没有花巧可言。不仅需要理解自己构建的是什么,也要理解程序如何不断地进化。幸运的是,面向对象的程序设计语言特别适合进行这类连续作出的修改——由对象建立起来的边界可有效保证结构的整体性,并能防范对无关对象进行的无谓干扰、破坏。也可以对自己的程序作一些看似激烈的大变动,同时不会破坏程序的整体性,不会波及到其他代码。事实上,对“校订”的支持是OOP非常重要的一个特点。通过校订,可创建出至少接近自己设想的东西。然后从整体上观察自己的作品,把它与自己的要求比较,看看还短缺什么。然后就可以从容地回过头去,对程序中不恰当的部分进行重新设计和重新实现(注释⑩)。在最终得到一套恰当的方案之前,可能需要解决一些不能回避的问题,或者至少解决问题的一个方面。而且一般要多“校订”几次才行(“设计范式”在这里可起到很大的帮助作用。有关它的讨论,请参考本书第16章)。551.12 分析和设计构建一套系统时,“校订”几乎是不可避免的。我们需要不断地对比自己的需求,了解系统是否自己实际所需要的。有时只有实际看到系统,才能意识到自己需要解决一个不同的问题。若认为这种形式的校订必然会发生,那么最好尽快拿出自己的第一个版本,检查它是否自己希望的,使自己的思想不断趋向成熟。反复的“校订”同“递增开发”有关密不可分的关系。递增开发意味着先从系统的核心入手,将其作为一个框架实现,以后要在这个框架的基础上逐渐建立起系统剩余的部分。随后,将准备提供的各种功能(特性)一个接一个地加入其中。这里最考验技巧的是架设起一个能方便扩充所有目标特性的一个框架(对这个问题,大家可参考第16章的论述)。这样做的好处在于一旦令核心框架运作起来,要加入的每一项特性就象它自身内的一个小项目,而非大项目的一部分。此外,开发或维护阶段合成的新特性可以更方便地加入。OOP之所以提供了对递增开发的支持,是由于假如程序设计得好,每一次递增都可以成为完善的对象或者对象组。⑩:这有点类似“快速造型”。此时应着眼于建立一个简单、明了的版本,使自己能对系统有个清楚的把握。再把这个原型扔掉,并正式地构建一个。快速造型最麻烦的一种情况就是人们不将原型扔掉,而是直接在它的基础上建造。如果再加上程序化设计中“结构”的缺乏,就会导致一个混乱的系统,致使维护成本增加。1.12.7 计划的回报如果没有仔细拟定的设计图,当然不可能建起一所房子。如建立的是一所狗舍,尽管设计图可以不必那么详尽,但仍然需要一些草图,以做到心中有数。软件开发则完全不同,它的“设计图”(计划)必须详尽而完备。在很长的一段时间里,人们在他们的开发过程中并没有太多的结构,但那些大型项目很容易就会遭致失败。通过不断的摸索,人们掌握了数量众多的结构和详细资料。但它们的使用却使人提心吊胆在意——似乎需要把自己的大多数时间花在编写文档上,而没有多少时间来编程(经常如此)。我希望这里为大家讲述的一切能提供一条折衷的道路。需要采取一种最适合自己需要(以及习惯)的方法。不管制订出的计划有多么小,但与完全没有计划相比,一些形式的计划会极大改善你的项目。请记住:根据估计,没有计划的50%以上的项目都会失败!Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:10561.13 Java还是C++1.13 Java还是C++Java特别象C++;由此很自然地会得出一个结论:C++似乎会被Java取代。但我对这个逻辑存有一些疑问。无论如何,C++仍有一些特性是Java没有的。而且尽管已有大量保证,声称Java有一天会达到或超过C++的速度。但这个突破迄今仍未实现(尽管Java的速度确实在稳步提高,但仍未达到C++的速度)。此外,许多领域都存在为数众多的C++爱好者,所以我并不认为那种语言很快就会被另一种语言替代(爱好者的力量是容忽视的。比如在我主持的一次“中/高级Java研讨会”上,Allen Holub声称两种最常用的语言是Rexx和COBOL)。我感觉Java强大之处反映在与C++稍有不同的领域。C++是一种绝对不会试图迎合某个模子的语言。特别是它的形式可以变化多端,以解决不同类型的问题。这主要反映在象MicrosoftVisual C++和Borland C++ Builder(我最喜欢这个)那样的工具身上。它们将库、组件模型以及代码生成工具等合成到一起,以开发视窗化的末端用户应用(用于Microsoft Windows操作系统)。但在另一方面,Windows开发人员最常用的是什么呢?是微软的VisualBasic(VB)。当然,我们在这儿暂且不提VB的语法极易使人迷惑的事实——即使一个只有几页长度的程序,产生的代码也十分难于管理。从语言设计的角度看,尽管VB是那样成功和流行,但仍然存在不少的缺点。最好能够同时拥有VB那样的强大功能和易用性,同时不要产生难于管理的代码。而这正是Java最吸引人的地方:作为“下一代的VB”。无论你听到这种主张后有什么感觉,请无论如何都仔细想一想:人们对Java做了大量的工作,使它能方便程序员解决应用级问题(如连网和跨平台UI等),所以它在本质上允许人们创建非常大型和灵活的代码主体。同时,考虑到Java还拥有我迄今为止尚未在其他任何一种语言里见到的最“健壮”的类型检查及错误控制系统,所以Java确实能大大提高我们的编程效率。这一点是勿庸置疑的!但对于自己某个特定的项目,真的可以不假思索地将C++换成Java吗?除了Web程序片,还有两个问题需要考虑。首先,假如要使用大量现有的库(这样肯定可以提高不少的效率),或者已经有了一个坚实的C或C++代码库,那么换成Java后,反映会阻碍开发进度,而不是加快它的速度。但若想从头开始构建自己的所有代码,那么Java的简单易用就能有效地缩短开发时间。 最大的问题是速度。在原始的Java解释器中,解释过的Java会比C慢上20到50倍。尽管经过长时间的发展,这个速度有一定程度的提高,但和C比起来仍然很悬殊。计算机最注重的就是速度;假如在一台计算机上不能明显较快地干活,那么还不如用手做(有人建议在开发期间使用Java,以缩短开发时间。然后用一个工具和支撑库将代码转换成C++,这样可获得更快的执行速度)。 为使Java适用于大多数Web开发项目,关键在于速度上的改善。此时要用到人们称为“刚好及时”(Just-In Time,或JIT)的编译器,甚至考虑更低级的代码编译器(写作本书时,也有两款问世)。当然,低级代码编译器会使编译好的程序不能跨平台执行,但同时也带来了速度上的提升。这个速度甚至接近C和C++。而且Java中的程序交叉编译应当比C和C++中简单得多(理论上只需重编译即可,但实际仍较难实现;其他语言也曾作出类似的保证)。571.13 Java还是C++在本书附录,大家可找到与Java/C++比较.对Java现状的观察以及编码规则有关的内容。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:1058第2章 一切都是对象第2章 一切都是对象“尽管以C++为基础,但Java是一种更纯粹的面向对象程序设计语言”。无论C++还是Java都属于杂合语言。但在Java中,设计者觉得这种杂合并不象在C++里那么重要。杂合语言允许采用多种编程风格;之所以说C++是一种杂合语言,是因为它支持与C语言的向后兼容能力。由于C++是C的一个超集,所以包含的许多特性都是后者不具备的,这些特性使C++在某些地方显得过于复杂。Java语言首先便假定了我们只希望进行面向对象的程序设计。也就是说,正式用它设计之前,必须先将自己的思想转入一个面向对象的世界(除非早已习惯了这个世界的思维方式)。只有做好这个准备工作,与其他OOP语言相比,才能体会到Java的易学易用。在本章,我们将探讨Java程序的基本组件,并体会为什么说Java乃至Java程序内的一切都是对象。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:10592.1 用句柄操纵对象2.1 用句柄操纵对象每种编程语言都有自己的数据处理方式。有些时候,程序员必须时刻留意准备处理的是什么类型。您曾利用一些特殊语法直接操作过对象,或处理过一些间接表示的对象吗(C或C++里的指针)?所有这些在Java里都得到了简化,任何东西都可看作对象。因此,我们可采用一种统一的语法,任何地方均可照搬不误。但要注意,尽管将一切都“看作”对象,但操纵的标识符实际是指向一个对象的“句柄”(Handle)。在其他Java参考书里,还可看到有的人将其称作一个“引用”,甚至一个“指针”。可将这一情形想象成用遥控板(句柄)操纵电视机(对象)。只要握住这个遥控板,就相当于掌握了与电视机连接的通道。但一旦需要“换频道”或者“关小声音”,我们实际操纵的是遥控板(句柄),再由遥控板自己操纵电视机(对象)。如果要在房间里四处走走,并想保持对电视机的控制,那么手上拿着的是遥控板,而非电视机。此外,即使没有电视机,遥控板亦可独立存在。也就是说,只是由于拥有一个句柄,并不表示必须有一个对象同它连接。所以如果想容纳一个词或句子,可创建一个String句柄:String s;但这里创建的只是句柄,并不是对象。若此时向s发送一条消息,就会获得一个错误(运行期)。这是由于s实际并未与任何东西连接(即“没有电视机”)。因此,一种更安全的做法是:创建一个句柄时,记住无论如何都进行初始化:String s = "asdf";然而,这里采用的是一种特殊类型:字串可用加引号的文字初始化。通常,必须为对象使用一种更通用的初始化类型。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:10602.2 所有对象都必须创建2.2 所有对象都必须创建创建句柄时,我们希望它同一个新对象连接。通常用new关键字达到这一目的。new的意思是:“把我变成这些对象的一种新类型”。所以在上面的例子中,可以说:String s = new String("asdf");它不仅指出“将我变成一个新字串”,也通过提供一个初始字串,指出了“如何生成这个新字串”。 当然,字串(String)并非唯一的类型。Java配套提供了数量众多的现成类型。对我们来讲,最重要的就是记住能自行创建类型。事实上,这应是Java程序设计的一项基本操作,是继续本书后余部分学习的基础。2.2.1 保存到什么地方程序运行时,我们最好对数据保存到什么地方做到心中有数。特别要注意的是内存的分配。有六个地方都可以保存数据:(1) 寄存器。这是最快的保存区域,因为它位于和其他所有保存方式不同的地方:处理器内部。然而,寄存器的数量十分有限,所以寄存器是根据需要由编译器分配。我们对此没有直接的控制权,也不可能在自己的程序里找到寄存器存在的任何踪迹。(2) 堆栈。驻留于常规RAM(随机访问存储器)区域,但可通过它的“堆栈指针”获得处理的直接支持。堆栈指针若向下移,会创建新的内存;若向上移,则会释放那些内存。这是一种特别快、特别有效的数据保存方式,仅次于寄存器。创建程序时,Java编译器必须准确地知道堆栈内保存的所有数据的“长度”以及“存在时间”。这是由于它必须生成相应的代码,以便向上和向下移动指针。这一限制无疑影响了程序的灵活性,所以尽管有些Java数据要保存在堆栈里——特别是对象句柄,但Java对象并不放到其中。(3) 堆。一种常规用途的内存池(也在RAM区域),其中保存了Java对象。和堆栈不同,“内存堆”或“堆”(Heap)最吸引人的地方在于编译器不必知道要从堆里分配多少存储空间,也不必知道存储的数据要在堆里停留多长的时间。因此,用堆保存数据时会得到更大的灵活性。要求创建一个对象时,只需用new命令编制相关的代码即可。执行这些代码时,会在堆里自动进行数据的保存。当然,为达到这种灵活性,必然会付出一定的代价:在堆里分配存储空间时会花掉更长的时间!(4) 静态存储。这儿的“静态”(Static)是指“位于固定位置”(尽管也在RAM里)。程序运行期间,静态存储的数据将随时等候调用。可用static关键字指出一个对象的特定元素是静态的。但Java对象本身永远都不会置入静态存储空间。(5) 常数存储。常数值通常直接置于程序代码内部。这样做是安全的,因为它们永远都不会改变。有的常数需要严格地保护,所以可考虑将它们置入只读存储器(ROM)。612.2 所有对象都必须创建(6) 非RAM存储。若数据完全独立于一个程序之外,则程序不运行时仍可存在,并在程序的控制范围之外。其中两个最主要的例子便是“流式对象”和“固定对象”。对于流式对象,对象会变成字节流,通常会发给另一台机器。而对于固定对象,对象保存在磁盘中。即使程序中止运行,它们仍可保持自己的状态不变。对于这些类型的数据存储,一个特别有用的技巧就是它们能存在于其他媒体中。一旦需要,甚至能将它们恢复成普通的、基于RAM的对象。Java1.1提供了对Lightweight persistence的支持。未来的版本甚至可能提供更完整的方案。2.2.2 特殊情况:主要类型有一系列类需特别对待;可将它们想象成“基本”、“主要”或者“主”(Primitive)类型,进行程序设计时要频繁用到它们。之所以要特别对待,是由于用new创建对象(特别是小的、简单的变量)并不是非常有效,因为new将对象置于“堆”里。对于这些类型,Java采纳了与C和C++相同的方法。也就是说,不是用new创建变量,而是创建一个并非句柄的“自动”变量。这个变量容纳了具体的值,并置于堆栈中,能够更高效地存取。Java决定了每种主要类型的大小。就象在大多数语言里那样,这些大小并不随着机器结构的变化而变化。这种大小的不可更改正是Java程序具有很强移植能力的原因之一。主类型大小最小值最大值封装器类型boolean1-bit––Booleanchar16-bitUnicode 0Unicode 216- 1Characterbyte8-bit-128+127Byte[11]short16-bit-215+215 – 1Short1int32-bit-231+231 – 1Integerlong64-bit-263+263 – 1Longfloat32-bitIEEE754IEEE754Floatdouble64-bitIEEE754IEEE754Doublevoid–––Void1①:到Java 1.1才有,1.0版没有。数值类型全都是有符号(正负号)的,所以不必费劲寻找没有符号的类型。 主数据类型也拥有自己的“封装器”(wrapper)类。这意味着假如想让堆内一个非主要对象表示那个主类型,就要使用对应的封装器。例如:char c = 'x';Character C = new Character('c');也可以直接使用:622.2 所有对象都必须创建Character C = new Character('x');这样做的原因将在以后的章节里解释。1. 高精度数字Java 1.1增加了两个类,用于进行高精度的计算:BigInteger和BigDecimal。尽管它们大致可以划分为“封装器”类型,但两者都没有对应的“主类型”。这两个类都有自己特殊的“方法”,对应于我们针对主类型执行的操作。也就是说,能对int或float做的事情,对BigInteger和BigDecimal一样可以做。只是必须使用方法调用,不能使用运算符。此外,由于牵涉更多,所以运算速度会慢一些。我们牺牲了速度,但换来了精度。BigInteger支持任意精度的整数。也就是说,我们可精确表示任意大小的整数值,同时在运算过程中不会丢失任何信息。 BigDecimal支持任意精度的定点数字。例如,可用它进行精确的币值计算。至于调用这两个类时可选用的构建器和方法,请自行参考联机帮助文档。2.2.3 Java的数组几乎所有程序设计语言都支持数组。在C和C++里使用数组是非常危险的,因为那些数组只是内存块。若程序访问自己内存块以外的数组,或者在初始化之前使用内存(属于常规编程错误),会产生不可预测的后果(注释②)。②:在C++里,应尽量不要使用数组,换用标准模板库(Standard TemplateLibrary)里更安全的容器。Java的一项主要设计目标就是安全性。所以在C和C++里困扰程序员的许多问题都未在Java里重复。一个Java可以保证被初始化,而且不可在它的范围之外访问。由于系统自动进行范围检查,所以必然要付出一些代价:针对每个数组,以及在运行期间对索引的校验,都会造成少量的内存开销。但由此换回的是更高的安全性,以及更高的工作效率。为此付出少许代价是值得的。创建对象数组时,实际创建的是一个句柄数组。而且每个句柄都会自动初始化成一个特殊值,并带有自己的关键字:null(空)。一旦Java看到null,就知道该句柄并未指向一个对象。正式使用前,必须为每个句柄都分配一个对象。若试图使用依然为null的一个句柄,就会在运行期报告问题。因此,典型的数组错误在Java里就得到了避免。也可以创建主类型数组。同样地,编译器能够担保对它的初始化,因为会将那个数组的内存划分成零。数组问题将在以后的章节里详细讨论。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:10632.2 所有对象都必须创建642.3 绝对不要清除对象2.3 绝对不要清除对象在大多数程序设计语言中,变量的“存在时间”(Lifetime)一直是程序员需要着重考虑的问题。变量应持续多长的时间?如果想清除它,那么何时进行?在变量存在时间上纠缠不清会造成大量的程序错误。在下面的小节里,将阐示Java如何帮助我们完成所有清除工作,从而极大了简化了这个问题。2.3.1 作用域大多数程序设计语言都提供了“作用域”(Scope)的概念。对于在作用域里定义的名字,作用域同时决定了它的“可见性”以及“存在时间”。在C,C++和Java里,作用域是由花括号的位置决定的。参考下面这个例子:{int x = 12;/* only x available */{int q = 96;/* both x & q available */}/* only x available *//* q “out of scope” */}作为在作用域里定义的一个变量,它只有在那个作用域结束之前才可使用。在上面的例子中,缩进排版使Java代码更易辨读。由于Java是一种形式自由的语言,所以额外的空格、制表位以及回车都不会对结果程序造成影响。注意尽管在C和C++里是合法的,但在Java里不能象下面这样书写代码:{int x = 12;{int x = 96; /* illegal */}}编译器会认为变量x已被定义。所以C和C++能将一个变量“隐藏”在一个更大的作用域里。但这种做法在Java里是不允许的,因为Java的设计者认为这样做使程序产生了混淆。2.3.2 对象的作用域652.3 绝对不要清除对象Java对象不具备与主类型一样的存在时间。用new关键字创建一个Java对象的时候,它会超出作用域的范围之外。所以假若使用下面这段代码:{String s = new String("a string");} /* 作用域的终点 */那么句柄s会在作用域的终点处消失。然而,s指向的String对象依然占据着内存空间。在上面这段代码里,我们没有办法访问对象,因为指向它的唯一一个句柄已超出了作用域的边界。在后面的章节里,大家还会继续学习如何在程序运行期间传递和复制对象句柄。这样造成的结果便是:对于用new创建的对象,只要我们愿意,它们就会一直保留下去。这个编程问题在C和C++里特别突出。看来在C++里遇到的麻烦最大:由于不能从语言获得任何帮助,所以在需要对象的时候,根本无法确定它们是否可用。而且更麻烦的是,在C++里,一旦工作完成,必须保证将对象清除。这样便带来了一个有趣的问题。假如Java让对象依然故我,怎样才能防止它们大量充斥内存,并最终造成程序的“凝固”呢。在C++里,这个问题最令程序员头痛。但Java以后,情况却发生了改观。Java有一个特别的“垃圾收集器”,它会查找用new创建的所有对象,并辨别其中哪些不再被引用。随后,它会自动释放由那些闲置对象占据的内存,以便能由新对象使用。这意味着我们根本不必操心内存的回收问题。只需简单地创建对象,一旦不再需要它们,它们就会自动离去。这样做可防止在C++里很常见的一个编程问题:由于程序员忘记释放内存造成的“内存溢出”。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:10662.4 新建数据类型:类2.4 新建数据类型:类2.4 新建数据类型:类如果说一切东西都是对象,那么用什么决定一个“类”(Class)的外观与行为呢?换句话说,是什么建立起了一个对象的“类型”(Type)呢?大家可能猜想有一个名为“type”的关键字。但从历史看来,大多数面向对象的语言都用关键字“class”表达这样一个意思:“我准备告诉你对象一种新类型的外观”。class关键字太常用了,以至于本书许多地方并没有用粗体字或双引号加以强调。在这个关键字的后面,应该跟随新数据类型的名称。例如:class ATypeName {/*类主体置于这里}这样就引入了一种新类型,接下来便可用new创建这种类型的一个新对象:ATypeName a = new ATypeName();在ATypeName里,类主体只由一条注释构成(星号和斜杠以及其中的内容,本章后面还会详细讲述),所以并不能对它做太多的事情。事实上,除非为其定义了某些方法,否则根本不能指示它做任何事情。2.4.1 字段和方法定义一个类时(我们在Java里的全部工作就是定义类、制作那些类的对象以及将消息发给那些对象),可在自己的类里设置两种类型的元素:数据成员(有时也叫“字段”)以及成员函数(通常叫“方法”)。其中,数据成员是一种对象(通过它的句柄与其通信),可以为任何类型。它也可以是主类型(并不是句柄)之一。如果是指向对象的一个句柄,则必须初始化那个句柄,用一种名为“构建器”(第4章会对此详述)的特殊函数将其与一个实际对象连接起来(就象早先看到的那样,使用new关键字)。但若是一种主类型,则可在类定义位置直接初始化(正如后面会看到的那样,句柄亦可在定义位置初始化)。每个对象都为自己的数据成员保有存储空间;数据成员不会在对象之间共享。下面是定义了一些数据成员的类示例:class DataOnly {int i;float f;boolean b;}这个类并没有做任何实质性的事情,但我们可创建一个对象:672.4 新建数据类型:类DataOnly d = new DataOnly();可将值赋给数据成员,但首先必须知道如何引用一个对象的成员。为达到引用对象成员的目的,首先要写上对象句柄的名字,再跟随一个点号(句点),再跟随对象内部成员的名字。即“对象句柄.成员”。例如:d.i = 47;d.f = 1.1f;d.b = false;一个对象也可能包含了另一个对象,而另一个对象里则包含了我们想修改的数据。对于这个问题,只需保持“连接句点”即可。例如:myPlane.leftTank.capacity = 100;除容纳数据之外,DataOnly类再也不能做更多的事情,因为它没有成员函数(方法)。为正确理解工作原理,首先必须知道“自变量”和“返回值”的概念。我们马上就会详加解释。1. 主成员的默认值若某个主数据类型属于一个类成员,那么即使不明确(显式)进行初始化,也可以保证它们获得一个默认值。主类型 默认值Boolean falseChar '\u0000'(null)byte (byte)0short (short)0int 0long 0Lfloat 0.0fdouble 0.0d一旦将变量作为类成员使用,就要特别注意由Java分配的默认值。这样做可保证主类型的成员变量肯定得到了初始化(C++不具备这一功能),可有效遏止多种相关的编程错误。然而,这种保证却并不适用于“局部”变量——那些变量并非一个类的字段。所以,假若在一个函数定义中写入下述代码:int x;682.4 新建数据类型:类那么x会得到一些随机值(这与C和C++是一样的),不会自动初始化成零。我们责任是在正式使用x前分配一个适当的值。如果忘记,就会得到一条编译期错误,告诉我们变量可能尚未初始化。这种处理正是Java优于C++的表现之一。许多C++编译器会对变量未初始化发出警告,但在Java里却是错误。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:10692.5 方法、自变量和返回值2.5 方法、自变量和返回值迄今为止,我们一直用“函数”(Function)这个词指代一个已命名的子例程。但在Java里,更常用的一个词却是“方法”(Method),代表“完成某事的途径”。尽管它们表达的实际是同一个意思,但从现在开始,本书将一直使用“方法”,而不是“函数”。Java的“方法”决定了一个对象能够接收的消息。通过本节的学习,大家会知道方法的定义有多么简单!方法的基本组成部分包括名字、自变量、返回类型以及主体。下面便是它最基本的形式:返回类型 方法名( /* 自变量列表*/ ) {/* 方法主体 */}返回类型是指调用方法之后返回的数值类型。显然,方法名的作用是对具体的方法进行标识和引用。自变量列表列出了想传递给方法的信息类型和名称。Java的方法只能作为类的一部分创建。只能针对某个对象调用一个方法(注释③),而且那个对象必须能够执行那个方法调用。若试图为一个对象调用错误的方法,就会在编译期得到一条出错消息。为一个对象调用方法时,需要先列出对象的名字,在后面跟上一个句点,再跟上方法名以及它的参数列表。亦即“对象名.方法名(自变量1,自变量2,自变量3...)。举个例子来说,假设我们有一个方法名叫f(),它没有自变量,返回的是类型为int的一个值。那么,假设有一个名为a的对象,可为其调用方法f(),则代码如下:int x = a.f();返回值的类型必须兼容x的类型。象这样调用一个方法的行动通常叫作“向对象发送一条消息”。在上面的例子中,消息是f(),而对象是a。面向对象的程序设计通常简单地归纳为“向对象发送消息”。③:正如马上就要学到的那样,“静态”方法可针对类调用,毋需一个对象。2.5.1 自变量列表自变量列表规定了我们传送给方法的是什么信息。正如大家或许已猜到的那样,这些信息——如同Java内其他任何东西——采用的都是对象的形式。因此,我们必须在自变量列表里指定要传递的对象类型,以及每个对象的名字。正如在Java其他地方处理对象时一样,我们实际传递的是“句柄”(注释④)。然而,句柄的类型必须正确。倘若希望自变量是一个“字串”,那么传递的必须是一个字串。④:对于前面提及的“特殊”数据类型boolean,char,byte,short,int,long,,float以及double来说是一个例外。但在传递对象时,通常都是指传递指向对象的句柄。702.5 方法、自变量和返回值下面让我们考虑将一个字串作为自变量使用的方法。下面列出的是定义代码,必须将它置于一个类定义里,否则无法编译:int storage(String s) {return s.length() * 2;}这个方法告诉我们需要多少字节才能容纳一个特定字串里的信息(字串里的每个字符都是16位,或者说2个字节、长整数,以便提供对Unicode字符的支持)。自变量的类型为String,而且叫作s。一旦将s传递给方法,就可将它当作其他对象一样处理(可向其发送消息)。在这里,我们调用的是length()方法,它是String的方法之一。该方法返回的是一个字串里的字符数。通过上面的例子,也可以了解return关键字的运用。它主要做两件事情。首先,它意味着“离开方法,我已完工了”。其次,假设方法生成了一个值,则那个值紧接在return语句的后面。在这种情况下,返回值是通过计算表达式“s.length()*2”而产生的。 可按自己的愿望返回任意类型,但倘若不想返回任何东西,就可指示方法返回void(空)。下面列出一些例子。boolean flag() { return true; }float naturalLogBase() { return 2.718; }void nothing() { return; }void nothing2() {}若返回类型为void,则return关键字唯一的作用就是退出方法。所以一旦抵达方法末尾,该关键字便不需要了。可在任何地方从一个方法返回。但假设已指定了一种非void的返回类型,那么无论从何地返回,编译器都会确保我们返回的是正确的类型。到此为止,大家或许已得到了这样的一个印象:一个程序只是一系列对象的集合,它们的方法将其他对象作为自己的自变量使用,而且将消息发给那些对象。这种说法大体正确,但通过以后的学习,大家还会知道如何在一个方法里作出决策,做一些更细致的基层工作。至于这一章,只需理解消息传送就足够了。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:10712.6 构建Java程序2.6 构建Java程序正式构建自己的第一个Java程序前,还有几个问题需要注意。2.6.1 名字的可见性在所有程序设计语言里,一个不可避免的问题是对名字或名称的控制。假设您在程序的某个模块里使用了一个名字,而另一名程序员在另一个模块里使用了相同的名字。此时,如何区分两个名字,并防止两个名字互相冲突呢?这个问题在C语言里特别突出。因为程序未提供很好的名字管理方法。C++的类(即Java类的基础)嵌套使用类里的函数,使其不至于同其他类里的嵌套函数名冲突。然而,C++仍然允许使用全局数据以及全局函数,所以仍然难以避免冲突。为解决这个问题,C++用额外的关键字引入了“命名空间”的概念。由于采用全新的机制,所以Java能完全避免这些问题。为了给一个库生成明确的名字,采用了与Internet域名类似的名字。事实上,Java的设计者鼓励程序员反转使用自己的Internet域名,因为它们肯定是独一无二的。由于我的域名是BruceEckel.com,所以我的实用工具库就可命名为com.bruceeckel.utility.foibles。反转了域名后,可将点号想象成子目录。在Java 1.0和Java 1.1中,域扩展名com,edu,org,net等都约定为大写形式。所以库的样子就变成:COM.bruceeckel.utility.foibles。然而,在Java 1.2的开发过程中,设计者发现这样做会造成一些问题。所以目前的整个软件包都以小写字母为标准。Java的这种特殊机制意味着所有文件都自动存在于自己的命名空间里。而且一个文件里的每个类都自动获得一个独一无二的标识符(当然,一个文件里的类名必须是唯一的)。所以不必学习特殊的语言知识来解决这个问题——语言本身已帮我们照顾到这一点。2.6.2 使用其他组件一旦要在自己的程序里使用一个预先定义好的类,编译器就必须知道如何找到它。当然,这个类可能就在发出调用的那个相同的源码文件里。如果是那种情况,只需简单地使用这个类即可——即使它直到文件的后面仍未得到定义。Java消除了“向前引用”的问题,所以不要关心这些事情。但假若那个类位于其他文件里呢?您或许认为编译器应该足够“联盟”,可以自行发现它。但实情并非如此。假设我们想使用一个具有特定名称的类,但那个类的定义位于多个文件里。或者更糟,假设我们准备写一个程序,但在创建它的时候,却向自己的库加入了一个新类,它与现有某个类的名字发生了冲突。为解决这个问题,必须消除所有潜在的、纠缠不清的情况。为达到这个目的,要用import关键字准确告诉Java编译器我们希望的类是什么。import的作用是指示编译器导入一个“包”——或者说一个“类库”(在其他语言里,可将“库”想象成一系列函数、数据以及类的集合。但请记住,Java的所有代码都必须写入一个类中)。722.6 构建Java程序大多数时候,我们直接采用来自标准Java库的组件(部件)即可,它们是与编译器配套提供的。使用这些组件时,没有必要关心冗长的保留域名;举个例子来说,只需象下面这样写一行代码即可:import java.util.Vector;它的作用是告诉编译器我们想使用Java的Vector类。然而,util包含了数量众多的类,我们有时希望使用其中的几个,同时不想全部明确地声明它们。为达到这个目的,可使用“*”通配符。如下所示:import java.util.*;需导入一系列类时,采用的通常是这个办法。应尽量避免一个一个地导入类。2.6.3 static关键字通常,我们创建类时会指出那个类的对象的外观与行为。除非用new创建那个类的一个对象,否则实际上并未得到任何东西。只有执行了new后,才会正式生成数据存储空间,并可使用相应的方法。但在两种特殊的情形下,上述方法并不堪用。一种情形是只想用一个存储区域来保存一个特定的数据——无论要创建多少个对象,甚至根本不创建对象。另一种情形是我们需要一个特殊的方法,它没有与这个类的任何对象关联。也就是说,即使没有创建对象,也需要一个能调用的方法。为满足这两方面的要求,可使用static(静态)关键字。一旦将什么东西设为static,数据或方法就不会同那个类的任何对象实例联系到一起。所以尽管从未创建那个类的一个对象,仍能调用一个static方法,或访问一些static数据。而在这之前,对于非static数据和方法,我们必须创建一个对象,并用那个对象访问数据或方法。这是由于非static数据和方法必须知道它们操作的具体对象。当然,在正式使用前,由于static方法不需要创建任何对象,所以它们不可简单地调用其他那些成员,同时不引用一个已命名的对象,从而直接访问非static成员或方法(因为非static成员和方法必须同一个特定的对象关联到一起)。 有些面向对象的语言使用了“类数据”和“类方法”这两个术语。它们意味着数据和方法只是为作为一个整体的类而存在的,并不是为那个类的任何特定对象。有时,您会在其他一些Java书刊里发现这样的称呼。为了将数据成员或方法设为static,只需在定义前置和这个关键字即可。例如,下述代码能生成一个static数据成员,并对其初始化:class StaticTest {Static int i = 47;}732.6 构建Java程序现在,尽管我们制作了两个StaticTest对象,但它们仍然只占据StaticTest.i的一个存储空间。这两个对象都共享同样的i。请考察下述代码:StaticTest st1 = new StaticTest();StaticTest st2 = new StaticTest();此时,无论st1.i还是st2.i都有同样的值47,因为它们引用的是同样的内存区域。有两个办法可引用一个static变量。正如上面展示的那样,可通过一个对象命名它,如st2.i。亦可直接用它的类名引用,而这在非静态成员里是行不通的(最好用这个办法引用static变量,因为它强调了那个变量的“静态”本质)。StaticTest.i++;其中,++运算符会使变量增值。此时,无论st1.i还是st2.i的值都是48。类似的逻辑也适用于静态方法。既可象对其他任何方法那样通过一个对象引用静态方法,亦可用特殊的语法格式“类名.方法()”加以引用。静态方法的定义是类似的:class StaticFun {static void incr() { StaticTest.i++; }}从中可看出,StaticFun的方法incr()使静态数据i增值。通过对象,可用典型的方法调用incr():StaticFun sf = new StaticFun();sf.incr();或者,由于incr()是一种静态方法,所以可通过它的类直接调用:StaticFun.incr();尽管是“静态”的,但只要应用于一个数据成员,就会明确改变数据的创建方式(一个类一个成员,以及每个对象一个非静态成员)。若应用于一个方法,就没有那么戏剧化了。对方法来说,static一项重要的用途就是帮助我们在不必创建对象的前提下调用那个方法。正如以后会看到的那样,这一点是至关重要的——特别是在定义程序运行入口方法main()的时候。和其他任何方法一样,static方法也能创建自己类型的命名对象。所以经常把static方法作为一个“领头羊”使用,用它生成一系列自己类型的“实例”。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:742.6 构建Java程序2018-03-13 01:23:10752.7 我们的第一个Java程序2.7 我们的第一个Java程序最后,让我们正式编一个程序(注释⑤)。它能打印出与当前运行的系统有关的资料,并利用了来自Java标准库的System对象的多种方法。注意这里引入了一种额外的注释样式:“//”。它表示到本行结束前的所有内容都是注释:// Property.javaimport java.util.*;public class Property {public static void main(String[] args) {System.out.println(new Date());Properties p = System.getProperties();p.list(System.out);System.out.println("--- Memory Usage:");Runtime rt = Runtime.getRuntime();System.out.println("Total Memory = "+ rt.totalMemory()+ " Free Memory = "+ rt.freeMemory());}}⑤:在某些编程环境里,程序会在屏幕上一切而过,甚至没机会看到结果。可将下面这段代码置于main()的末尾,用它暂停输出:try {Thread.currentThread().sleep(5 * 1000);} catch(InterruptedException e) {}}它的作用是暂停输出5秒钟。这段代码涉及的一些概念要到本书后面才会讲到。所以目前不必深究,只知道它是让程序暂停的一个技巧便可。在每个程序文件的开头,都必须放置一个import语句,导入那个文件的代码里要用到的所有额外的类。注意我们说它们是“额外”的,因为一个特殊的类库会自动导入每个Java文件:java.lang。启动您的Web浏览器,查看由Sun提供的用户文档(如果尚未从http://www.java.sun.com 下载,或用其他方式安装了Java文档,请立即下载)。在packages.html文件里,可找到Java配套提供的所有类库名称。请选择其中的java.lang。在“Class Index”下面,可找到属于那个库的全部类的列表。由于java.lang默认进入每个Java代码文件,所以这些类在任何时候都可直接使用。在这个列表里,可发现System和Runtime,我们在Property.java里用到了它们。java.lang里没有列出Date类,所以必须导入另一个类库才能使用它。如果不清楚一个特定的类在哪个类库里,或者想检视所有的类,可在762.7 我们的第一个Java程序Java用户文档里选择“Class Hierarchy”(类分级结构)。在Web浏览器中,虽然要花不短的时间来建立这个结构,但可清楚找到与Java配套提供的每一个类。随后,可用浏览器的“查找”(Find)功能搜索关键字“Date”。经这样处理后,可发现我们的搜索目标以java.util.Date的形式列出。我们终于知道它位于util库里,所以必须导入java.util.*;否则便不能使用Date。观察packages.html文档最开头的部分(我已将其设为自己的默认起始页),请选择java.lang,再选System。这时可看到System类有几个字段。若选择out,就可知道它是一个static PrintStream对象。由于它是“静态”的,所以不需要我们创建任何东西。out对象肯定是3,所以只需直接用它即可。我们能对这个out对象做的事情由它的类型决定:PrintStream。PrintStream在说明文字中以一个超链接的形式列出,这一点做得非常方便。所以假若单击那个链接,就可看到能够为PrintStream调用的所有方法。方法的数量不少,本书后面会详细介绍。就目前来说,我们感兴趣的只有println()。它的意思是“把我给你的东西打印到控制台,并用一个新行结束”。所以在任何Java程序中,一旦要把某些内容打印到控制台,就可条件反射地写上System.out.println("内容")。类名与文件是一样的。若象现在这样创建一个独立的程序,文件中的一个类必须与文件同名(如果没这样做,编译器会及时作出反应)。类里必须包含一个名为main()的方法,形式如下:public static void main(String[] args) {其中,关键字“public”意味着方法可由外部世界调用(第5章会详细解释)。main()的自变量是包含了String对象的一个数组。args不会在本程序中用到,但需要在这个地方列出,因为它们保存了在命令行调用的自变量。 程序的第一行非常有趣:System.out.println(new Date());请观察它的自变量:创建Date对象唯一的目的就是将它的值发送给println()。一旦这个语句执行完毕,Date就不再需要。随之而来的“垃圾收集器”会发现这一情况,并在任何可能的时候将其回收。事实上,我们没太大的必要关心“清除”的细节。第二行调用了System.getProperties()。若用Web浏览器查看联机用户文档,就可知道getProperties()是System类的一个static方法。由于它是“静态”的,所以不必创建任何对象便可调用该方法。无论是否存在该类的一个对象,static方法随时都可使用。调用getProperties()时,它会将系统属性作为Properties类的一个对象生成(注意Properties是“属性”的意思)。随后的的句柄保存在一个名为p的Properties句柄里。在第三行,大家可看到Properties对象有一个名为list()的方法,它将自己的全部内容都发给一个我们作为自变量传递的PrintStream对象。772.7 我们的第一个Java程序main()的第四和第六行是典型的打印语句。注意为了打印多个String值,用加号(+)分隔它们即可。然而,也要在这里注意一些奇怪的事情。在String对象中使用时,加号并不代表真正的“相加”。处理字串时,我们通常不必考虑“+”的任何特殊含义。但是,Java的String类要受一种名为“运算符过载”的机制的制约。也就是说,只有在随同String对象使用时,加号才会产生与其他任何地方不同的表现。对于字串,它的意思是“连接这两个字串”。但事情到此并未结束。请观察下述语句:System.out.println("Total Memory = "+ rt.totalMemory()+ " Free Memory = "+ rt.freeMemory());其中,totalMemory()和freeMemory()返回的是数值,并非String对象。如果将一个数值“加”到一个字串身上,会发生什么情况呢?同我们一样,编译器也会意识到这个问题,并魔术般地调用一个方法,将那个数值(int,float等等)转换成字串。经这样处理后,它们当然能利用加号“加”到一起。这种“自动类型转换”亦划入“运算符过载”处理的范畴。许多Java著作都在热烈地辩论“运算符过载”(C++的一项特性)是否有用。目前就是反对它的一个好例子!然而,这最多只能算编译器(程序)的问题,而且只是对String对象而言。对于自己编写的任何源代码,都不可能使运算符“过载”。通过为Runtime类调用getRuntime()方法,main()的第五行创建了一个Runtime对象。返回的则是指向一个Runtime对象的句柄。而且,我们不必关心它是一个静态对象,还是由new命令创建的一个对象。这是由于我们不必为清除工作负责,可以大模大样地使用对象。正如显示的那样,Runtime可告诉我们与内存使用有关的信息。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:10782.8 注释和嵌入文档2.8 注释和嵌入文档2.8 注释和嵌入文档Java里有两种类型的注释。第一种是传统的、C语言风格的注释,是从C++继承而来的。这些注释用一个“/*”起头,随后是注释内容,并可跨越多行,最后用一个“/”结束。注意许多程序员在连续注释内容的每一行都用一个 `“”` 开头,所以经常能看到象下面这样的内容:/* 这是* 一段注释,* 它跨越了多个行*/但请记住,进行编译时,/和/之间的所有东西都会被忽略,所以上述注释与下面这段注释并没有什么不同:/* 这是一段注释,它跨越了多个行 */第二种类型的注释也起源于C++。这种注释叫作“单行注释”,以一个“//”起头,表示这一行的所有内容都是注释。这种类型的注释更常用,因为它书写时更方便。没有必要在键盘上寻找“/”,再寻找“*”(只需按同样的键两次),而且不必在注释结尾时加一个结束标记。下面便是这类注释的一个例子:// 这是一条单行注释2.8.1 注释文档对于Java语言,最体贴的一项设计就是它并没有打算让人们为了写程序而写程序——人们也需要考虑程序的文档化问题。对于程序的文档化,最大的问题莫过于对文档的维护。若文档与代码分离,那么每次改变代码后都要改变文档,这无疑会变成相当麻烦的一件事情。解决的方法看起来似乎很简单:将代码同文档“链接”起来。为达到这个目的,最简单的方法是将所有内容都置于同一个文件。然而,为使一切都整齐划一,还必须使用一种特殊的注释语法,以便标记出特殊的文档;另外还需要一个工具,用于提取这些注释,并按有价值的形式将其展现出来。这些都是Java必须做到的。用于提取注释的工具叫作javadoc。它采用了部分来自Java编译器的技术,查找我们置入程序的特殊注释标记。它不仅提取由这些标记指示的信息,也将毗邻注释的类名或方法名提取出来。这样一来,我们就可用最轻的工作量,生成十分专业的程序文档。792.8 注释和嵌入文档javadoc输出的是一个HTML文件,可用自己的Web浏览器查看。该工具允许我们创建和管理单个源文件,并生动生成有用的文档。由于有了jvadoc,所以我们能够用标准的方法创建文档。而且由于它非常方便,所以我们能轻松获得所有Java库的文档。2.8.2 具体语法所有javadoc命令都只能出现于“/**”注释中。但和平常一样,注释结束于一个“*/”。主要通过两种方式来使用javadoc:嵌入的HTML,或使用“文档标记”。其中,“文档标记”(Doctags)是一些以“@”开头的命令,置于注释行的起始处(但前导的“*”会被忽略)。有三种类型的注释文档,它们对应于位于注释后面的元素:类、变量或者方法。也就是说,一个类注释正好位于一个类定义之前;变量注释正好位于变量定义之前;而一个方法定义正好位于一个方法定义的前面。如下面这个简单的例子所示:/** 一个类注释 */public class docTest {/** 一个变量注释 */public int i;/** 一个方法注释 */public void f() {}}注意javadoc只能为public(公共)和protected(受保护)成员处理注释文档。“private”(私有)和“友好”(详见5章)成员的注释会被忽略,我们看不到任何输出(也可以用-private标记包括private成员)。这样做是有道理的,因为只有public和protected成员才可在文件之外使用,这是客户程序员的希望。然而,所有类注释都会包含到输出结果里。上述代码的输出是一个HTML文件,它与其他Java文档具有相同的标准格式。因此,用户会非常熟悉这种格式,可在您设计的类中方便地“漫游”。设计程序时,请务必考虑输入上述代码,用javadoc处理一下,观看最终HTML文件的效果如何。2.8.3 嵌入HTMLjavadoc将HTML命令传递给最终生成的HTML文档。这便使我们能够充分利用HTML的巨大威力。当然,我们的最终动机是格式化代码,不是为了哗众取宠。下面列出一个例子:/*** * System.out.println(new Date());* */亦可象在其他Web文档里那样运用HTML,对普通文本进行格式化,使其更具条理、更加美观:802.8 注释和嵌入文档/*** 您甚至可以插入一个列表:* * 项目一* 项目二* 项目三* */注意在文档注释中,位于一行最开头的星号会被javadoc丢弃。同时丢弃的还有前导空格。javadoc 会对所有内容进行格式化,使其与标准的文档外观相符。不要将或这样的标题当作嵌入HTML使用,因为javadoc会插入自己的标题,我们给出的标题会与之冲撞。所有类型的注释文档——类、变量和方法——都支持嵌入HTML。2.8.4 @see:引用其他类所有三种类型的注释文档都可包含@see标记,它允许我们引用其他类里的文档。对于这个标记,javadoc会生成相应的HTML,将其直接链接到其他文档。格式如下:@see 类名@see 完整类名@see 完整类名#方法名每一格式都会在生成的文档里自动加入一个超链接的“See Also”(参见)条目。注意javadoc不会检查我们指定的超链接,不会验证它们是否有效。2.8.5 类文档标记随同嵌入HTML和@see引用,类文档还可以包括用于版本信息以及作者姓名的标记。类文档亦可用于“接口”目的(本书后面会详细解释)。1. @version格式如下:@version 版本信息其中,“版本信息”代表任何适合作为版本说明的资料。若在javadoc命令行使用了“-version”标记,就会从生成的HTML文档里提取出版本信息。2. @author格式如下:812.8 注释和嵌入文档@author 作者信息其中,“作者信息”包括您的姓名、电子函件地址或者其他任何适宜的资料。若在javadoc命令行使用了“-author”标记,就会专门从生成的HTML文档里提取出作者信息。可为一系列作者使用多个这样的标记,但它们必须连续放置。全部作者信息会一起存入最终HTML代码的单独一个段落里。2.8.6 变量文档标记变量文档只能包括嵌入的HTML以及@see引用。2.8.7 方法文档标记除嵌入HTML和@see引用之外,方法还允许使用针对参数、返回值以及违例的文档标记。1. @param 格式如下: @param 参数名 说明 其中,“参数名”是指参数列表内的标识符,而“说明”代表一些可延续到后续行内的说明文字。一旦遇到一个新文档标记,就认为前一个说明结束。可使用任意数量的说明,每个参数一个。2. @return格式如下:@return 说明其中,“说明”是指返回值的含义。它可延续到后面的行内。3. @exception有关“违例”(Exception)的详细情况,我们会在第9章讲述。简言之,它们是一些特殊的对象,若某个方法失败,就可将它们“扔出”对象。调用一个方法时,尽管只有一个违例对象出现,但一些特殊的方法也许能产生任意数量的、不同类型的违例。所有这些违例都需要说明。所以,违例标记的格式如下:@exception 完整类名 说明其中,“完整类名”明确指定了一个违例类的名字,它是在其他某个地方定义好的。而“说明”(同样可以延续到下面的行)告诉我们为什么这种特殊类型的违例会在方法调用中出现。4. @deprecated这是Java 1.1的新特性。该标记用于指出一些旧功能已由改进过的新功能取代。该标记的作用是建议用户不必再使用一种特定的功能,因为未来改版时可能摒弃这一功能。若将一个方法标记为@deprecated,则使用该方法时会收到编译器的警告。822.8 注释和嵌入文档2.8.8 文档示例下面还是我们的第一个Java程序,只不过已加入了完整的文档注释:92页程序第一行://: Property.java采用了我自己的方法:将一个“:”作为特殊的记号,指出这是包含了源文件名字的一个注释行。最后一行也用这样的一条注释结尾,它标志着源代码清单的结束。这样一来,可将代码从本书的正文中方便地提取出来,并用一个编译器检查。这方面的细节在第17章讲述。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:10832.9 编码样式2.9 编码样式一个非正式的Java编程标准是大写一个类名的首字母。若类名由几个单词构成,那么把它们紧靠到一起(也就是说,不要用下划线来分隔名字)。此外,每个嵌入单词的首字母都采用大写形式。例如:class AllTheColorsOfTheRainbow { // ...}对于其他几乎所有内容:方法、字段(成员变量)以及对象句柄名称,可接受的样式与类样式差不多,只是标识符的第一个字母采用小写。例如:class AllTheColorsOfTheRainbow {int anIntegerRepresentingColors;void changeTheHueOfTheColor(int newHue) {// ...}// ...}当然,要注意用户也必须键入所有这些长名字,而且不能输错。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:10842.10 总结2.10 总结通过本章的学习,大家已接触了足够多的Java编程知识,已知道如何自行编写一个简单的程序。此外,对语言的总体情况以及一些基本思想也有了一定程度的认识。然而,本章所有例子的模式都是单线形式的“这样做,再那样做,然后再做另一些事情”。如果想让程序作出一项选择,又该如何设计呢?例如,“假如这样做的结果是红色,就那样做;如果不是,就做另一些事情”。对于这种基本的编程方法,下一章会详细说明在Java里是如何实现的。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:10852.11 练习2.11 练习(1) 参照本章的第一个例子,创建一个“Hello,World”程序,在屏幕上简单地显示这句话。注意在自己的类里只需一个方法(“main”方法会在程序启动时执行)。记住要把它设为static形式,并置入自变量列表——即使根本不会用到这个列表。用javac编译这个程序,再用java运行它。(2) 写一个程序,打印出从命令行获取的三个自变量。(3) 找出Property.java第二个版本的代码,这是一个简单的注释文档示例。请对文件执行javadoc,并在自己的Web浏览器里观看结果。(4) 以练习(1)的程序为基础,向其中加入注释文档。利用javadoc,将这个注释文档提取为一个HTML文件,并用Web浏览器观看。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:1086第3章 控制程序流程第3章 控制程序流程“就象任何有感知的生物一样,程序必须能操纵自己的世界,在执行过程中作出判断与选择。”在Java里,我们利用运算符操纵对象和数据,并用执行控制语句作出选择。Java是建立在C++基础上的,所以对C和C++程序员来说,对Java这方面的大多数语句和运算符都应是非常熟悉的。当然,Java也进行了自己的一些改进与简化工作。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:10873.1 使用Java运算符3.1 使用Java运算符运算符以一个或多个自变量为基础,可生成一个新值。自变量采用与原始方法调用不同的一种形式,但效果是相同的。根据以前写程序的经验,运算符的常规概念应该不难理解。加号(+)、减号和负号(-)、乘号(*)、除号(/)以及等号(=)的用法与其他所有编程语言都是类似的。所有运算符都能根据自己的运算对象生成一个值。除此以外,一个运算符可改变运算对象的值,这叫作“副作用”(Side Effect)。运算符最常见的用途就是修改自己的运算对象,从而产生副作用。但要注意生成的值亦可由没有副作用的运算符生成。 几乎所有运算符都只能操作“主类型”(Primitives)。唯一的例外是“=”、“==”和“!=”,它们能操作所有对象(也是对象易令人混淆的一个地方)。除此以外,String类支持“+”和“+=”。3.1.1 优先级运算符的优先级决定了存在多个运算符时一个表达式各部分的计算顺序。Java对计算顺序作出了特别的规定。其中,最简单的规则就是乘法和除法在加法和减法之前完成。程序员经常都会忘记其他优先级规则,所以应该用括号明确规定计算顺序。例如:A = X + Y - 2/2 + Z;为上述表达式加上括号后,就有了一个不同的含义。A = X + (Y - 2)/(2 + Z);3.1.2 赋值赋值是用等号运算符(=)进行的。它的意思是“取得右边的值,把它复制到左边”。右边的值可以是任何常数、变量或者表达式,只要能产生一个值就行。但左边的值必须是一个明确的、已命名的变量。也就是说,它必须有一个物理性的空间来保存右边的值。举个例子来说,可将一个常数赋给一个变量(A=4;),但不可将任何东西赋给一个常数(比如不能4=A)。对主数据类型的赋值是非常直接的。由于主类型容纳了实际的值,而且并非指向一个对象的句柄,所以在为其赋值的时候,可将来自一个地方的内容复制到另一个地方。例如,假设为主类型使用“A=B”,那么B处的内容就复制到A。若接着又修改了A,那么B根本不会受这种修改的影响。作为一名程序员,这应成为自己的常识。883.1 使用Java运算符但在为对象“赋值”的时候,情况却发生了变化。对一个对象进行操作时,我们真正操作的是它的句柄。所以倘若“从一个对象到另一个对象”赋值,实际就是将句柄从一个地方复制到另一个地方。这意味着假若为对象使用“C=D”,那么C和D最终都会指向最初只有D才指向的那个对象。下面这个例子将向大家阐示这一点。这里有一些题外话。在后面,大家在代码示例里看到的第一个语句将是“package 03”使用的“package”语句,它代表本书第3章。本书每一章的第一个代码清单都会包含象这样的一个“package”(封装、打包、包裹)语句,它的作用是为那一章剩余的代码建立章节编号。在第17章,大家会看到第3章的所有代码清单(除那些有不同封装名称的以外)都会自动置入一个名为c03的子目录里;第4章的代码置入c04;以此类推。所有这些都是通过第17章展示的CodePackage.java程序实现的;“封装”的基本概念会在第5章进行详尽的解释。就目前来说,大家只需记住象“package 03”这样的形式只是用于为某一章的代码清单建立相应的子目录。为运行程序,必须保证在classpath里包含了我们安装本书源码文件的根目录(那个目录里包含了c02,c03c,c04等等子目录)。 对于Java后续的版本(1.1.4和更高版本),如果您的main()用package语句封装到一个文件里,那么必须在程序名前面指定完整的包裹名称,否则不能运行程序。在这种情况下,命令行是:java c03.Assignment运行位于一个“包裹”里的程序时,随时都要注意这方面的问题。 下面是例子://: Assignment.java// Assignment with objects is a bit trickypackage c03;class Number {int i;}public class Assignment {public static void main(String[] args) {Number n1 = new Number();Number n2 = new Number();n1.i = 9;n2.i = 47;System.out.println("1: n1.i: " + n1.i +", n2.i: " + n2.i);n1 = n2;System.out.println("2: n1.i: " + n1.i +", n2.i: " + n2.i);n1.i = 27;System.out.println("3: n1.i: " + n1.i +", n2.i: " + n2.i);}} ///:~893.1 使用Java运算符Number类非常简单,它的两个实例(n1和n2)是在main()里创建的。每个Number中的i值都赋予了一个不同的值。随后,将n2赋给n1,而且n1发生改变。在许多程序设计语言中,我们都希望n1和n2任何时候都相互独立。但由于我们已赋予了一个句柄,所以下面才是真实的输出:1: n1.i: 9, n2.i: 472: n1.i: 47, n2.i: 473: n1.i: 27, n2.i: 27看来改变n1的同时也改变了n2!这是由于无论n1还是n2都包含了相同的句柄,它指向相同的对象(最初的句柄位于n1内部,指向容纳了值9的一个对象。在赋值过程中,那个句柄实际已经丢失;它的对象会由“垃圾收集器”自动清除)。 这种特殊的现象通常也叫作“别名”,是Java操作对象的一种基本方式。但假若不愿意在这种情况下出现别名,又该怎么操作呢?可放弃赋值,并写入下述代码:n1.i = n2.i;这样便可保留两个独立的对象,而不是将n1和n2绑定到相同的对象。但您很快就会意识到,这样做会使对象内部的字段处理发生混乱,并与标准的面向对象设计准则相悖。由于这并非一个简单的话题,所以留待第12章详细论述,那一章是专门讨论别名的。其时,大家也会注意到对象的赋值会产生一些令人震惊的效果。1. 方法调用中的别名处理将一个对象传递到方法内部时,也会产生别名现象。//: PassObject.java// Passing objects to methods can be a bit trickyclass Letter {char c;}public class PassObject {static void f(Letter y) {y.c = 'z';}public static void main(String[] args) {Letter x = new Letter();x.c = 'a';System.out.println("1: x.c: " + x.c);f(x);System.out.println("2: x.c: " + x.c);}} ///:~903.1 使用Java运算符在许多程序设计语言中,f()方法表面上似乎要在方法的作用域内制作自己的自变量Letter y的一个副本。但同样地,实际传递的是一个句柄。所以下面这个程序行:y.c = 'z';`实际改变的是f()之外的对象。输出结果如下:1: x.c: a2: x.c: z别名和它的对策是非常复杂的一个问题。尽管必须等至第12章才可获得所有答案,但从现在开始就应加以重视,以便提早发现它的缺点。3.1.3 算术运算符Java的基本算术运算符与其他大多数程序设计语言是相同的。其中包括加号(+)、减号(-)、除号(/)、乘号(*)以及模数(%,从整数除法中获得余数)。整数除法会直接砍掉小数,而不是进位。Java也用一种简写形式进行运算,并同时进行赋值操作。这是由等号前的一个运算符标记的,而且对于语言中的所有运算符都是固定的。例如,为了将4加到变量x,并将结果赋给x,可用:x+=4。下面这个例子展示了算术运算符的各种用法:913.1 使用Java运算符//: MathOps.java// Demonstrates the mathematical operatorsimport java.util.*;public class MathOps {// Create a shorthand to save typing:static void prt(String s) {System.out.println(s);}// shorthand to print a string and an int:static void pInt(String s, int i) {prt(s + " = " + i);}// shorthand to print a string and a float:static void pFlt(String s, float f) {prt(s + " = " + f);}public static void main(String[] args) {// Create a random number generator,// seeds with current time by default:Random rand = new Random();int i, j, k;// '%' limits maximum value to 99:j = rand.nextInt() % 100;k = rand.nextInt() % 100;pInt("j",j);pInt("k",k);i = j + k; pInt("j + k", i);i = j - k; pInt("j - k", i);i = k / j; pInt("k / j", i);i = k * j; pInt("k * j", i);i = k % j; pInt("k % j", i);j %= k; pInt("j %= k", j);// Floating-point number tests:float u,v,w;// applies to doubles, toov = rand.nextFloat();w = rand.nextFloat();pFlt("v", v); pFlt("w", w);u = v + w; pFlt("v + w", u);u = v - w; pFlt("v - w", u);u = v * w; pFlt("v * w", u);u = v / w; pFlt("v / w", u);// the following also works for// char, byte, short, int, long,// and double:u += v; pFlt("u += v", u);u -= v; pFlt("u -= v", u);u *= v; pFlt("u *= v", u);u /= v; pFlt("u /= v", u);}} ///:~923.1 使用Java运算符我们注意到的第一件事情就是用于打印(显示)的一些快捷方法:prt()方法打印一个String;pInt()先打印一个String,再打印一个int;而pFlt()先打印一个String,再打印一个float。当然,它们最终都要用System.out.println()结尾。为生成数字,程序首先会创建一个Random(随机)对象。由于自变量是在创建过程中传递的,所以Java将当前时间作为一个“种子值”,由随机数生成器利用。通过Random对象,程序可生成许多不同类型的随机数字。做法很简单,只需调用不同的方法即可:nextInt(),nextLong(),nextFloat()或者nextDouble()。若随同随机数生成器的结果使用,模数运算符(%)可将结果限制到运算对象减1的上限(本例是99)之下。1. 一元加、减运算符一元减号(-)和一元加号(+)与二元加号和减号都是相同的运算符。根据表达式的书写形式,编译器会自动判断使用哪一种。例如下述语句:x = -a;它的含义是显然的。编译器能正确识别下述语句:x = a * -b;但读者会被搞糊涂,所以最好更明确地写成:x = a * (-b);一元减号得到的运算对象的负值。一元加号的含义与一元减号相反,虽然它实际并不做任何事情。3.1.4 自动递增和递减和C类似,Java提供了丰富的快捷运算方式。这些快捷运算可使代码更清爽,更易录入,也更易读者辨读。两种很不错的快捷运算方式是递增和递减运算符(常称作“自动递增”和“自动递减”运算符)。其中,递减运算符是“--”,意为“减少一个单位”;递增运算符是“++”,意为“增加一个单位”。举个例子来说,假设A是一个int(整数)值,则表达式++A就等价于(A = A + 1)。递增和递减运算符结果生成的是变量的值。对每种类型的运算符,都有两个版本可供选用;通常将其称为“前缀版”和“后缀版”。“前递增”表示++运算符位于变量或表达式的前面;而“后递增”表示++运算符位于变量或表达式的后面。类似地,“前递减”意味着--运算符位于变量或表达式的前面;而“后递减”意味着--运算符位933.1 使用Java运算符于变量或表达式的后面。对于前递增和前递减(如++A或--A),会先执行运算,再生成值。而对于后递增和后递减(如A++或A--),会先生成值,再执行运算。下面是一个例子://: AutoInc.java// Demonstrates the ++ and -- operatorspublic class AutoInc {public static void main(String[] args) {int i = 1;prt("i : " + i);prt("++i : " + ++i); // Pre-incrementprt("i++ : " + i++); // Post-incrementprt("i : " + i);prt("--i : " + --i); // Pre-decrementprt("i-- : " + i--); // Post-decrementprt("i : " + i);}static void prt(String s) {System.out.println(s);}} ///:~该程序的输出如下:i : 1++i : 2i++ : 2i : 3--i : 2i-- : 2i : 1从中可以看到,对于前缀形式,我们在执行完运算后才得到值。但对于后缀形式,则是在运算执行之前就得到值。它们是唯一具有“副作用”的运算符(除那些涉及赋值的以外)。也就是说,它们会改变运算对象,而不仅仅是使用自己的值。 递增运算符正是对“C++”这个名字的一种解释,暗示着“超载C的一步”。在早期的一次Java演讲中,Bill Joy(始创人之一)声称“Java=C++--”(C加加减减),意味着Java已去除了C++一些没来由折磨人的地方,形成一种更精简的语言。正如大家会在这本书中学到的那样,Java的许多地方都得到了简化,所以Java的学习比C++更容易。3.1.5 关系运算符关系运算符生成的是一个“布尔”(Boolean)结果。它们评价的是运算对象值之间的关系。若关系是真实的,关系表达式会生成true(真);若关系不真实,则生成false(假)。关系运算符包括小于()、小于或等于(=)、等于(==)以及不等于(!=)。等于和不等于适用于所有内建的数据类型,但其他比较不适用于boolean类型。943.1 使用Java运算符1. 检查对象是否相等关系运算符==和!=也适用于所有对象,但它们的含义通常会使初涉Java领域的人找不到北。下面是一个例子://: Equivalence.javapublic class Equivalence {public static void main(String[] args) {Integer n1 = new Integer(47);Integer n2 = new Integer(47);System.out.println(n1 == n2);System.out.println(n1 != n2);}} ///:~其中,表达式System.out.println(n1 == n2)可打印出内部的布尔比较结果。一般人都会认为输出结果肯定先是true,再是false,因为两个Integer对象都是相同的。但尽管对象的内容相同,句柄却是不同的,而==和!=比较的正好就是对象句柄。所以输出结果实际上先是false,再是true。这自然会使第一次接触的人感到惊奇。若想对比两个对象的实际内容是否相同,又该如何操作呢?此时,必须使用所有对象都适用的特殊方法equals()。但这个方法不适用于“主类型”,那些类型直接使用==和!=即可。下面举例说明如何使用://: EqualsMethod.javapublic class EqualsMethod {public static void main(String[] args) {Integer n1 = new Integer(47);Integer n2 = new Integer(47);System.out.println(n1.equals(n2));}} ///:~正如我们预计的那样,此时得到的结果是true。但事情并未到此结束!假设您创建了自己的类,就象下面这样:953.1 使用Java运算符//: EqualsMethod2.javaclass Value {int i;}public class EqualsMethod2 {public static void main(String[] args) {Value v1 = new Value();Value v2 = new Value();v1.i = v2.i = 100;System.out.println(v1.equals(v2));}} ///:~此时的结果又变回了false!这是由于equals()的默认行为是比较句柄。所以除非在自己的新类中改变了equals(),否则不可能表现出我们希望的行为。不幸的是,要到第7章才会学习如何改变行为。但要注意equals()的这种行为方式同时或许能够避免一些“灾难”性的事件。大多数Java类库都实现了equals(),所以它实际比较的是对象的内容,而非它们的句柄。3.1.6 逻辑运算符逻辑运算符AND(&&)、OR(||)以及NOT(!)能生成一个布尔值(true或false)——以自变量的逻辑关系为基础。下面这个例子向大家展示了如何使用关系和逻辑运算符。963.1 使用Java运算符//: Bool.java// Relational and logical operatorsimport java.util.*;public class Bool {public static void main(String[] args) {Random rand = new Random();int i = rand.nextInt() % 100;int j = rand.nextInt() % 100;prt("i = " + i);prt("j = " + j);prt("i > j is " + (i > j));prt("i < j is " + (i = j is " + (i >= j));prt("i <= j is " + (i <= j));prt("i == j is " + (i == j));prt("i != j is " + (i != j));// Treating an int as a boolean is// not legal Java//! prt("i && j is " + (i && j));//! prt("i || j is " + (i || j));//! prt("!i is " + !i);prt("(i < 10) && (j < 10) is "+ ((i < 10) && (j < 10)) );prt("(i < 10) || (j < 10) is "+ ((i < 10) || (j j is truei = j is truei <= j is falsei == j is falsei != j is true(i < 10) && (j < 10) is false(i < 10) || (j < 10) is true973.1 使用Java运算符注意若在预计为String值的地方使用,布尔值会自动转换成适当的文本形式。在上述程序中,可将对int的定义替换成除boolean以外的其他任何主数据类型。但要注意,对浮点数字的比较是非常严格的。即使一个数字仅在小数部分与另一个数字存在极微小的差异,仍然认为它们是“不相等”的。即使一个数字只比零大一点点(例如2不停地开平方根),它仍然属于“非零”值。1. 短路操作逻辑运算符时,我们会遇到一种名为“短路”的情况。这意味着只有明确得出整个表达式真或假的结论,才会对表达式进行逻辑求值。因此,一个逻辑表达式的所有部分都有可能不进行求值://: ShortCircuit.java// Demonstrates short-circuiting behavior// with logical operators.public class ShortCircuit {static boolean test1(int val) {System.out.println("test1(" + val + ")");System.out.println("result: " + (val < 1));return val < 1;}static boolean test2(int val) {System.out.println("test2(" + val + ")");System.out.println("result: " + (val < 2));return val < 2;}static boolean test3(int val) {System.out.println("test3(" + val + ")");System.out.println("result: " + (val < 3));return val < 3;}public static void main(String[] args) {if(test1(0) && test2(2) && test3(2))System.out.println("expression is true");elseSystem.out.println("expression is false");}} ///:~每次测试都会比较自变量,并返回真或假。它不会显示与准备调用什么有关的资料。测试在下面这个表达式中进行:if(test1(0)) && test2(2) && test3(2))很自然地,你也许认为所有这三个测试都会得以执行。但希望输出结果不至于使你大吃一惊:983.1 使用Java运算符if(test1(0) && test2(2) && test3(2))第一个测试生成一个true结果,所以表达式求值会继续下去。然而,第二个测试产生了一个false结果。由于这意味着整个表达式肯定为false,所以为什么还要继续剩余的表达式呢?这样做只会徒劳无益。事实上,“短路”一词的由来正种因于此。如果一个逻辑表达式的所有部分都不必执行下去,那么潜在的性能提升将是相当可观的。3.1.7 按位运算符按位运算符允许我们操作一个整数主数据类型中的单个“比特”,即二进制位。按位运算符会对两个自变量中对应的位执行布尔代数,并最终生成一个结果。按位运算来源于C语言的低级操作。我们经常都要直接操纵硬件,需要频繁设置硬件寄存器内的二进制位。Java的设计初衷是嵌入电视顶置盒内,所以这种低级操作仍被保留下来了。然而,由于操作系统的进步,现在也许不必过于频繁地进行按位运算。若两个输入位都是1,则按位AND运算符(&)在输出位里生成一个1;否则生成0。若两个输入位里至少有一个是1,则按位OR运算符(|)在输出位里生成一个1;只有在两个输入位都是0的情况下,它才会生成一个0。若两个输入位的某一个是1,但不全都是1,那么按位XOR(^,异或)在输出位里生成一个1。按位NOT(~,也叫作“非”运算符)属于一元运算符;它只对一个自变量进行操作(其他所有运算符都是二元运算符)。按位NOT生成与输入位的相反的值——若输入0,则输出1;输入1,则输出0。按位运算符和逻辑运算符都使用了同样的字符,只是数量不同。因此,我们能方便地记忆各自的含义:由于“位”是非常“小”的,所以按位运算符仅使用了一个字符。按位运算符可与等号(=)联合使用,以便合并运算及赋值:&=,|=和^=都是合法的(由于~是一元运算符,所以不可与=联合使用)。我们将boolean(布尔)类型当作一种“单位”或“单比特”值对待,所以它多少有些独特的地方。我们可执行按位AND,OR和XOR,但不能执行按位NOT(大概是为了避免与逻辑NOT混淆)。对于布尔值,按位运算符具有与逻辑运算符相同的效果,只是它们不会中途“短路”。此外,针对布尔值进行的按位运算为我们新增了一个XOR逻辑运算符,它并未包括在“逻辑”运算符的列表中。在移位表达式中,我们被禁止使用布尔运算,原因将在下面解释。3.1.8 移位运算符移位运算符面向的运算对象也是二进制的“位”。可单独用它们处理整数类型(主类型的一种)。左移位运算符(<>)则将运算符左边的运算对象向右移动运算符右侧指定的位数。“有符号”右移位运算符使用了“符号扩展”:若值为正,则在高位插入0;若值为负,则在高位插入1。Java也添加了一种“无符号”右移位运算符(>>>),它使用了“零扩展”:无论正负,都在高位插入0。这一运算符是C或C++没有的。993.1 使用Java运算符若对char,byte或者short进行移位处理,那么在移位进行之前,它们会自动转换成一个int。只有右侧的5个低位才会用到。这样可防止我们在一个int数里移动不切实际的位数。若对一个long值进行处理,最后得到的结果也是long。此时只会用到右侧的6个低位,防止移动超过long值里现成的位数。但在进行“无符号”右移位时,也可能遇到一个问题。若对byte或short值进行右移位运算,得到的可能不是正确的结果(Java 1.0和Java 1.1特别突出)。它们会自动转换成int类型,并进行右移位。但“零扩展”不会发生,所以在那些情况下会得到-1的结果。可用下面这个例子检测自己的实现方案://: URShift.java// Test of unsigned right shiftpublic class URShift {public static void main(String[] args) {int i = -1;i >>>= 10;System.out.println(i);long l = -1;l >>>= 10;System.out.println(l);short s = -1;s >>>= 10;System.out.println(s);byte b = -1;b >>>= 10;System.out.println(b);}} ///:~移位可与等号(<>=或>>>=)组合使用。此时,运算符左边的值会移动由右边的值指定的位数,再将得到的结果赋回左边的值。下面这个例子向大家阐示了如何应用涉及“按位”操作的所有运算符,以及它们的效果://: BitManipulation.java// Using the bitwise operatorsimport java.util.*;public class BitManipulation {public static void main(String[] args) {Random rand = new Random();int i = rand.nextInt();int j = rand.nextInt();pBinInt("-1", -1);pBinInt("+1", +1);int maxpos = 2147483647;pBinInt("maxpos", maxpos);int maxneg = -2147483648;pBinInt("maxneg", maxneg);pBinInt("i", i);1003.1 使用Java运算符pBinInt("~i", ~i);pBinInt("-i", -i);pBinInt("j", j);pBinInt("i & j", i & j);pBinInt("i | j", i | j);pBinInt("i ^ j", i ^ j);pBinInt("i << 5", i <> 5", i >> 5);pBinInt("(~i) >> 5", (~i) >> 5);pBinInt("i >>> 5", i >>> 5);pBinInt("(~i) >>> 5", (~i) >>> 5);long l = rand.nextLong();long m = rand.nextLong();pBinLong("-1L", -1L);pBinLong("+1L", +1L);long ll = 9223372036854775807L;pBinLong("maxpos", ll);long lln = -9223372036854775808L;pBinLong("maxneg", lln);pBinLong("l", l);pBinLong("~l", ~l);pBinLong("-l", -l);pBinLong("m", m);pBinLong("l & m", l & m);pBinLong("l | m", l | m);pBinLong("l ^ m", l ^ m);pBinLong("l << 5", l <> 5", l >> 5);pBinLong("(~l) >> 5", (~l) >> 5);pBinLong("l >>> 5", l >>> 5);pBinLong("(~l) >>> 5", (~l) >>> 5);}static void pBinInt(String s, int i) {System.out.println(s + ", int: " + i + ", binary: ");System.out.print("");for(int j = 31; j >=0; j--)if(((1 <=0; i--)if(((1L << i) & l) != 0)System.out.print("1");elseSystem.out.print("0");1013.1 使用Java运算符System.out.println();}} ///:~程序末尾调用了两个方法:pBinInt()和pBinLong()。它们分别操作一个int和long值,并用一种二进制格式输出,同时附有简要的说明文字。目前,可暂时忽略它们具体的实现方案。大家要注意的是System.out.print()的使用,而不是System.out.println()。print()方法不会产生一个新行,以便在同一行里罗列多种信息。除展示所有按位运算符针对int和long的效果之外,本例也展示了int和long的最小值、最大值、+1和-1值,使大家能体会它们的情况。注意高位代表正负号:0为正,1为负。下面列出int部分的输出:-1, int: -1, binary:11111111111111111111111111111111+1, int: 1, binary:00000000000000000000000000000001maxpos, int: 2147483647, binary:01111111111111111111111111111111maxneg, int: -2147483648, binary:10000000000000000000000000000000i, int: 59081716, binary:00000011100001011000001111110100~i, int: -59081717, binary:11111100011110100111110000001011-i, int: -59081716, binary:11111100011110100111110000001100j, int: 198850956, binary:00001011110110100011100110001100i & j, int: 58720644, binary:00000011100000000000000110000100i | j, int: 199212028, binary:00001011110111111011101111111100i ^ j, int: 140491384, binary:00001000010111111011101001111000i <> 5, int: 1846303, binary:00000000000111000010110000011111(~i) >> 5, int: -1846304, binary:11111111111000111101001111100000i >>> 5, int: 1846303, binary:00000000000111000010110000011111(~i) >>> 5, int: 132371424, binary:00000111111000111101001111100000数字的二进制形式表现为“有符号2的补值”。1023.1 使用Java运算符3.1.9 三元if-else运算符这种运算符比较罕见,因为它有三个运算对象。但它确实属于运算符的一种,因为它最终也会生成一个值。这与本章后一节要讲述的普通if-else语句是不同的。表达式采取下述形式:布尔表达式 ? 值0:值1若“布尔表达式”的结果为true,就计算“值0”,而且它的结果成为最终由运算符产生的值。但若“布尔表达式”的结果为false,计算的就是“值1”,而且它的结果成为最终由运算符产生的值。当然,也可以换用普通的if-else语句(在后面介绍),但三元运算符更加简洁。尽管C引以为傲的就是它是一种简练的语言,而且三元运算符的引入多半就是为了体现这种高效率的编程,但假若您打算频繁用它,还是要先多作一些思量——它很容易就会产生可读性极差的代码。可将条件运算符用于自己的“副作用”,或用于它生成的值。但通常都应将其用于值,因为那样做可将运算符与if-else明确区别开。下面便是一个例子:static int ternary(int i) {return i < 10 ? i * 100 : i * 10;}可以看出,假设用普通的if-else结构写上述代码,代码量会比上面多出许多。如下所示:static int alternative(int i) {if (i < 10)return i * 100;return i * 10;}但第二种形式更易理解,而且不要求更多的录入。所以在挑选三元运算符时,请务必权衡一下利弊。3.1.10 逗号运算符在C和C++里,逗号不仅作为函数自变量列表的分隔符使用,也作为进行后续计算的一个运算符使用。在Java里需要用到逗号的唯一场所就是for循环,本章稍后会对此详加解释。3.1.11 字串运算符+这个运算符在Java里有一项特殊用途:连接不同的字串。这一点已在前面的例子中展示过了。尽管与+的传统意义不符,但用+来做这件事情仍然是非常自然的。在C++里,这一功能看起来非常不错,所以引入了一项“运算符过载”机制,以便C++程序员为几乎所有运算符增加特殊的含义。但非常不幸,与C++的另外一些限制结合,运算符过载成为一种非常复杂的特1033.1 使用Java运算符性,程序员在设计自己的类时必须对此有周到的考虑。与C++相比,尽管运算符过载在Java里更易实现,但迄今为止仍然认为这一特性过于复杂。所以Java程序员不能象C++程序员那样设计自己的过载运算符。我们注意到运用“String +”时一些有趣的现象。若表达式以一个String起头,那么后续所有运算对象都必须是字串。如下所示:int x = 0, y = 1, z = 2;String sString = "x, y, z ";System.out.println(sString + x + y + z);在这里,Java编译程序会将x,y和z转换成它们的字串形式,而不是先把它们加到一起。然而,如果使用下述语句:System.out.println(x + sString);那么早期版本的Java就会提示出错(以后的版本能将x转换成一个字串)。因此,如果想通过“加号”连接字串(使用Java的早期版本),请务必保证第一个元素是字串(或加上引号的一系列字符,编译能将其识别成一个字串)。3.1.12 运算符常规操作规则使用运算符的一个缺点是括号的运用经常容易搞错。即使对一个表达式如何计算有丝毫不确定的因素,都容易混淆括号的用法。这个问题在Java里仍然存在。 在C和C++中,一个特别常见的错误如下:while(x = y) {//...}程序的意图是测试是否“相等”(==),而不是进行赋值操作。在C和C++中,若y是一个非零值,那么这种赋值的结果肯定是true。这样使可能得到一个无限循环。在Java里,这个表达式的结果并不是布尔值,而编译器期望的是一个布尔值,而且不会从一个int数值中转换得来。所以在编译时,系统就会提示出现错误,有效地阻止我们进一步运行程序。所以这个缺点在Java里永远不会造成更严重的后果。唯一不会得到编译错误的时候是x和y都为布尔值。在这种情况下,x = y属于合法表达式。而在上述情况下,则可能是一个错误。在C和C++里,类似的一个问题是使用按位AND和OR,而不是逻辑AND和OR。按位AND和OR使用两个字符之一(&或|),而逻辑AND和OR使用两个相同的字符(&&或||)。就象“=”和“==”一样,键入一个字符当然要比键入两个简单。在Java里,编译器同样可防止这一点,因为它不允许我们强行使用一种并不属于的类型。3.1.13 造型运算符1043.1 使用Java运算符“造型”(Cast)的作用是“与一个模型匹配”。在适当的时候,Java会将一种数据类型自动转换成另一种。例如,假设我们为浮点变量分配一个整数值,计算机会将int自动转换成float。通过造型,我们可明确设置这种类型的转换,或者在一般没有可能进行的时候强迫它进行。为进行一次造型,要将括号中希望的数据类型(包括所有修改符)置于其他任何值的左侧。下面是一个例子:void casts() {int i = 200;long l = (long)i;long l2 = (long)200;}正如您看到的那样,既可对一个数值进行造型处理,亦可对一个变量进行造型处理。但在这儿展示的两种情况下,造型均是多余的,因为编译器在必要的时候会自动进行int值到long值的转换。当然,仍然可以设置一个造型,提醒自己留意,也使程序更清楚。在其他情况下,造型只有在代码编译时才显出重要性。在C和C++中,造型有时会让人头痛。在Java里,造型则是一种比较安全的操作。但是,若进行一种名为“缩小转换”(Narrowing Conversion)的操作(也就是说,脚本是能容纳更多信息的数据类型,将其转换成容量较小的类型),此时就可能面临信息丢失的危险。此时,编译器会强迫我们进行造型,就好象说:“这可能是一件危险的事情——如果您想让我不顾一切地做,那么对不起,请明确造型。”而对于“放大转换”(Widening conversion),则不必进行明确造型,因为新类型肯定能容纳原来类型的信息,不会造成任何信息的丢失。Java允许我们将任何主类型“造型”为其他任何一种主类型,但布尔值(bollean)要除外,后者根本不允许进行任何造型处理。“类”不允许进行造型。为了将一种类转换成另一种,必须采用特殊的方法(字串是一种特殊的情况,本书后面会讲到将对象造型到一个类型“家族”里;例如,“橡树”可造型为“树”;反之亦然。但对于其他外来类型,如“岩石”,则不能造型为“树”)。1. 字面值最开始的时候,若在一个程序里插入“字面值”(Literal),编译器通常能准确知道要生成什么样的类型。但在有些时候,对于类型却是暧昧不清的。若发生这种情况,必须对编译器加以适当的“指导”。方法是用与字面值关联的字符形式加入一些额外的信息。下面这段代码向大家展示了这些字符。1053.1 使用Java运算符//: Literals.javaclass Literals {char c = 0xffff; // max char hex valuebyte b = 0x7f; // max byte hex valueshort s = 0x7fff; // max short hex valueint i1 = 0x2f; // Hexadecimal (lowercase)int i2 = 0X2F; // Hexadecimal (uppercase)int i3 = 0177; // Octal (leading zero)// Hex and Oct also work with long.long n1 = 200L; // long suffixlong n2 = 200l; // long suffixlong n3 = 200;//! long l6(200); // not allowedfloat f1 = 1;float f2 = 1F; // float suffixfloat f3 = 1f; // float suffixfloat f4 = 1e-45f; // 10 to the powerfloat f5 = 1e+9f; // float suffixdouble d1 = 1d; // double suffixdouble d2 = 1D; // double suffixdouble d3 = 47e47d; // 10 to the power} ///:~十六进制(Base 16)——它适用于所有整数数据类型——用一个前置的0x或0X指示。并在后面跟随采用大写或小写形式的0-9以及a-f。若试图将一个变量初始化成超出自身能力的一个值(无论这个值的数值形式如何),编译器就会向我们报告一条出错消息。注意在上述代码中,最大的十六进制值只会在char,byte以及short身上出现。若超出这一限制,编译器会将值自动变成一个int,并告诉我们需要对这一次赋值进行“缩小造型”。这样一来,我们就可清楚获知自己已超载了边界。八进制(Base 8)是用数字中的一个前置0以及0-7的数位指示的。在C,C++或者Java中,对二进制数字没有相应的“字面”表示方法。字面值后的尾随字符标志着它的类型。若为大写或小写的L,代表long;大写或小写的F,代表float;大写或小写的D,则代表double。指数总是采用一种我们认为很不直观的记号方法:1.39e-47f。在科学与工程学领域,“e”代表自然对数的基数,约等于2.718(Java一种更精确的double值采用Math.E的形式)。它在象“1.39×e的-47次方”这样的指数表达式中使用,意味着“1.39×2.718的-47次方”。然而,自FORTRAN语言发明后,人们自然而然地觉得e代表“10多少次幂”。这种做法显得颇为古怪,因为FORTRAN最初面向的是科学与工程设计领域。理所当然,它的设计者应对这样的混淆概念持谨慎态度(注释①)。但不管怎样,这种特别的表达方法在C,C++以及现在的Java中顽固地保留下来了。所以倘若您习惯将e作为自然对数的基数使用,那么在Java中看到象“1.39e47f”这样的表达式时,请转换您的思维,从程序设计的角度思考它;它真正的含义是“1.39×10的-47次方”。1063.1 使用Java运算符①:John Kirkham这样写道:“我最早于1962年在一部IBM 1620机器上使用FORTRAN II。那时——包括60年代以及70年代的早期,FORTRAN一直都是使用大写字母。之所以会出现这一情况,可能是由于早期的输入设备大多是老式电传打字机,使用5位Baudot码,那种码并不具备小写能力。乘幂表达式中的‘E’也肯定是大写的,所以不会与自然对数的基数‘e’发生冲突,后者必然是小写的。‘E’这个字母的含义其实很简单,就是‘Exponential’的意思,即‘指数’或‘幂数’,代表计算系统的基数——一般都是10。当时,八进制也在程序员中广泛使用。尽管我自己未看到它的使用,但假若我在乘幂表达式中看到一个八进制数字,就会把它认作Base 8。我记得第一次看到用小写‘e’表示指数是在70年代末期。我当时也觉得它极易产生混淆。所以说,这个问题完全是自己‘潜入’FORTRAN里去的,并非一开始就有。如果你真的想使用自然对数的基数,实际有现成的函数可供利用,但它们都是大写的。”注意如果编译器能够正确地识别类型,就不必使用尾随字符。对于下述语句:long n3 = 200;它并不存在含混不清的地方,所以200后面的一个L大可省去。然而,对于下述语句:float f4 = 1e-47f; //10的幂数编译器通常会将指数作为双精度数(double)处理,所以假如没有这个尾随的f,就会收到一条出错提示,告诉我们须用一个“造型”将double转换成float。2. 转型大家会发现假若对主数据类型执行任何算术或按位运算,只要它们“比int小”(即char,byte或者short),那么在正式执行运算之前,那些值会自动转换成int。这样一来,最终生成的值就是int类型。所以只要把一个值赋回较小的类型,就必须使用“造型”。此外,由于是将值赋回给较小的类型,所以可能出现信息丢失的情况)。通常,表达式中最大的数据类型是决定了表达式最终结果大小的那个类型。若将一个float值与一个double值相乘,结果就是double;如将一个int和一个long值相加,则结果为long。3.1.14 Java没有“sizeof”在C和C++中,sizeof()运算符能满足我们的一项特殊需要:获知为数据项目分配的字符数量。在C和C++中,size()最常见的一种应用就是“移植”。不同的数据在不同的机器上可能有不同的大小,所以在进行一些对大小敏感的运算时,程序员必须对那些类型有多大做到心中有数。例如,一台计算机可用32位来保存整数,而另一台只用16位保存。显然,在第一台机器中,程序可保存更大的值。正如您可能已经想到的那样,移植是令C和C++程序员颇为头痛的一个问题。 Java不需要sizeof()运算符来满足这方面的需要,因为所有数据类型在所有机器的大小都是相同的。我们不必考虑移植问题——Java本身就是一种“与平台无关”的语言。3.1.15 复习计算顺序1073.1 使用Java运算符在我举办的一次培训班中,有人抱怨运算符的优先顺序太难记了。一名学生推荐用一句话来帮助记忆:“Ulcer Addicts Really Like C A lot”,即“溃疡患者特别喜欢(维生素)C”。助记词运算符类型Ulcer运算符Unary+ - ++ – [[ rest...]]AddictsArithmetic (andshift)* / % + - <>ReallyRelational> = B ? X : Y= (and compound assignment like*=)当然,对于移位和按位运算符,上表并不是完美的助记方法;但对于其他运算来说,它确实很管用。3.1.16 运算符总结 下面这个例子向大家展示了如何随同特定的运算符使用主数据类型。从根本上说,它是同一个例子反反复复地执行,只是使用了不同的主数据类型。文件编译时不会报错,因为那些会导致错误的行已用//!变成了注释内容。//: AllOps.java// Tests all the operators on all the// primitive data types to show which// ones are accepted by the Java compiler.class AllOps {// To accept the results of a boolean test:void f(boolean b) {}void boolTest(boolean x, boolean y) {// Arithmetic operators://! x = x * y;//! x = x / y;//! x = x % y;//! x = x + y;//! x = x - y;//! x++;//! x--;//! x = +y;//! x = -y;// Relational and logical://! f(x > y);//! f(x >= y);//! f(x < y);//! f(x <= y);f(x == y);1083.1 使用Java运算符f(x != y);f(!y);x = x && y;x = x || y;// Bitwise operators://! x = ~y;x = x & y;x = x | y;x = x ^ y;//! x = x <> 1;//! x = x >>> 1;// Compound assignment://! x += y;//! x -= y;//! x *= y;//! x /= y;//! x %= y;//! x <>= 1;//! x >>>= 1;x &= y;x ^= y;x |= y;// Casting://! char c = (char)x;//! byte B = (byte)x;//! short s = (short)x;//! int i = (int)x;//! long l = (long)x;//! float f = (float)x;//! double d = (double)x;}void charTest(char x, char y) {// Arithmetic operators:x = (char)(x * y);x = (char)(x / y);x = (char)(x % y);x = (char)(x + y);x = (char)(x - y);x++;x--;x = (char)+y;x = (char)-y;// Relational and logical:f(x > y);f(x >= y);f(x < y);f(x <= y);f(x == y);f(x != y);//! f(!x);//! f(x && y);1093.1 使用Java运算符//! f(x || y);// Bitwise operators:x= (char)~y;x = (char)(x & y);x= (char)(x | y);x = (char)(x ^ y);x = (char)(x <> 1);x = (char)(x >>> 1);// Compound assignment:x += y;x -= y;x *= y;x /= y;x %= y;x <>= 1;x >>>= 1;x &= y;x ^= y;x |= y;// Casting://! boolean b = (boolean)x;byte B = (byte)x;short s = (short)x;int i = (int)x;long l = (long)x;float f = (float)x;double d = (double)x;}void byteTest(byte x, byte y) {// Arithmetic operators:x = (byte)(x* y);x = (byte)(x / y);x = (byte)(x % y);x = (byte)(x + y);x = (byte)(x - y);x++;x--;x = (byte)+ y;x = (byte)- y;// Relational and logical:f(x > y);f(x >= y);f(x < y);f(x <= y);f(x == y);f(x != y);//! f(!x);//! f(x && y);//! f(x || y);// Bitwise operators:x = (byte)~y;1103.1 使用Java运算符x = (byte)(x & y);x = (byte)(x | y);x = (byte)(x ^ y);x = (byte)(x <> 1);x = (byte)(x >>> 1);// Compound assignment:x += y;x -= y;x *= y;x /= y;x %= y;x <>= 1;x >>>= 1;x &= y;x ^= y;x |= y;// Casting://! boolean b = (boolean)x;char c = (char)x;short s = (short)x;int i = (int)x;long l = (long)x;float f = (float)x;double d = (double)x;}void shortTest(short x, short y) {// Arithmetic operators:x = (short)(x * y);x = (short)(x / y);x = (short)(x % y);x = (short)(x + y);x = (short)(x - y);x++;x--;x = (short)+y;x = (short)-y;// Relational and logical:f(x > y);f(x >= y);f(x < y);f(x <= y);f(x == y);f(x != y);//! f(!x);//! f(x && y);//! f(x || y);// Bitwise operators:x = (short)~y;x = (short)(x & y);x = (short)(x | y);x = (short)(x ^ y);1113.1 使用Java运算符x = (short)(x <> 1);x = (short)(x >>> 1);// Compound assignment:x += y;x -= y;x *= y;x /= y;x %= y;x <>= 1;x >>>= 1;x &= y;x ^= y;x |= y;// Casting://! boolean b = (boolean)x;char c = (char)x;byte B = (byte)x;int i = (int)x;long l = (long)x;float f = (float)x;double d = (double)x;}void intTest(int x, int y) {// Arithmetic operators:x = x * y;x = x / y;x = x % y;x = x + y;x = x - y;x++;x--;x = +y;x = -y;// Relational and logical:f(x > y);f(x >= y);f(x < y);f(x <= y);f(x == y);f(x != y);//! f(!x);//! f(x && y);//! f(x || y);// Bitwise operators:x = ~y;x = x & y;x = x | y;x = x ^ y;x = x <> 1;x = x >>> 1;1123.1 使用Java运算符// Compound assignment:x += y;x -= y;x *= y;x /= y;x %= y;x <>= 1;x >>>= 1;x &= y;x ^= y;x |= y;// Casting://! boolean b = (boolean)x;char c = (char)x;byte B = (byte)x;short s = (short)x;long l = (long)x;float f = (float)x;double d = (double)x;}void longTest(long x, long y) {// Arithmetic operators:x = x * y;x = x / y;x = x % y;x = x + y;x = x - y;x++;x--;x = +y;x = -y;// Relational and logical:f(x > y);f(x >= y);f(x < y);f(x <= y);f(x == y);f(x != y);//! f(!x);//! f(x && y);//! f(x || y);// Bitwise operators:x = ~y;x = x & y;x = x | y;x = x ^ y;x = x <> 1;x = x >>> 1;// Compound assignment:x += y;x -= y;1133.1 使用Java运算符x *= y;x /= y;x %= y;x <>= 1;x >>>= 1;x &= y;x ^= y;x |= y;// Casting://! boolean b = (boolean)x;char c = (char)x;byte B = (byte)x;short s = (short)x;int i = (int)x;float f = (float)x;double d = (double)x;}void floatTest(float x, float y) {// Arithmetic operators:x = x * y;x = x / y;x = x % y;x = x + y;x = x - y;x++;x--;x = +y;x = -y;// Relational and logical:f(x > y);f(x >= y);f(x < y);f(x <= y);f(x == y);f(x != y);//! f(!x);//! f(x && y);//! f(x || y);// Bitwise operators://! x = ~y;//! x = x & y;//! x = x | y;//! x = x ^ y;//! x = x <> 1;//! x = x >>> 1;// Compound assignment:x += y;x -= y;x *= y;x /= y;x %= y;1143.1 使用Java运算符//! x <>= 1;//! x >>>= 1;//! x &= y;//! x ^= y;//! x |= y;// Casting://! boolean b = (boolean)x;char c = (char)x;byte B = (byte)x;short s = (short)x;int i = (int)x;long l = (long)x;double d = (double)x;}void doubleTest(double x, double y) {// Arithmetic operators:x = x * y;x = x / y;x = x % y;x = x + y;x = x - y;x++;x--;x = +y;x = -y;// Relational and logical:f(x > y);f(x >= y);f(x < y);f(x <= y);f(x == y);f(x != y);//! f(!x);//! f(x && y);//! f(x || y);// Bitwise operators://! x = ~y;//! x = x & y;//! x = x | y;//! x = x ^ y;//! x = x <> 1;//! x = x >>> 1;// Compound assignment:x += y;x -= y;x *= y;x /= y;x %= y;//! x <>= 1;//! x >>>= 1;1153.1 使用Java运算符//! x &= y;//! x ^= y;//! x |= y;// Casting://! boolean b = (boolean)x;char c = (char)x;byte B = (byte)x;short s = (short)x;int i = (int)x;long l = (long)x;float f = (float)x;}} ///:~注意布尔值(boolean)的能力非常有限。我们只能为其赋予true和false值。而且可测试它为真还是为假,但不可为它们再添加布尔值,或进行其他其他任何类型运算。 在char,byte和short中,我们可看到算术运算符的“转型”效果。对这些类型的任何一个进行算术运算,都会获得一个int结果。必须将其明确“造型”回原来的类型(缩小转换会造成信息的丢失),以便将值赋回那个类型。但对于int值,却不必进行造型处理,因为所有数据都已经属于int类型。然而,不要放松警惕,认为一切事情都是安全的。如果对两个足够大的int值执行乘法运算,结果值就会溢出。下面这个例子向大家展示了这一点://: Overflow.java// Surprise! Java lets you overflow.public class Overflow {public static void main(String[] args) {int big = 0x7fffffff; // max int valueprt("big = " + big);int bigger = big * 4;prt("bigger = " + bigger);}static void prt(String s) {System.out.println(s);}} ///:~输出结果如下:big = 2147483647bigger = -4而且不会从编译器那里收到出错提示,运行时也不会出现异常反应。爪哇咖啡(Java)确实是很好的东西,但却没有“那么”好! 对于char,byte或者short,混合赋值并不需要造型。即使它们执行转型操作,也会获得与直接算术运算相同的结果。而在另一方面,将造型略去可使代码显得更加简练。1163.1 使用Java运算符大家可以看到,除boolean以外,任何一种主类型都可通过造型变为其他主类型。同样地,当造型成一种较小的类型时,必须留意“缩小转换”的后果。否则会在造型过程中不知不觉地丢失信息。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:101173.2 执行控制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-elseif-else语句或许是控制程序流程最基本的形式。其中的else是可选的,所以可按下述两种形式来使用if:if(布尔表达式)语句或者if(布尔表达式)语句else语句条件必须产生一个布尔结果。“语句”要么是用分号结尾的一个简单语句,要么是一个复合语句——封闭在括号内的一组简单语句。在本书任何地方,只要提及“语句”这个词,就有可能包括简单或复合语句。作为if-else的一个例子,下面这个test()方法可告诉我们猜测的一个数字位于目标数字之上、之下还是相等:1183.2 执行控制static int test(int testval) {int result = 0;if(testval > target)result = -1;else if(testval target)return -1;if(testval < target)return +1;return 0; // match}不必加上else,因为方法在遇到return后便不再继续。3.2.3 反复while,do-while和for控制着循环,有时将其划分为“反复语句”。除非用于控制反复的布尔表达式得到“假”的结果,否则语句会重复执行下去。while循环的格式如下:while(布尔表达式)语句在循环刚开始时,会计算一次“布尔表达式”的值。而对于后来每一次额外的循环,都会在开始前重新计算一次。 下面这个简单的例子可产生随机数,直到符合特定的条件为止:1193.2 执行控制//: WhileTest.java// Demonstrates the while looppublic 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-whiledo-while的格式如下:do语句while(布尔表达式)while和do-while唯一的区别就是do-while肯定会至少执行一次;也就是说,至少会将其中的语句“过一遍”——即便表达式第一次便计算为false。而在while循环结构中,若条件第一次就为false,那么其中的语句根本不会执行。在实际应用中,while比do-while更常用一些。3.2.5 forfor循环在第一次反复之前要进行初始化。随后,它会进行条件测试,而且在每一次反复的时候,进行某种形式的“步进”(Stepping)。for循环的形式如下:for(初始表达式; 布尔表达式; 步进)语句无论初始表达式,布尔表达式,还是步进,都可以置空。每次反复前,都要测试一下布尔表达式。若获得的结果是false,就会继续执行紧跟在for语句后面的那行代码。在每次循环的末尾,会计算一次步进。 for循环通常用于执行“计数”任务:1203.2 执行控制//: 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 screenSystem.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循环的控制表达式。在控制表达式的初始化和步进控制部分,我们可使用一系列由逗号分隔的语句。而且那些语句均会独立执行。前面的例子已运用了这种能力,下面则是另一个例子:1213.2 执行控制//: CommaOperator.javapublic 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= 11i= 2 j= 4i= 3 j= 6i= 4 j= 8大家可以看到,无论在初始化还是在步进部分,语句都是顺序执行的。此外,尽管初始化部分可设置任意数量的定义,但都属于同一类型。3.2.6 中断和继续在任何循环语句的主体部分,亦可用break和continue控制循环的流程。其中,break用于强行退出循环,不执行循环中剩余的语句。而continue则停止执行当前的反复,然后退回循环起始和,开始新的反复。 下面这个程序向大家展示了break和continue在for和while循环中的例子:1223.2 执行控制//: BreakAndContinue.java// Demonstrates break and continue keywordspublic class BreakAndContinue {public static void main(String[] args) {for(int i = 0; i < 100; i++) {if(i == 74) break; // Out of for loopif(i % 9 != 0) continue; // Next iterationSystem.out.println(i);}int i = 0;// An "infinite loop":while(true) {i++;int j = i * 27;if(j == 1269) break; // Out of loopif(i % 10 != 0) continue; // Top of loopSystem.out.println(i);}}} ///:~在这个for循环中,i的值永远不会到达100。因为一旦i到达74,break语句就会中断循环。通常,只有在不知道中断条件何时满足时,才需象这样使用break。只要i不能被9整除,continue语句会使程序流程返回循环的最开头执行(所以使i值递增)。如果能够整除,则将值显示出来。 第二部分向大家揭示了一个“无限循环”的情况。然而,循环内部有一个break语句,可中止循环。除此以外,大家还会看到continue移回循环顶部,同时不完成剩余的内容(所以只有在i值能被9整除时才打印出值)。输出结果如下:091827364554637210203040之所以显示0,是由于0%9等于0。无限循环的第二种形式是for(;;)。编译器将while(true)与for(;;)看作同一回事。所以具体选用哪个取决于自己的编程习惯。1233.2 执行控制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循环的一个例子:1243.2 执行控制//: LabeledFor.java// Java’s "labeled for loop"public class LabeledFor {public static void main(String[] args) {int i = 0;outer: // Can't have statements herefor(; true ;) { // infinite loopinner: // Can't have statements herefor(; 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()方法。1253.2 执行控制注意break会中断for循环,而且在抵达for循环的末尾之前,递增表达式不会执行。由于break跳过了递增表达式,所以递增会在i==3的情况下直接执行。在i==7的情况下,continue outer语句也会到达循环顶部,而且也会跳过递增,所以它也是直接递增的。下面是输出结果:i = 0continue inneri = 1continue inneri = 2continuei = 3breaki = 4continue inneri = 5continue inneri = 6continue inneri = 7continue outeri = 8break outer如果没有break outer语句,就没有办法在一个内部循环里找到出外部循环的路径。这是由于break本身只能中断最内层的循环(对于continue同样如此)。当然,若想在中断循环的同时退出方法,简单地用一个return即可。下面这个例子向大家展示了带标签的break以及continue语句在while循环中的用法:1263.2 执行控制//: LabeledWhile.java// Java's "labeled while" looppublic 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会中断当前循环,并移离由那个标签指示的循环的末尾。这个方法的输出结果是一目了然的:1273.2 执行控制Outer while loopi = 1continuei = 2i = 3continue outerOuter while loopi = 4i = 5breakOuter while loopi = 6i = 7break 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为止。尽管通常不想出现这种情况,1283.2 执行控制但对有经验的程序员来说,也许能够善加利用。注意最后的default语句没有break,因为执行流程已到了break的跳转目的地。当然,如果考虑到编程风格方面的原因,完全可以在default语句的末尾放置一个break,尽管它并没有任何实际的用处。switch语句是实现多路选择的一种易行方式(比如从一系列执行路径中挑选一个)。但它要求使用一个选择因子,并且必须是int或char那样的整数值。例如,假若将一个字串或者浮点数作为选择因子使用,那么它们在switch语句里是不会工作的。对于非整数类型,则必须使用一系列if语句。 下面这个例子可随机生成字母,并判断它们是元音还是辅音字母://: VowelsAndConsonants.java// Demonstrates the switch statementpublic 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. 具体的计算1293.2 执行控制应特别留意下面这个语句: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) {doubleabove = 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.7below: 0.4(int)above: 0(int)below: 0(char)('a' + above): a(char)('a' + below): a所以答案就是:将一个float或double值造型成整数值后,总是将小数部分“砍掉”,不作任何进位处理。1303.2 执行控制第二个问题与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 tryingSystem.out.println("Produced 0.0!");}else if(args[0].equals("upper")) {while(Math.random() != 1.0); // Keep tryingSystem.out.println("Produced 1.0!");}elseusage();}} ///:~为运行这个程序,只需在命令行键入下述命令即可:java RandomBounds lower或java RandomBounds upper在这两种情况下,我们都必须人工中断程序,所以会发现Math.random()“似乎”永远都不会产生0.0或1.0。但这只是一项实验而已。若想到0和1之间有2的128次方不同的双精度小数,所以如果全部产生这些数字,花费的时间会远远超过一个人的生命。当然,最后的结果是在Math.random()的输出中包括了0.0。或者用数字语言表达,输出值范围是[0,1)。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:101313.2 执行控制1323.3 总结3.3 总结本章总结了大多数程序设计语言都具有的基本特性:计算、运算符优先顺序、类型转换以及选择和循环等等。现在,我们作好了相应的准备,可继续向面向对象的程序设计领域迈进。在下一章里,我们将讨论对象的初始化与清除问题,再后面则讲述隐藏的基本实现方法。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:101333.4 练习3.4 练习(1) 写一个程序,打印出1到100间的整数。(2) 修改练习(1),在值为47时用一个break退出程序。亦可换成return试试。(3) 创建一个switch语句,为每一种case都显示一条消息。并将switch置入一个for循环里,令其尝试每一种case。在每个case后面都放置一个break,并对其进行测试。然后,删除break,看看会有什么情况出现。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:10134第4章 初始化和清除第4章 初始化和清除“随着计算机的进步,‘不安全’的程序设计已成为造成编程代价高昂的罪魁祸首之一。”“初始化”和“清除”是这些安全问题的其中两个。许多C程序的错误都是由于程序员忘记初始化一个变量造成的。对于现成的库,若用户不知道如何初始化库的一个组件,就往往会出现这一类的错误。清除是另一个特殊的问题,因为用完一个元素后,由于不再关心,所以很容易把它忘记。这样一来,那个元素占用的资源会一直保留下去,极易产生资源(主要是内存)用尽的后果。C++为我们引入了“构建器”的概念。这是一种特殊的方法,在一个对象创建之后自动调用。Java也沿用了这个概念,但新增了自己的“垃圾收集器”,能在资源不再需要的时候自动释放它们。本章将讨论初始化和清除的问题,以及Java如何提供它们的支持。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:101354.1 用构建器自动初始化4.1 用构建器自动初始化对于方法的创建,可将其想象成为自己写的每个类都调用一次initialize()。这个名字提醒我们在使用对象之前,应首先进行这样的调用。但不幸的是,这也意味着用户必须记住调用方法。在Java中,由于提供了名为“构建器”的一种特殊方法,所以类的设计者可担保每个对象都会得到正确的初始化。若某个类有一个构建器,那么在创建对象时,Java会自动调用那个构建器——甚至在用户毫不知觉的情况下。所以说这是可以担保的!接着的一个问题是如何命名这个方法。存在两方面的问题。第一个是我们使用的任何名字都可能与打算为某个类成员使用的名字冲突。第二是由于编译器的责任是调用构建器,所以它必须知道要调用是哪个方法。C++采取的方案看来是最简单的,且更有逻辑性,所以也在Java里得到了应用:构建器的名字与类名相同。这样一来,可保证象这样的一个方法会在初始化期间自动调用。下面是带有构建器的一个简单的类(若执行这个程序有问题,请参考第3章的“赋值”小节)。//: SimpleConstructor.java// Demonstration of a simple constructorpackage c04;class Rock {Rock() { // This is the constructorSystem.out.println("Creating Rock");}}public class SimpleConstructor {public static void main(String[] args) {for(int i = 0; i < 10; i++)new Rock();}} ///:~现在,一旦创建一个对象:new Rock();就会分配相应的存储空间,并调用构建器。这样可保证在我们经手之前,对象得到正确的初始化。 请注意所有方法首字母小写的编码规则并不适用于构建器。这是由于构建器的名字必须与类名完全相同! 和其他任何方法一样,构建器也能使用自变量,以便我们指定对象的具体创建方式。可非常方便地改动上述例子,以便构建器使用自己的自变量。如下所示:1364.1 用构建器自动初始化class Rock {Rock(int i) {System.out.println("Creating Rock number " + i);}}public class SimpleConstructor {public static void main(String[] args) {for(int i = 0; i < 10; i++)new Rock(i);}}利用构建器的自变量,我们可为一个对象的初始化设定相应的参数。举个例子来说,假设类Tree有一个构建器,它用一个整数自变量标记树的高度,那么就可以象下面这样创建一个Tree对象:tree t = new Tree(12); // 12英尺高的树若Tree(int)是我们唯一的构建器,那么编译器不会允许我们以其他任何方式创建一个Tree对象。构建器有助于消除大量涉及类的问题,并使代码更易阅读。例如在前述的代码段中,我们并未看到对initialize()方法的明确调用——那些方法在概念上独立于定义内容。在Java中,定义和初始化属于统一的概念——两者缺一不可。 构建器属于一种较特殊的方法类型,因为它没有返回值。这与void返回值存在着明显的区别。对于void返回值,尽管方法本身不会自动返回什么,但仍然可以让它返回另一些东西。构建器则不同,它不仅什么也不会自动返回,而且根本不能有任何选择。若存在一个返回值,而且假设我们可以自行选择返回内容,那么编译器多少要知道如何对那个返回值作什么样的处理。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:101374.2 方法过载4.2 方法过载在任何程序设计语言中,一项重要的特性就是名字的运用。我们创建一个对象时,会分配到一个保存区域的名字。方法名代表的是一种具体的行动。通过用名字描述自己的系统,可使自己的程序更易人们理解和修改。它非常象写散文——目的是与读者沟通。我们用名字引用或描述所有对象与方法。若名字选得好,可使自己及其他人更易理解自己的代码。将人类语言中存在细致差别的概念“映射”到一种程序设计语言中时,会出现一些特殊的问题。在日常生活中,我们用相同的词表达多种不同的含义——即词的“过载”。我们说“洗衬衫”、“洗车”以及“洗狗”。但若强制象下面这样说,就显得很愚蠢:“衬衫洗 衬衫”、“车洗 车”以及“狗洗狗”。这是由于听众根本不需要对执行的行动作任何明确的区分。人类的大多数语言都具有很强的“冗余”性,所以即使漏掉了几个词,仍然可以推断出含义。我们不需要独一无二的标识符——可从具体的语境中推论出含义。大多数程序设计语言(特别是C)要求我们为每个函数都设定一个独一无二的标识符。所以绝对不能用一个名为print()的函数来显示整数,再用另一个print()显示浮点数——每个函数都要求具备唯一的名字。在Java里,另一项因素强迫方法名出现过载情况:构建器。由于构建器的名字由类名决定,所以只能有一个构建器名称。但假若我们想用多种方式创建一个对象呢?例如,假设我们想创建一个类,令其用标准方式进行初始化,另外从文件里读取信息来初始化。此时,我们需要两个构建器,一个没有自变量(默认构建器),另一个将字串作为自变量——用于初始化对象的那个文件的名字。由于都是构建器,所以它们必须有相同的名字,亦即类名。所以为了让相同的方法名伴随不同的自变量类型使用,“方法过载”是非常关键的一项措施。同时,尽管方法过载是构建器必需的,但它亦可应用于其他任何方法,且用法非常方便。在下面这个例子里,我们向大家同时展示了过载构建器和过载的原始方法:1384.2 方法过载//: Overloading.java// Demonstration of both constructor// and ordinary method overloading.import java.util.*;class Tree {int height;Tree() {prt("Planting a seedling");height = 0;}Tree(int i) {prt("Creating new Tree that is "+ i + " feet tall");height = i;}void info() {prt("Tree is " + height+ " feet tall");}void info(String s) {prt(s + ": Tree is "+ height + " feet tall");}static void prt(String s) {System.out.println(s);}}public class Overloading {public static void main(String[] args) {for(int i = 0; i = created)System.out.println("All " + finalized + " finalized");}}public class Garbage {public static void main(String[] args) {if(args.length == 0) {System.err.println("Usage: \n" +"java Garbage before\nor:\n" +"java Garbage after");return;}while(!Chair.f) {new Chair();new String("To take up space");}System.out.println("After all Chairs have been created:\n" +"total created = " + Chair.created +", total finalized = " + Chair.finalized);if(args[0].equals("before")) {System.out.println("gc():");System.gc();1514.3 清除:收尾和垃圾收集System.out.println("runFinalization():");System.runFinalization();}System.out.println("bye!");if(args[0].equals("after"))System.runFinalizersOnExit(true);}} ///:~上面这个程序创建了许多Chair对象,而且在垃圾收集器开始运行后的某些时候,程序会停止创建Chair。由于垃圾收集器可能在任何时间运行,所以我们不能准确知道它在何时启动。因此,程序用一个名为gcrun的标记来指出垃圾收集器是否已经开始运行。利用第二个标记f,Chair可告诉main()它应停止对象的生成。这两个标记都是在finalize()内部设置的,它调用于垃圾收集期间。另两个static变量——created以及finalized——分别用于跟踪已创建的对象数量以及垃圾收集器已进行完收尾工作的对象数量。最后,每个Chair都有它自己的(非static)int i,所以能跟踪了解它具体的编号是多少。编号为47的Chair进行完收尾工作后,标记会设为true,最终结束Chair对象的创建过程。所有这些都在main()的内部进行——在下面这个循环里:while(!Chair.f) {new Chair();new String("To take up space");}大家可能会疑惑这个循环什么时候会停下来,因为内部没有任何改变Chair.f值的语句。然而,finalize()进程会改变这个值,直至最终对编号47的对象进行收尾处理。每次循环过程中创建的String对象只是属于额外的垃圾,用于吸引垃圾收集器——一旦垃圾收集器对可用内存的容量感到“紧张不安”,就会开始关注它。运行这个程序的时候,提供了一个命令行自变量“before”或者“after”。其中,“before”自变量会调用System.gc()方法(强制执行垃圾收集器),同时还会调用System.runFinalization()方法,以便进行收尾工作。这些方法都可在Java 1.0中使用,但通过使用“after”自变量而调用的runFinalizersOnExit()方法却只有Java 1.1及后续版本提供了对它的支持(注释③)。注意可在程序执行的任何时候调用这个方法,而且收尾程序的执行与垃圾收集器是否运行是无关的。③:不幸的是,Java 1.0采用的垃圾收集器方案永远不能正确地调用finalize()。因此,finalize()方法(特别是那些用于关闭文件的)事实上经常都不会得到调用。现在有些文章声称所有收尾模块都会在程序退出的时候得到调用——即使到程序中止的时候,垃圾收集器仍未针对那些对象采取行动。这并不是真实的情况,所以我们根本不能指望finalize()能为所有对象而调用。特别地,finalize()在Java 1.0里几乎毫无用处。1524.3 清除:收尾和垃圾收集前面的程序向我们揭示出:在Java 1.1中,收尾模块肯定会运行这一许诺已成为现实——但前提是我们明确地强制它采取这一操作。若使用一个不是“before”或“after”的自变量(如“none”),那么两个收尾工作都不会进行,而且我们会得到象下面这样的输出:Created 47Created 47Beginning to finalize after 8694 Chairs have been createdFinalizing Chair #47, Setting flag to stop Chair creationAfter all Chairs have been created:total created = 9834, total finalized = 108bye!因此,到程序结束的时候,并非所有收尾模块都会得到调用(注释④)。为强制进行收尾工作,可先调用System.gc(),再调用System.runFinalization()。这样可清除到目前为止没有使用的所有对象。这样做一个稍显奇怪的地方是在调用runFinalization()之前调用gc(),这看起来似乎与Sun公司的文档说明有些抵触,它宣称首先运行收尾模块,再释放存储空间。然而,若在这里首先调用runFinalization(),再调用gc(),收尾模块根本不会执行。④:到你读到本书时,有些Java虚拟机(JVM)可能已开始表现出不同的行为。针对所有对象,Java 1.1有时之所以会默认为跳过收尾工作,是由于它认为这样做的开销太大。不管用哪种方法强制进行垃圾收集,都可能注意到比没有额外收尾工作时较长的时间延迟。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:101534.4 成员初始化4.4 成员初始化Java尽自己的全力保证所有变量都能在使用前得到正确的初始化。若被定义成相对于一个方法的“局部”变量,这一保证就通过编译期的出错提示表现出来。因此,如果使用下述代码:void f() {int i;i++;}就会收到一条出错提示消息,告诉你i可能尚未初始化。当然,编译器也可为i赋予一个默认值,但它看起来更象一个程序员的失误,此时默认值反而会“帮倒忙”。若强迫程序员提供一个初始值,就往往能够帮他/她纠出程序里的“臭虫”。然而,若将基本类型(主类型)设为一个类的数据成员,情况就会变得稍微有些不同。由于任何方法都可以初始化或使用那个数据,所以在正式使用数据前,若还是强迫程序员将其初始化成一个适当的值,就可能不是一种实际的做法。然而,若为其赋予一个垃圾值,同样是非常不安全的。因此,一个类的所有基本类型数据成员都会保证获得一个初始值。可用下面这段小程序看到这些值:1544.4 成员初始化//: InitialValues.java// Shows default initial valuesclass Measurement {boolean t;char c;byte b;short s;int i;long l;float f;double d;void print() {System.out.println("Data typeInital value\n" +"boolean" + t + "\n" +"char" + c + "\n" +"byte" + b + "\n" +"short" + s + "\n" +"int" + i + "\n" +"long" + l + "\n" +"float" + f + "\n" +"double" + d);}}public class InitialValues {public static void main(String[] args) {Measurement d = new Measurement();d.print();/* In this case you could also say:new Measurement().print();*/}} ///:~输入结果如下:Data typeInital valuebooleanfalsecharbyte0short0int0long0float0.0double0.0其中,Char值为空(NULL),没有数据打印出来。1554.4 成员初始化稍后大家就会看到:在一个类的内部定义一个对象句柄时,如果不将其初始化成新对象,那个句柄就会获得一个空值。4.4.1 规定初始化如果想自己为变量赋予一个初始值,又会发生什么情况呢?为达到这个目的,一个最直接的做法是在类内部定义变量的同时也为其赋值(注意在C++里不能这样做,尽管C++的新手们总“想”这样做)。在下面,Measurement类内部的字段定义已发生了变化,提供了初始值:class Measurement {boolean b = true;char c = 'x';byte B = 47;short s = 0xff;int i = 999;long l = 1;float f = 3.14f;double d = 3.14159;//. . .亦可用相同的方法初始化非基本(主)类型的对象。若Depth是一个类,那么可象下面这样插入一个变量并进行初始化:class Measurement {Depth o = new Depth();boolean b = true;// . . .若尚未为o指定一个初始值,同时不顾一切地提前试用它,就会得到一条运行期错误提示,告诉你产生了名为“违例”(Exception)的一个错误(在第9章详述)。 甚至可通过调用一个方法来提供初始值:class CInit {int i = f();//...}当然,这个方法亦可使用自变量,但那些自变量不可是尚未初始化的其他类成员。因此,下面这样做是合法的:class CInit {int i = f();int j = g(i);//...}1564.4 成员初始化但下面这样做是非法的:class CInit {int j = g(i);int i = f();//...}这正是编译器对“向前引用”感到不适应的一个地方,因为它与初始化的顺序有关,而不是与程序的编译方式有关。 这种初始化方法非常简单和直观。它的一个限制是类型Measurement的每个对象都会获得相同的初始化值。有时,这正是我们希望的结果,但有时却需要盼望更大的灵活性。4.4.2 构建器初始化可考虑用构建器执行初始化进程。这样便可在编程时获得更大的灵活程度,因为我们可以在运行期调用方法和采取行动,从而“现场”决定初始化值。但要注意这样一件事情:不可妨碍自动初始化的进行,它在构建器进入之前就会发生。因此,假如使用下述代码:class Counter {int i;Counter() { i = 7; }// . . .那么i首先会初始化成零,然后变成7。对于所有基本类型以及对象句柄,这种情况都是成立的,其中包括在定义时已进行了明确初始化的那些一些。考虑到这个原因,编译器不会试着强迫我们在构建器任何特定的场所对元素进行初始化,或者在它们使用之前——初始化早已得到了保证(注释⑤)。⑤:相反,C++有自己的“构建器初始模块列表”,能在进入构建器主体之前进行初始化,而且它对于对象来说是强制进行的。参见《Thinking in C++》。1. 初始化顺序在一个类里,初始化的顺序是由变量在类内的定义顺序决定的。即使变量定义大量遍布于方法定义的中间,那些变量仍会在调用任何方法之前得到初始化——甚至在构建器调用之前。例如:1574.4 成员初始化//: OrderOfInitialization.java// Demonstrates initialization order.// When the constructor is called, to create a// Tag object, you'll see a message:class Tag {Tag(int marker) {System.out.println("Tag(" + marker + ")");}}class Card {Tag t1 = new Tag(1); // Before constructorCard() {// Indicate we're in the constructor:System.out.println("Card()");t3 = new Tag(33); // Re-initialize t3}Tag t2 = new Tag(2); // After constructorvoid f() {System.out.println("f()");}Tag t3 = new Tag(3); // At end}public class OrderOfInitialization {public static void main(String[] args) {Card t = new Card();t.f(); // Shows that construction is done}} ///:~在Card中,Tag对象的定义故意到处散布,以证明它们全都会在构建器进入或者发生其他任何事情之前得到初始化。除此之外,t3在构建器内部得到了重新初始化。它的输入结果如下:Tag(1)Tag(2)Tag(3)Card()Tag(33)f()因此,t3句柄会被初始化两次,一次在构建器调用前,一次在调用期间(第一个对象会被丢弃,所以它后来可被当作垃圾收掉)。从表面看,这样做似乎效率低下,但它能保证正确的初始化——若定义了一个过载的构建器,它没有初始化t3;同时在t3的定义里并没有规定“默认”的初始化方式,那么会产生什么后果呢?1. 静态数据的初始化1584.4 成员初始化若数据是静态的(static),那么同样的事情就会发生;如果它属于一个基本类型(主类型),而且未对其初始化,就会自动获得自己的标准基本类型初始值;如果它是指向一个对象的句柄,那么除非新建一个对象,并将句柄同它连接起来,否则就会得到一个空值(NULL)。如果想在定义的同时进行初始化,采取的方法与非静态值表面看起来是相同的。但由于static值只有一个存储区域,所以无论创建多少个对象,都必然会遇到何时对那个存储区域进行初始化的问题。下面这个例子可将这个问题说更清楚一些://: StaticInitialization.java// Specifying initial values in a// class definition.class Bowl {Bowl(int marker) {System.out.println("Bowl(" + marker + ")");}void f(int marker) {System.out.println("f(" + marker + ")");}}class Table {static Bowl b1 = new Bowl(1);Table() {System.out.println("Table()");b2.f(1);}void f2(int marker) {System.out.println("f2(" + marker + ")");}static Bowl b2 = new Bowl(2);}class Cupboard {Bowl b3 = new Bowl(3);static Bowl b4 = new Bowl(4);Cupboard() {System.out.println("Cupboard()");b4.f(2);}void f3(int marker) {System.out.println("f3(" + marker + ")");}static Bowl b5 = new Bowl(5);}public class StaticInitialization {public static void main(String[] args) {System.out.println("Creating new Cupboard() in main");1594.4 成员初始化new Cupboard();System.out.println("Creating new Cupboard() in main");new Cupboard();t2.f2(1);t3.f3(1);}static Table t2 = new Table();static Cupboard t3 = new Cupboard();} ///:~Bowl允许我们检查一个类的创建过程,而Table和Cupboard能创建散布于类定义中的Bowl的static成员。注意在static定义之前,Cupboard先创建了一个非static的Bowl b3。它的输出结果如下:Bowl(1)Bowl(2)Table()f(1)Bowl(4)Bowl(5)Bowl(3)Cupboard()f(2)Creating new Cupboard() in mainBowl(3)Cupboard()f(2)Creating new Cupboard() in mainBowl(3)Cupboard()f(2)f2(1)f3(1)static初始化只有在必要的时候才会进行。如果不创建一个Table对象,而且永远都不引用Table.b1或Table.b2,那么static Bowl b1和b2永远都不会创建。然而,只有在创建了第一个Table对象之后(或者发生了第一次static访问),它们才会创建。在那以后,static对象不会重新初始化。 初始化的顺序是首先static(如果它们尚未由前一次对象创建过程初始化),接着是非static对象。大家可从输出结果中找到相应的证据。在这里有必要总结一下对象的创建过程。请考虑一个名为Dog的类:(1) 类型为Dog的一个对象首次创建时,或者Dog类的static方法/static字段首次访问时,Java解释器必须找到Dog.class(在事先设好的类路径里搜索)。(2) 找到Dog.class后(它会创建一个Class对象,这将在后面学到),它的所有static初始化模块都会运行。因此,static初始化仅发生一次——在Class对象首次载入的时候。1604.4 成员初始化(3) 创建一个new Dog()时,Dog对象的构建进程首先会在内存堆(Heap)里为一个Dog对象分配足够多的存储空间。(4) 这种存储空间会清为零,将Dog中的所有基本类型设为它们的默认值(零用于数字,以及boolean和char的等价设定)。(5) 进行字段定义时发生的所有初始化都会执行。(6) 执行构建器。正如第6章将要讲到的那样,这实际可能要求进行相当多的操作,特别是在涉及继承的时候。1. 明确进行的静态初始化Java允许我们将其他static初始化工作划分到类内一个特殊的“static构建从句”(有时也叫作“静态块”)里。它看起来象下面这个样子:class Spoon {static int i;static {i = 47;}// . . .尽管看起来象个方法,但它实际只是一个static关键字,后面跟随一个方法主体。与其他static初始化一样,这段代码仅执行一次——首次生成那个类的一个对象时,或者首次访问属于那个类的一个static成员时(即便从未生成过那个类的对象)。例如:1614.4 成员初始化//: ExplicitStatic.java// Explicit static initialization// with the "static" clause.class Cup {Cup(int marker) {System.out.println("Cup(" + marker + ")");}void f(int marker) {System.out.println("f(" + marker + ")");}}class Cups {static Cup c1;static Cup c2;static {c1 = new Cup(1);c2 = new Cup(2);}Cups() {System.out.println("Cups()");}}public class ExplicitStatic {public static void main(String[] args) {System.out.println("Inside main()");Cups.c1.f(99);// (1)}static Cups x = new Cups();// (2)static Cups y = new Cups();// (2)} ///:~在标记为(1)的行内访问static对象c1的时候,或在行(1)标记为注释,同时(2)行不标记成注释的时候,用于Cups的static初始化模块就会运行。若(1)和(2)都被标记成注释,则用于Cups的static初始化进程永远不会发生。1. 非静态实例的初始化针对每个对象的非静态变量的初始化,Java 1.1提供了一种类似的语法格式。下面是一个例子:1624.4 成员初始化//: Mugs.java// Java 1.1 "Instance Initialization"class Mug {Mug(int marker) {System.out.println("Mug(" + marker + ")");}void f(int marker) {System.out.println("f(" + marker + ")");}}public class Mugs {Mug c1;Mug c2;{c1 = new Mug(1);c2 = new Mug(2);System.out.println("c1 & c2 initialized");}Mugs() {System.out.println("Mugs()");}public static void main(String[] args) {System.out.println("Inside main()");Mugs x = new Mugs();}} ///:~大家可看到实例初始化从句:{c1 = new Mug(1);c2 = new Mug(2);System.out.println("c1 & c2 initialized");}它看起来与静态初始化从句极其相似,只是static关键字从里面消失了。为支持对“匿名内部类”的初始化(参见第7章),必须采用这一语法格式。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:101634.5 数组初始化4.5 数组初始化在C中初始化数组极易出错,而且相当麻烦。C++通过“集合初始化”使其更安全(注释⑥)。Java则没有象C++那样的“集合”概念,因为Java中的所有东西都是对象。但它确实有自己的数组,通过数组初始化来提供支持。数组代表一系列对象或者基本数据类型,所有相同的类型都封装到一起——采用一个统一的标识符名称。数组的定义和使用是通过方括号索引运算符进行的([])。为定义一个数组,只需在类型名后简单地跟随一对空方括号即可:int[] al;也可以将方括号置于标识符后面,获得完全一致的结果:int al[];这种格式与C和C++程序员习惯的格式是一致的。然而,最“通顺”的也许还是前一种语法,因为它指出类型是“一个int数组”。本书将沿用那种格式。编译器不允许我们告诉它一个数组有多大。这样便使我们回到了“句柄”的问题上。此时,我们拥有的一切就是指向数组的一个句柄,而且尚未给数组分配任何空间。为了给数组创建相应的存储空间,必须编写一个初始化表达式。对于数组,初始化工作可在代码的任何地方出现,但也可以使用一种特殊的初始化表达式,它必须在数组创建的地方出现。这种特殊的初始化是一系列由花括号封闭起来的值。存储空间的分配(等价于使用new)将由编译器在这种情况下进行。例如:int[] a1 = { 1, 2, 3, 4, 5 };那么为什么还要定义一个没有数组的数组句柄呢?int[] a2;事实上在Java中,可将一个数组分配给另一个,所以能使用下述语句:a2 = a1;我们真正准备做的是复制一个句柄,就象下面演示的那样:1644.5 数组初始化//: Arrays.java// Arrays of primitives.public class Arrays {public static void main(String[] args) {int[] a1 = { 1, 2, 3, 4, 5 };int[] a2;a2 = a1;for(int i = 0; i < a2.length; i++)a2[i]++;for(int i = 0; i < a1.length; i++)prt("a1[" + i + "] = " + a1[i]);}static void prt(String s) {System.out.println(s);}} ///:~大家看到a1获得了一个初始值,而a2没有;a2将在以后赋值——这种情况下是赋给另一个数组。这里也出现了一些新东西:所有数组都有一个本质成员(无论它们是对象数组还是基本类型数组),可对其进行查询——但不是改变,从而获知数组内包含了多少个元素。这个成员就是length。与C和C++类似,由于Java数组从元素0开始计数,所以能索引的最大元素编号是“length-1”。如超出边界,C和C++会“默默”地接受,并允许我们胡乱使用自己的内存,这正是许多程序错误的根源。然而,Java可保留我们这受这一问题的损害,方法是一旦超过边界,就生成一个运行期错误(即一个“违例”,这是第9章的主题)。当然,由于需要检查每个数组的访问,所以会消耗一定的时间和多余的代码量,而且没有办法把它关闭。这意味着数组访问可能成为程序效率低下的重要原因——如果它们在关键的场合进行。但考虑到因特网访问的安全,以及程序员的编程效率,Java设计人员还是应该把它看作是值得的。程序编写期间,如果不知道在自己的数组里需要多少元素,那么又该怎么办呢?此时,只需简单地用new在数组里创建元素。在这里,即使准备创建的是一个基本数据类型的数组,new也能正常地工作(new不会创建非数组的基本类型):1654.5 数组初始化//: ArrayNew.java// Creating arrays with new.import java.util.*;public class ArrayNew {static Random rand = new Random();static int pRand(int mod) {return Math.abs(rand.nextInt()) % mod + 1;}public static void main(String[] args) {int[] a;a = new int[pRand(20)];prt("length of a = " + a.length);for(int i = 0; i < a.length; i++)prt("a[" + i + "] = " + a[i]);}static void prt(String s) {System.out.println(s);}} ///:~由于数组的大小是随机决定的(使用早先定义的pRand()方法),所以非常明显,数组的创建实际是在运行期间进行的。除此以外,从这个程序的输出中,大家可看到基本数据类型的数组元素会自动初始化成“空”值(对于数值,空值就是零;对于char,它是null;而对于boolean,它却是false)。当然,数组可能已在相同的语句中定义和初始化了,如下所示:int[] a = new int[pRand(20)];若操作的是一个非基本类型对象的数组,那么无论如何都要使用new。在这里,我们会再一次遇到句柄问题,因为我们创建的是一个句柄数组。请大家观察封装器类型Integer,它是一个类,而非基本数据类型:1664.5 数组初始化//: ArrayClassObj.java// Creating an array of non-primitive objects.import java.util.*;public class ArrayClassObj {static Random rand = new Random();static int pRand(int mod) {return Math.abs(rand.nextInt()) % mod + 1;}public static void main(String[] args) {Integer[] a = new Integer[pRand(20)];prt("length of a = " + a.length);for(int i = 0; i < a.length; i++) {a[i] = new Integer(pRand(500));prt("a[" + i + "] = " + a[i]);}}static void prt(String s) {System.out.println(s);}} ///:~在这儿,甚至在new调用后才开始创建数组:Integer[] a = new Integer[pRand(20)];它只是一个句柄数组,而且除非通过创建一个新的Integer对象,从而初始化了对象句柄,否则初始化进程不会结束:a[i] = new Integer(pRand(500));但若忘记创建对象,就会在运行期试图读取空数组位置时获得一个“违例”错误。下面让我们看看打印语句中String对象的构成情况。大家可看到指向Integer对象的句柄会自动转换,从而产生一个String,它代表着位于对象内部的值。亦可用花括号封闭列表来初始化对象数组。可采用两种形式,第一种是Java 1.0允许的唯一形式。第二种(等价)形式自Java 1.1才开始提供支持:1674.5 数组初始化//: ArrayInit.java// Array initializationpublic class ArrayInit {public static void main(String[] args) {Integer[] a = {new Integer(1),new Integer(2),new Integer(3),};// Java 1.1 only:Integer[] b = new Integer[] {new Integer(1),new Integer(2),new Integer(3),};}} ///:~这种做法大多数时候都很有用,但限制也是最大的,因为数组的大小是在编译期间决定的。初始化列表的最后一个逗号是可选的(这一特性使长列表的维护变得更加容易)。数组初始化的第二种形式(Java 1.1开始支持)提供了一种更简便的语法,可创建和调用方法,获得与C的“变量参数列表”(C通常把它简称为“变参表”)一致的效果。这些效果包括未知的参数(自变量)数量以及未知的类型(如果这样选择的话)。由于所有类最终都是从通用的根类Object中继承的,所以能创建一个方法,令其获取一个Object数组,并象下面这样调用它://: VarArgs.java// Using the Java 1.1 array syntax to create// variable argument listsclass A { int i; }public class VarArgs {static void f(Object[] x) {for(int i = 0; i < x.length; i++)System.out.println(x[i]);}public static void main(String[] args) {f(new Object[] {new Integer(47), new VarArgs(),new Float(3.14), new Double(11.11) });f(new Object[] {"one", "two", "three" });f(new Object[] {new A(), new A(), new A()});}} ///:~1684.5 数组初始化此时,我们对这些未知的对象并不能采取太多的操作,而且这个程序利用自动String转换对每个Object做一些有用的事情。在第11章(运行期类型标识或RTTI),大家还会学习如何调查这类对象的准确类型,使自己能对它们做一些有趣的事情。4.5.1 多维数组在Java里可以方便地创建多维数组://: MultiDimArray.java// Creating multidimensional arrays.import java.util.*;public class MultiDimArray {static Random rand = new Random();static int pRand(int mod) {return Math.abs(rand.nextInt()) % mod + 1;}public static void main(String[] args) {int[][] a1 = {{ 1, 2, 3, },{ 4, 5, 6, },};for(int i = 0; i < a1.length; i++)for(int j = 0; j < a1[i].length; j++)prt("a1[" + i + "][" + j +"] = " + a1[i][j]);// 3-D array with fixed length:int[][][] a2 = new int[2][2][4];for(int i = 0; i < a2.length; i++)for(int j = 0; j < a2[i].length; j++)for(int k = 0; k < a2[i][j].length;k++)prt("a2[" + i + "][" +j + "][" + k +"] = " + a2[i][j][k]);// 3-D array with varied-length vectors:int[][][] a3 = new int[pRand(7)][][];for(int i = 0; i < a3.length; i++) {a3[i] = new int[pRand(5)][];for(int j = 0; j < a3[i].length; j++)a3[i][j] = new int[pRand(5)];}for(int i = 0; i < a3.length; i++)for(int j = 0; j < a3[i].length; j++)for(int k = 0; k < a3[i][j].length;k++)prt("a3[" + i + "][" +j + "][" + k +"] = " + a3[i][j][k]);// Array of non-primitive objects:Integer[][] a4 = {{ new Integer(1), new Integer(2)},1694.5 数组初始化{ new Integer(3), new Integer(4)},{ new Integer(5), new Integer(6)},};for(int i = 0; i < a4.length; i++)for(int j = 0; j < a4[i].length; j++)prt("a4[" + i + "][" + j +"] = " + a4[i][j]);Integer[][] a5;a5 = new Integer[3][];for(int i = 0; i < a5.length; i++) {a5[i] = new Integer[3];for(int j = 0; j < a5[i].length; j++)a5[i][j] = new Integer(i*j);}for(int i = 0; i < a5.length; i++)for(int j = 0; j < a5[i].length; j++)prt("a5[" + i + "][" + j +"] = " + a5[i][j]);}static void prt(String s) {System.out.println(s);}} ///:~用于打印的代码里使用了length,所以它不必依赖固定的数组大小。 第一个例子展示了基本数据类型的一个多维数组。我们可用花括号定出数组内每个矢量的边界:int[][] a1 = {{ 1, 2, 3, },{ 4, 5, 6, },};每个方括号对都将我们移至数组的下一级。 第二个例子展示了用new分配的一个三维数组。在这里,整个数组都是立即分配的: int[][][] a2 = new int[2][2][4]; 但第三个例子却向大家揭示出构成矩阵的每个矢量都可以有任意的长度:int[][][] a3 = new int[pRand(7)][][];for(int i = 0; i < a3.length; i++) {a3[i] = new int[pRand(5)][];for(int j = 0; j < a3[i].length; j++)a3[i][j] = new int[pRand(5)];}对于第一个new创建的数组,它的第一个元素的长度是随机的,其他元素的长度则没有定义。for循环内的第二个new则会填写元素,但保持第三个索引的未定状态——直到碰到第三个new。 根据输出结果,大家可以看到:假若没有明确指定初始化值,数组值就会自动初始化1704.5 数组初始化成零。 可用类似的表式处理非基本类型对象的数组。这从第四个例子可以看出,它向我们演示了用花括号收集多个new表达式的能力:Integer[][] a4 = {{ new Integer(1), new Integer(2)},{ new Integer(3), new Integer(4)},{ new Integer(5), new Integer(6)},};第五个例子展示了如何逐渐构建非基本类型的对象数组:Integer[][] a5;a5 = new Integer[3][];for(int i = 0; i < a5.length; i++) {a5[i] = new Integer[3];for(int j = 0; j < a5[i].length; j++)a5[i][j] = new Integer(i*j);}i*j只是在Integer里置了一个有趣的值。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:101714.6 总结4.6 总结作为初始化的一种具体操作形式,构建器应使大家明确感受到在语言中进行初始化的重要性。与C++的程序设计一样,判断一个程序效率如何,关键是看是否由于变量的初始化不正确而造成了严重的编程错误(臭虫)。这些形式的错误很难发现,而且类似的问题也适用于不正确的清除或收尾工作。由于构建器使我们能保证正确的初始化和清除(若没有正确的构建器调用,编译器不允许对象创建),所以能获得完全的控制权和安全性。在C++中,与“构建”相反的“破坏”(Destruction)工作也是相当重要的,因为用new创建的对象必须明确地清除。在Java中,垃圾收集器会自动为所有对象释放内存,所以Java中等价的清除方法并不是经常都需要用到的。如果不需要类似于构建器的行为,Java的垃圾收集器可以极大简化编程工作,而且在内存的管理过程中增加更大的安全性。有些垃圾收集器甚至能清除其他资源,比如图形和文件句柄等。然而,垃圾收集器确实也增加了运行期的开销。但这种开销到底造成了多大的影响却是很难看出的,因为到目前为止,Java解释器的总体运行速度仍然是比较慢的。随着这一情况的改观,我们应该能判断出垃圾收集器的开销是否使Java不适合做一些特定的工作(其中一个问题是垃圾收集器不可预测的性质)。由于所有对象都肯定能获得正确的构建,所以同这儿讲述的情况相比,构建器实际做的事情还要多得多。特别地,当我们通过“创作”或“继承”生成新类的时候,对构建的保证仍然有效,而且需要一些附加的语法来提供对它的支持。大家将在以后的章节里详细了解创作、继承以及它们对构建器造成的影响。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:101724.7 练习4.7 练习(1) 用默认构建器创建一个类(没有自变量),用它打印一条消息。创建属于这个类的一个对象。(2) 在练习1的基础上增加一个过载的构建器,令其采用一个String自变量,并随同自己的消息打印出来。(3) 以练习2创建的类为基础上,创建属于它的对象句柄的一个数组,但不要实际创建对象并分配到数组里。运行程 序时,注意是否打印出来自构建器调用的初始化消息。(4) 创建同句柄数组联系起来的对象,最终完成练习3。(5) 用自变量“before”,“after”和“none”运行程序,试验Garbage.java。重复这个操作,观察是否从输出中看出了一些固定的模式。改变代码,使System.runFinalization()在System.gc()之前调用,再观察结果。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:10173第5章 隐藏实施过程第5章 隐藏实施过程“进行面向对象的设计时,一项基本的考虑是:如何将发生变化的东西与保持不变的东西分隔开。”这一点对于库来说是特别重要的。那个库的用户(客户程序员)必须能依赖自己使用的那一部分,并知道一旦新版本的库出台,自己不需要改写代码。而与此相反,库的创建者必须能自由地进行修改与改进,同时保证客户程序员代码不会受到那些变动的影响。为达到这个目的,需遵守一定的约定或规则。例如,库程序员在修改库内的一个类时,必须保证不删除已有的方法,因为那样做会造成客户程序员代码出现断点。然而,相反的情况却是令人痛苦的。对于一个数据成员,库的创建者怎样才能知道哪些数据成员已受到客户程序员的访问呢?若方法属于某个类唯一的一部分,而且并不一定由客户程序员直接使用,那么这种痛苦的情况同样是真实的。如果库的创建者想删除一种旧有的实施方案,并置入新代码,此时又该怎么办呢?对那些成员进行的任何改动都可能中断客户程序员的代码。所以库创建者处在一个尴尬的境地,似乎根本动弹不得。为解决这个问题,Java推出了“访问指示符”的概念,允许库创建者声明哪些东西是客户程序员可以使用的,哪些是不可使用的。这种访问控制的级别在“最大访问”和“最小访问”的范围之间,分别包括:public,“友好的”(无关键字),protected以及private。根据前一段的描述,大家或许已总结出作为一名库设计者,应将所有东西都尽可能保持为“private”(私有),并只展示出那些想让客户程序员使用的方法。这种思路是完全正确的,尽管它有点儿违背那些用其他语言(特别是C)编程的人的直觉,那些人习惯于在没有任何限制的情况下访问所有东西。到这一章结束时,大家应该可以深刻体会到Java访问控制的价值。然而,组件库以及控制谁能访问那个库的组件的概念现在仍不是完整的。仍存在这样一个问题:如何将组件绑定到单独一个统一的库单元里。这是通过Java的package(打包)关键字来实现的,而且访问指示符要受到类在相同的包还是在不同的包里的影响。所以在本章的开头,大家首先要学习库组件如何置入包里。这样才能理解访问指示符的完整含义。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:101745.1 包:库单元5.1 包:库单元我们用import关键字导入一个完整的库时,就会获得“包”(Package)。例如:import java.util.*;它的作用是导入完整的实用工具(Utility)库,该库属于标准Java开发工具包的一部分。由于Vector位于java.util里,所以现在要么指定完整名称“java.util.Vector”(可省略import语句),要么简单地指定一个“Vector”(因为import是默认的)。若想导入单独一个类,可在import语句里指定那个类的名字:import java.util.Vector;现在,我们可以自由地使用Vector。然而,java.util中的其他任何类仍是不可使用的。之所以要进行这样的导入,是为了提供一种特殊的机制,以便管理“命名空间”(NameSpace)。我们所有类成员的名字相互间都会隔离起来。位于类A内的一个方法f()不会与位于类B内的、拥有相同“签名”(自变量列表)的f()发生冲突。但类名会不会冲突呢?假设创建一个stack类,将它安装到已有一个stack类(由其他人编写)的机器上,这时会出现什么情况呢?对于因特网中的Java应用,这种情况会在用户毫不知晓的时候发生,因为类会在运行一个Java程序的时候自动下载。正是由于存在名字潜在的冲突,所以特别有必要对Java中的命名空间进行完整的控制,而且需要创建一个完全独一无二的名字,无论因特网存在什么样的限制。迄今为止,本书的大多数例子都仅存在于单个文件中,而且设计成局部(本地)使用,没有同包名发生冲突(在这种情况下,类名置于“默认包”内)。这是一种有效的做法,而且考虑到问题的简化,本书剩下的部分也将尽可能地采用它。然而,若计划创建一个“对因特网友好”或者说“适合在因特网使用”的程序,必须考虑如何防止类名的重复。 为Java创建一个源码文件的时候,它通常叫作一个“编辑单元”(有时也叫作“翻译单元”)。每个编译单元都必须有一个以.java结尾的名字。而且在编译单元的内部,可以有一个公共(public)类,它必须拥有与文件相同的名字(包括大小写形式,但排除.java文件扩展名)。如果不这样做,编译器就会报告出错。每个编译单元内都只能有一个public类(同样地,否则编译器会报告出错)。那个编译单元剩下的类(如果有的话)可在那个包外面的世界面前隐藏起来,因为它们并非“公共”的(非public),而且它们由用于主public类的“支撑”类组成。编译一个.java文件时,我们会获得一个名字完全相同的输出文件;但对于.java文件中的每个类,它们都有一个.class扩展名。因此,我们最终从少量的.java文件里有可能获得数量众多的.class文件。如以前用一种汇编语言写过程序,那么可能已习惯编译器先分割出一种过渡形1755.1 包:库单元式(通常是一个.obj文件),再用一个链接器将其与其他东西封装到一起(生成一个可执行文件),或者与一个库封装到一起(生成一个库)。但那并不是Java的工作方式。一个有效的程序就是一系列.class文件,它们可以封装和压缩到一个JAR文件里(使用Java 1.1提供的jar工具)。Java解释器负责对这些文件的寻找、装载和解释(注释①)。①:Java并没有强制一定要使用解释器。一些固有代码的Java编译器可生成单独的可执行文件。“库”也由一系列类文件构成。每个文件都有一个public类(并没强迫使用一个public类,但这种情况最很典型的),所以每个文件都有一个组件。如果想将所有这些组件(它们在各自独立的.java和.class文件里)都归纳到一起,那么package关键字就可以发挥作用)。若在一个文件的开头使用下述代码:package mypackage;那么package语句必须作为文件的第一个非注释语句出现。该语句的作用是指出这个编译单元属于名为mypackage的一个库的一部分。或者换句话说,它表明这个编译单元内的public类名位于mypackage这个名字的下面。如果其他人想使用这个名字,要么指出完整的名字,要么与mypackage联合使用import关键字(使用前面给出的选项)。注意根据Java包(封装)的约定,名字内的所有字母都应小写,甚至那些中间单词亦要如此。例如,假定文件名是MyClass.java。它意味着在那个文件有一个、而且只能有一个public类。而且那个类的名字必须是MyClass(包括大小写形式):package mypackage;public class MyClass {// . . .现在,如果有人想使用MyClass,或者想使用mypackage内的其他任何public类,他们必须用import关键字激活mypackage内的名字,使它们能够使用。另一个办法则是指定完整的名称:mypackage.MyClass m = new mypackage.MyClass();import关键字则可将其变得简洁得多:import mypackage.*;// . . .MyClass m = new MyClass();作为一名库设计者,一定要记住package和import关键字允许我们做的事情就是分割单个全局命名空间,保证我们不会遇到名字的冲突——无论有多少人使用因特网,也无论多少人用Java编写自己的类。1765.1 包:库单元5.1.1 创建独一无二的包名大家或许已注意到这样一个事实:由于一个包永远不会真的“封装”到单独一个文件里面,它可由多个.class文件构成,所以局面可能稍微有些混乱。为避免这个问题,最合理的一种做法就是将某个特定包使用的所有.class文件都置入单个目录里。也就是说,我们要利用操作系统的分级文件结构避免出现混乱局面。这正是Java所采取的方法。 它同时也解决了另两个问题:创建独一无二的包名以及找出那些可能深藏于目录结构某处的类。正如我们在第2章讲述的那样,为达到这个目的,需要将.class文件的位置路径编码到package的名字里。但根据约定,编译器强迫package名的第一部分是类创建者的因特网域名。由于因特网域名肯定是独一无二的(由InterNIC保证——注释②,它控制着域名的分配),所以假如按这一约定行事,package的名称就肯定不会重复,所以永远不会遇到名称冲突的问题。换句话说,除非将自己的域名转让给其他人,而且对方也按照相同的路径名编写Java代码,否则名字的冲突是永远不会出现的。当然,如果你没有自己的域名,那么必须创造一个非常生僻的包名(例如自己的英文姓名),以便尽最大可能创建一个独一无二的包名。如决定发行自己的Java代码,那么强烈推荐去申请自己的域名,它所需的费用是非常低廉的。②:ftp://ftp.internic.net这个技巧的另一部分是将package名解析成自己机器上的一个目录。这样一来,Java程序运行并需要装载.class文件的时候(这是动态进行的,在程序需要创建属于那个类的一个对象,或者首次访问那个类的一个static成员时),它就可以找到.class文件驻留的那个目录。Java解释器的工作程序如下:首先,它找到环境变量CLASSPATH(将Java或者具有Java解释能力的工具——如浏览器——安装到机器中时,通过操作系统进行设定)。CLASSPATH包含了一个或多个目录,它们作为一种特殊的“根”使用,从这里展开对.class文件的搜索。从那个根开始,解释器会寻找包名,并将每个点号(句点)替换成一个斜杠,从而生成从CLASSPATH根开始的一个路径名(所以package foo.bar.baz会变成foo\bar\baz或者foo/bar/baz;具体是正斜杠还是反斜杠由操作系统决定)。随后将它们连接到一起,成为CLASSPATH内的各个条目(入口)。以后搜索.class文件时,就可从这些地方开始查找与准备创建的类名对应的名字。此外,它也会搜索一些标准目录——这些目录与Java解释器驻留的地方有关。为进一步理解这个问题,下面以我自己的域名为例,它是bruceeckel.com。将其反转过来后,com.bruceeckel就为我的类创建了独一无二的全局名称(com,edu,org,net等扩展名以前在Java包中都是大写的,但自Java 1.2以来,这种情况已发生了变化。现在整个包名都是小写的)。由于决定创建一个名为util的库,我可以进一步地分割它,所以最后得到的包名如下:package com.bruceeckel.util;现在,可将这个包名作为下述两个文件的“命名空间”使用:1775.1 包:库单元//: Vector.java// Creating a packagepackage com.bruceeckel.util;public class Vector {public Vector() {System.out.println("com.bruceeckel.util.Vector");}} ///:~创建自己的包时,要求package语句必须是文件中的第一个“非注释”代码。第二个文件表面看起来是类似的://: List.java// Creating a packagepackage com.bruceeckel.util;public class List {public List() {System.out.println("com.bruceeckel.util.List");}} ///:~这两个文件都置于我自己系统的一个子目录中:C:\DOC\JavaT\com\bruceeckel\util若通过它往回走,就会发现包名com.bruceeckel.util,但路径的第一部分又是什么呢?这是由CLASSPATH环境变量决定的。在我的机器上,它是:CLASSPATH=.;D:\JAVA\LIB;C:\DOC\JavaT可以看出,CLASSPATH里能包含大量备用的搜索路径。然而,使用JAR文件时要注意一个问题:必须将JAR文件的名字置于类路径里,而不仅仅是它所在的路径。所以对一个名为grape.jar的JAR文件来说,我们的类路径需要包括:CLASSPATH=.;D:\JAVA\LIB;C:\flavors\grape.jar正确设置好类路径后,可将下面这个文件置于任何目录里(若在执行该程序时遇到麻烦,请参见第3章的3.1.2小节“赋值”):1785.1 包:库单元//: LibTest.java// Uses the librarypackage c05;import com.bruceeckel.util.*;public class LibTest {public static void main(String[] args) {Vector v = new Vector();List l = new List();}} ///:~编译器遇到import语句后,它会搜索由CLASSPATH指定的目录,查找子目录com\bruceeckel\util,然后查找名称适当的已编译文件(对于Vector是Vector.class,对于List则是List.class)。注意Vector和List内无论类还是需要的方法都必须设为public。1. 自动编译为导入的类首次创建一个对象时(或者访问一个类的static成员时),编译器会在适当的目录里寻找同名的.class文件(所以如果创建类X的一个对象,就应该是X.class)。若只发现X.class,它就是必须使用的那一个类。然而,如果它在相同的目录中还发现了一个X.java,编译器就会比较两个文件的日期标记。如果X.java比X.class新,就会自动编译X.java,生成一个最新的X.class。 对于一个特定的类,或在与它同名的.java文件中没有找到它,就会对那个类采取上述的处理。1. 冲突若通过*导入了两个库,而且它们包括相同的名字,这时会出现什么情况呢?例如,假定一个程序使用了下述导入语句:import com.bruceeckel.util.*;import java.util.*;由于java.util.*也包含了一个Vector类,所以这会造成潜在的冲突。然而,只要冲突并不真的发生,那么就不会产生任何问题——这当然是最理想的情况,因为否则的话,就需要进行大量编程工作,防范那些可能可能永远也不会发生的冲突。如现在试着生成一个Vector,就肯定会发生冲突。如下所示:Vector v = new Vector();它引用的到底是哪个Vector类呢?编译器对这个问题没有答案,读者也不可能知道。所以编译器会报告一个错误,强迫我们进行明确的说明。例如,假设我想使用标准的Java Vector,那么必须象下面这样编程:1795.1 包:库单元java.util.Vector v = new java.util.Vector();由于它(与CLASSPATH一起)完整指定了那个Vector的位置,所以不再需要java.util.*import语句,除非还想使用来自java.util的其他东西。5.1.2 自定义工具库掌握前述的知识后,接下来就可以开始创建自己的工具库,以便减少或者完全消除重复的代码。例如,可为System.out.println()创建一个别名,减少重复键入的代码量。它可以是名为tools的一个包(package)的一部分://: P.java// The P.rint & P.rintln shorthandpackage com.bruceeckel.tools;public class P {public static void rint(Object obj) {System.out.print(obj);}public static void rint(String s) {System.out.print(s);}public static void rint(char[] s) {System.out.print(s);}public static void rint(char c) {System.out.print(c);}public static void rint(int i) {System.out.print(i);}public static void rint(long l) {System.out.print(l);}public static void rint(float f) {System.out.print(f);}public static void rint(double d) {System.out.print(d);}public static void rint(boolean b) {System.out.print(b);}public static void rintln() {System.out.println();}public static void rintln(Object obj) {System.out.println(obj);}public static void rintln(String s) {1805.1 包:库单元System.out.println(s);}public static void rintln(char[] s) {System.out.println(s);}public static void rintln(char c) {System.out.println(c);}public static void rintln(int i) {System.out.println(i);}public static void rintln(long l) {System.out.println(l);}public static void rintln(float f) {System.out.println(f);}public static void rintln(double d) {System.out.println(d);}public static void rintln(boolean b) {System.out.println(b);}} ///:~所有不同的数据类型现在都可以在一个新行输出(P.rintln()),或者不在一个新行输出(P.rint())。 大家可能会猜想这个文件所在的目录必须从某个CLASSPATH位置开始,然后继续com/bruceeckel/tools。编译完毕后,利用一个import语句,即可在自己系统的任何地方使用P.class文件。如下所示:ToolTest.java所以从现在开始,无论什么时候只要做出了一个有用的新工具,就可将其加入tools目录(或者自己的个人util或tools目录)。1. CLASSPATH的陷阱P.java文件存在一个非常有趣的陷阱。特别是对于早期的Java实现方案来说,类路径的正确设定通常都是很困难的一项工作。编写这本书的时候,我引入了P.java文件,它最初看起来似乎工作很正常。但在某些情况下,却开始出现中断。在很长的时间里,我都确信这是Java或其他什么在实现时一个错误。但最后,我终于发现在一个地方引入了一个程序(即第17章要说明的CodePackager.java),它使用了一个不同的类P。由于它作为一个工具使用,所以有时候会进入类路径里;另一些时候则不会这样。但只要它进入类路径,那么假若执行的程序需要寻找com.bruceeckel.tools中的类,Java首先发现的就是CodePackager.java中的P。此时,1815.1 包:库单元编译器会报告一个特定的方法没有找到。这当然是非常令人头疼的,因为我们在前面的类P里明明看到了这个方法,而且根本没有更多的诊断报告可为我们提供一条线索,让我们知道找到的是一个完全不同的类(那甚至不是public的)。乍一看来,这似乎是编译器的一个错误,但假若考察import语句,就会发现它只是说:“在这里可能发现了P”。然而,我们假定的是编译器搜索自己类路径的任何地方,所以一旦它发现一个P,就会使用它;若在搜索过程中发现了“错误的”一个,它就会停止搜索。这与我们在前面表述的稍微有些区别,因为存在一些讨厌的类,它们都位于包内。而这里有一个不在包内的P,但仍可在常规的类路径搜索过程中找到。如果您遇到象这样的情况,请务必保证对于类路径的每个地方,每个名字都仅存在一个类。5.1.3 利用导入改变行为Java已取消的一种特性是C的“条件编译”,它允许我们改变参数,获得不同的行为,同时不改变其他任何代码。Java之所以抛弃了这一特性,可能是由于该特性经常在C里用于解决跨平台问题:代码的不同部分根据具体的平台进行编译,否则不能在特定的平台上运行。由于Java的设计思想是成为一种自动跨平台的语言,所以这种特性是没有必要的。然而,条件编译还有另一些非常有价值的用途。一种很常见的用途就是调试代码。调试特性可在开发过程中使用,但在发行的产品中却无此功能。Alen Holub(www.holub.com)提出了利用包(package)来模仿条件编译的概念。根据这一概念,它创建了C“断定机制”一个非常有用的Java版本。之所以叫作“断定机制”,是由于我们可以说“它应该为真”或者“它应该为假”。如果语句不同意你的断定,就可以发现相关的情况。这种工具在调试过程中是特别有用的。可用下面这个类进行程序调试:1825.1 包:库单元//: Assert.java// Assertion tool for debuggingpackage com.bruceeckel.tools.debug;public class Assert {private static void perr(String msg) {System.err.println(msg);}public final static void is_true(boolean exp) {if(!exp) perr("Assertion failed");}public final static void is_false(boolean exp){if(exp) perr("Assertion failed");}public final static voidis_true(boolean exp, String msg) {if(!exp) perr("Assertion failed: " + msg);}public final static voidis_false(boolean exp, String msg) {if(exp) perr("Assertion failed: " + msg);}} ///:~这个类只是简单地封装了布尔测试。如果失败,就显示出出错消息。在第9章,大家还会学习一个更高级的错误控制工具,名为“违例控制”。但在目前这种情况下,perr()方法已经可以很好地工作。 如果想使用这个类,可在自己的程序中加入下面这一行:import com.bruceeckel.tools.debug.*;如欲清除断定机制,以便自己能发行最终的代码,我们创建了第二个Assert类,但却是在一个不同的包里://: Assert.java// Turning off the assertion output// so you can ship the program.package com.bruceeckel.tools;public class Assert {public final static void is_true(boolean exp){}public final static void is_false(boolean exp){}public final static voidis_true(boolean exp, String msg) {}public final static voidis_false(boolean exp, String msg) {}} ///:~1835.1 包:库单元现在,假如将前一个import语句变成下面这个样子:import com.bruceeckel.tools.*;程序便不再显示出断言。下面是个例子://: TestAssert.java// Demonstrating the assertion toolpackage c05;// Comment the following, and uncomment the// subsequent line to change assertion behavior:import com.bruceeckel.tools.debug.*;// import com.bruceeckel.tools.*;public class TestAssert {public static void main(String[] args) {Assert.is_true((2 + 2) == 5);Assert.is_false((1 + 1) == 2);Assert.is_true((2 + 2) == 5, "2 + 2 == 5");Assert.is_false((1 + 1) == 2, "1 +1 != 2");}} ///:~通过改变导入的package,我们可将自己的代码从调试版本变成最终的发行版本。这种技术可应用于任何种类的条件代码。5.1.4 包的停用大家应注意这样一个问题:每次创建一个包后,都在为包取名时间接地指定了一个目录结构。这个包必须存在(驻留)于由它的名字规定的目录内。而且这个目录必须能从CLASSPATH开始搜索并发现。最开始的时候,package关键字的运用可能会令人迷惑,因为除非坚持遵守根据目录路径指定包名的规则,否则就会在运行期获得大量莫名其妙的消息,指出找不到一个特定的类——即使那个类明明就在相同的目录中。若得到象这样的一条消息,请试着将package语句作为注释标记出去。如果这样做行得通,就可知道问题到底出在哪儿。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:101845.2 Java访问指示符5.2 Java访问指示符针对类内每个成员的每个定义,Java访问指示符poublic,protected以及private都置于它们的最前面——无论它们是一个数据成员,还是一个方法。每个访问指示符都只控制着对那个特定定义的访问。这与C++存在着显著不同。在C++中,访问指示符控制着它后面的所有定义,直到又一个访问指示符加入为止。通过千丝万缕的联系,程序为所有东西都指定了某种形式的访问。在后面的小节里,大家要学习与各类访问有关的所有知识。首次从默认访问开始。5.2.1 “友好的”如果根本不指定访问指示符,就象本章之前的所有例子那样,这时会出现什么情况呢?默认的访问没有关键字,但它通常称为“友好”(Friendly)访问。这意味着当前包内的其他所有类都能访问“友好的”成员,但对包外的所有类来说,这些成员却是“私有”(Private)的,外界不得访问。由于一个编译单元(一个文件)只能从属于单个包,所以单个编译单元内的所有类相互间都是自动“友好”的。因此,我们也说友好元素拥有“包访问”权限。友好访问允许我们将相关的类都组合到一个包里,使它们相互间方便地进行沟通。将类组合到一个包内以后(这样便允许友好成员的相互访问,亦即让它们“交朋友”),我们便“拥有”了那个包内的代码。只有我们已经拥有的代码才能友好地访问自己拥有的其他代码。我们可认为友好访问使类在一个包内的组合显得有意义,或者说前者是后者的原因。在许多语言中,我们在文件内组织定义的方式往往显得有些牵强。但在Java中,却强制用一种颇有意义的形式进行组织。除此以外,我们有时可能想排除一些类,不想让它们访问当前包内定义的类。对于任何关系,一个非常重要的问题是“谁能访问我们的‘私有’或private代码”。类控制着哪些代码能够访问自己的成员。没有任何秘诀可以“闯入”。另一个包内推荐可以声明一个新类,然后说:“嗨,我是Bob的朋友!”,并指望看到Bob的“protected”(受到保护的)、友好的以及“private”(私有)的成员。为获得对一个访问权限,唯一的方法就是:(1) 使成员成为“public”(公共的)。这样所有人从任何地方都可以访问它。(2) 变成一个“友好”成员,方法是舍弃所有访问指示符,并将其类置于相同的包内。这样一来,其他类就可以访问成员。(3) 正如以后引入“继承”概念后大家会知道的那样,一个继承的类既可以访问一个protected成员,也可以访问一个public成员(但不可访问private成员)。只有在两个类位于相同的包内时,它才可以访问友好成员。但现在不必关心这方面的问题。(4) 提供“访问器/变化器”方法(亦称为“获取/设置”方法),以便读取和修改值。这是OOP环境中最正规的一种方法,也是Java Beans的基础——具体情况会在第13章介绍。5.2.2 public:接口访问1855.2 Java访问指示符使用public关键字时,它意味着紧随在public后面的成员声明适用于所有人,特别是适用于使用库的客户程序员。假定我们定义了一个名为dessert的包,其中包含下述单元(若执行该程序时遇到困难,请参考第3章3.1.2小节“赋值”)://: Cookie.java// Creates a librarypackage c05.dessert;public class Cookie {public Cookie() {System.out.println("Cookie constructor");}void foo() { System.out.println("foo"); }} ///:~请记住,Cookie.java必须驻留在名为dessert的一个子目录内,而这个子目录又必须位于由CLASSPATH指定的C05目录下面(C05代表本书的第5章)。不要错误地以为Java无论如何都会将当前目录作为搜索的起点看待。如果不将一个“.”作为CLASSPATH的一部分使用,Java就不会考虑当前目录。 现在,假若创建使用了Cookie的一个程序,如下所示://: Dinner.java// Uses the libraryimport c05.dessert.*;public class Dinner {public Dinner() {System.out.println("Dinner constructor");}public static void main(String[] args) {Cookie x = new Cookie();//! x.foo(); // Can't access}} ///:~就可以创建一个Cookie对象,因为它的构建器是public的,而且类也是public的(公共类的概念稍后还会进行更详细的讲述)。然而,foo()成员不可在Dinner.java内访问,因为foo()只有在dessert包内才是“友好”的。1. 默认包大家可能会惊讶地发现下面这些代码得以顺利编译——尽管它看起来似乎已违背了规则:1865.2 Java访问指示符//: Cake.java// Accesses a class in a separate// compilation unit.class Cake {public static void main(String[] args) {Pie x = new Pie();x.f();}} ///:~在位于相同目录的第二个文件里://: Pie.java// The other classclass Pie {void f() { System.out.println("Pie.f()"); }} ///:~最初可能会把它们看作完全不相干的文件,然而Cake能创建一个Pie对象,并能调用它的f()方法!通常的想法会认为Pie和f()是“友好的”,所以不适用于Cake。它们确实是友好的——这部分结论非常正确。但它们之所以仍能在Cake.java中使用,是由于它们位于相同的目录中,而且没有明确的包名。Java把象这样的文件看作那个目录“默认包”的一部分,所以它们对于目录内的其他文件来说是“友好”的。5.2.3 private:不能接触!private关键字意味着除非那个特定的类,而且从那个类的方法里,否则没有人能访问那个成员。同一个包内的其他成员不能访问private成员,这使其显得似乎将类与我们自己都隔离起来。另一方面,也不能由几个合作的人创建一个包。所以private允许我们自由地改变那个成员,同时毋需关心它是否会影响同一个包内的另一个类。默认的“友好”包访问通常已经是一种适当的隐藏方法;请记住,对于包的用户来说,是不能访问一个“友好”成员的。这种效果往往能令人满意,因为默认访问是我们通常采用的方法。对于希望变成public(公共)的成员,我们通常明确地指出,令其可由客户程序员自由调用。而且作为一个结果,最开始的时候通常会认为自己不必频繁使用private关键字,因为完全可以在不用它的前提下发布自己的代码(这与C++是个鲜明的对比)。然而,随着学习的深入,大家就会发现private仍然有非常重要的用途,特别是在涉及多线程处理的时候(详情见第14章)。 下面是应用了private的一个例子:1875.2 Java访问指示符//: IceCream.java// Demonstrates "private" keywordclass Sundae {private Sundae() {}static Sundae makeASundae() {return new Sundae();}}public class IceCream {public static void main(String[] args) {//! Sundae x = new Sundae();Sundae x = Sundae.makeASundae();}} ///:~这个例子向我们证明了使用private的方便:有时可能想控制对象的创建方式,并防止有人直接访问一个特定的构建器(或者所有构建器)。在上面的例子中,我们不可通过它的构建器创建一个Sundae对象;相反,必须调用makeASundae()方法来实现(注释③)。③:此时还会产生另一个影响:由于默认构建器是唯一获得定义的,而且它的属性是private,所以可防止对这个类的继承(这是第6章要重点讲述的主题)。若确定一个类只有一个“助手”方法,那么对于任何方法来说,都可以把它们设为private,从而保证自己不会误在包内其他地方使用它,防止自己更改或删除方法。将一个方法的属性设为private后,可保证自己一直保持这一选项(然而,若一个句柄被设为private,并不表明其他对象不能拥有指向同一个对象的public句柄。有关“别名”的问题将在第12章详述)。5.2.4 protected:“友好的一种”protected(受到保护的)访问指示符要求大家提前有所认识。首先应注意这样一个事实:为继续学习本书一直到继承那一章之前的内容,并不一定需要先理解本小节的内容。但为了保持内容的完整,这儿仍然要对此进行简要说明,并提供相关的例子。protected关键字为我们引入了一种名为“继承”的概念,它以现有的类为基础,并在其中加入新的成员,同时不会对现有的类产生影响——我们将这种现有的类称为“基础类”或者“基本类”(Base Class)。亦可改变那个类现有成员的行为。对于从一个现有类的继承,我们说自己的新类“扩展”(extends)了那个现有的类。如下所示:class Foo extends Bar {类定义剩余的部分看起来是完全相同的。1885.2 Java访问指示符若新建一个包,并从另一个包内的某个类里继承,则唯一能够访问的成员就是原来那个包的public成员。当然,如果在相同的包里进行继承,那么继承获得的包能够访问所有“友好”的成员。有些时候,基础类的创建者喜欢提供一个特殊的成员,并允许访问衍生类。这正是protected的工作。若往回引用5.2.2小节“public:接口访问”的那个Cookie.java文件,则下面这个类就不能访问“友好”的成员://: ChocolateChip.java// Can't access friendly member// in another classimport c05.dessert.*;public class ChocolateChip extends Cookie {public ChocolateChip() {System.out.println("ChocolateChip constructor");}public static void main(String[] args) {ChocolateChip x = new ChocolateChip();//! x.foo(); // Can't access foo}} ///:~对于继承,值得注意的一件有趣的事情是倘若方法foo()存在于类Cookie中,那么它也会存在于从Cookie继承的所有类中。但由于foo()在外部的包里是“友好”的,所以我们不能使用它。当然,亦可将其变成public。但这样一来,由于所有人都能自由访问它,所以可能并非我们所希望的局面。若象下面这样修改类Cookie:public class Cookie {public Cookie() {System.out.println("Cookie constructor");}protected void foo() {System.out.println("foo");}}那么仍然能在包dessert里“友好”地访问foo(),但从Cookie继承的其他东西亦可自由地访问它。然而,它并非公共的(public)。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:101895.3 接口与实现5.3 接口与实现我们通常认为访问控制是“隐藏实施细节”的一种方式。将数据和方法封装到类内后,可生成一种数据类型,它具有自己的特征与行为。但由于两方面重要的原因,访问为那个数据类型加上了自己的边界。第一个原因是规定客户程序员哪些能够使用,哪些不能。我们可在结构里构建自己的内部机制,不用担心客户程序员将其当作接口的一部分,从而自由地使用或者“滥用”。这个原因直接导致了第二个原因:我们需要将接口同实施细节分离开。若结构在一系列程序中使用,但用户除了将消息发给public接口之外,不能做其他任何事情,我们就可以改变不属于public的所有东西(如“友好的”、protected以及private),同时不要求用户对他们的代码作任何修改。我们现在是在一个面向对象的编程环境中,其中的一个类(class)实际是指“一类对象”,就象我们说“鱼类”或“鸟类”那样。从属于这个类的所有对象都共享这些特征与行为。“类”是对属于这一类的所有对象的外观及行为进行的一种描述。在一些早期OOP语言中,如Simula-67,关键字class的作用是描述一种新的数据类型。同样的关键字在大多数面向对象的编程语言里都得到了应用。它其实是整个语言的焦点:需要新建数据类型的场合比那些用于容纳数据和方法的“容器”多得多。在Java中,类是最基本的OOP概念。它是本书未采用粗体印刷的关键字之一——由于数量太多,所以会造成页面排版的严重混乱。为清楚起见,可考虑用特殊的样式创建一个类:将public成员置于最开头,后面跟随protected、友好以及private成员。这样做的好处是类的使用者可从上向下依次阅读,并首先看到对自己来说最重要的内容(即public成员,因为它们可从文件的外部访问),并在遇到非公共成员后停止阅读,后者已经属于内部实施细节的一部分了。然而,利用由javadoc提供支持的注释文档(已在第2章介绍),代码的可读性问题已在很大程度上得到了解决。public class X {public void pub1( ) { /* . . . */ }public void pub2( ) { /* . . . */ }public void pub3( ) { /* . . . */ }private void priv1( ) { /* . . . */ }private void priv2( ) { /* . . . */ }private void priv3( ) { /* . . . */ }private int i;// . . .}1905.3 接口与实现由于接口和实施细节仍然混合在一起,所以只是部分容易阅读。也就是说,仍然能够看到源码——实施的细节,因为它们需要保存在类里面。向一个类的消费者显示出接口实际是“类浏览器”的工作。这种工具能查找所有可用的类,总结出可对它们采取的全部操作(比如可以使用哪些成员等),并用一种清爽悦目的形式显示出来。到大家读到这本书的时候,所有优秀的Java开发工具都应推出了自己的浏览器。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:101915.4 类访问5.4 类访问在Java中,亦可用访问指示符判断出一个库内的哪些类可由那个库的用户使用。若想一个类能由客户程序员调用,可在类主体的起始花括号前面某处放置一个public关键字。它控制着客户程序员是否能够创建属于这个类的一个对象。为控制一个类的访问,指示符必须在关键字class之前出现。所以我们能够使用:public class Widget {也就是说,假若我们的库名是mylib,那么所有客户程序员都能访问Widget——通过下述语句:import mylib.Widget;或者import mylib.*;然而,我们同时还要注意到一些额外的限制:(1) 每个编译单元(文件)都只能有一个public类。每个编译单元有一个公共接口的概念是由那个公共类表达出来的。根据自己的需要,它可拥有任意多个提供支撑的“友好”类。但若在一个编译单元里使用了多个public类,编译器就会向我们提示一条出错消息。(2) public类的名字必须与包含了编译单元的那个文件的名字完全相符,甚至包括它的大小写形式。所以对于Widget来说,文件的名字必须是Widget.java,而不应是widget.java或者WIDGET.java。同样地,如果出现不符,就会报告一个编译期错误。(3) 可能(但并常见)有一个编译单元根本没有任何公共类。此时,可按自己的意愿任意指定文件名。如果已经获得了mylib内部的一个类,准备用它完成由Widget或者mylib内部的其他某些public类执行的任务,此时又会出现什么情况呢?我们不希望花费力气为客户程序员编制文档,并感觉以后某个时候也许会进行大手笔的修改,并将自己的类一起删掉,换成另一个不同的类。为获得这种灵活处理的能力,需要保证没有客户程序员能够依赖自己隐藏于mylib内部的特定实施细节。为达到这个目的,只需将public关键字从类中剔除即可,这样便把类变成了“友好的”(类仅能在包内使用)。1925.4 类访问注意不可将类设成private(那样会使除类之外的其他东西都不能访问它),也不能设成protected(注释④)。因此,我们现在对于类的访问只有两个选择:“友好的”或者public。若不愿其他任何人访问那个类,可将所有构建器设为private。这样一来,在类的一个static成员内部,除自己之外的其他所有人都无法创建属于那个类的一个对象(注释⑤)。如下例所示://: Lunch.java// Demonstrates class access specifiers.// Make a class effectively private// with private constructors:class Soup {private Soup() {}// (1) Allow creation via static method:public static Soup makeSoup() {return new Soup();}// (2) Create a static object and// return a reference upon request.// (The "Singleton" pattern):private static Soup ps1 = new Soup();public static Soup access() {return ps1;}public void f() {}}class Sandwich { // Uses Lunchvoid f() { new Lunch(); }}// Only one public class allowed per file:public class Lunch {void test() {// Can't do this! Private constructor://! Soup priv1 = new Soup();Soup priv2 = Soup.makeSoup();Sandwich f1 = new Sandwich();Soup.access().f();}} ///:~④:实际上,Java 1.1内部类既可以是“受到保护的”,也可以是“私有的”,但那属于特别情况。第7章会详细解释这个问题。⑤:亦可通过从那个类继承来实现。迄今为止,我们创建过的大多数方法都是要么返回void,要么返回一个基本数据类型。所以对下述定义来说:1935.4 类访问public static Soup access() {return psl;}它最开始多少会使人有些迷惑。位于方法名(access)前的单词指出方法到底返回什么。在这之前,我们看到的都是void,它意味着“什么也不返回”(void在英语里是“虚无”的意思。但亦可返回指向一个对象的句柄,此时出现的就是这个情况。该方法返回一个句柄,它指向类Soup的一个对象。Soup类向我们展示出如何通过将所有构建器都设为private,从而防止直接创建一个类。请记住,假若不明确地至少创建一个构建器,就会自动创建默认构建器(没有自变量)。若自己编写默认构建器,它就不会自动创建。把它变成private后,就没人能为那个类创建一个对象。但别人怎样使用这个类呢?上面的例子为我们揭示出了两个选择。第一个选择,我们可创建一个static方法,再通过它创建一个新的Soup,然后返回指向它的一个句柄。如果想在返回之前对Soup进行一些额外的操作,或者想了解准备创建多少个Soup对象(可能是为了限制它们的个数),这种方案无疑是特别有用的。第二个选择是采用“设计方案”(Design Pattern)技术,本书后面会对此进行详细介绍。通常方案叫作“独子”,因为它仅允许创建一个对象。类Soup的对象被创建成Soup的一个staticprivate成员,所以有一个而且只能有一个。除非通过public方法access(),否则根本无法访问它。正如早先指出的那样,如果不针对类的访问设置一个访问指示符,那么它会自动默认为“友好的”。这意味着那个类的对象可由包内的其他类创建,但不能由包外创建。请记住,对于相同目录内的所有文件,如果没有明确地进行package声明,那么它们都默认为那个目录的默认包的一部分。然而,假若那个类一个static成员的属性是public,那么客户程序员仍然能够访问那个static成员——即使它们不能创建属于那个类的一个对象。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:101945.5 总结5.5 总结对于任何关系,最重要的一点都是规定好所有方面都必须遵守的界限或规则。创建一个库时,相当于建立了同那个库的用户(即“客户程序员”)的一种关系——那些用户属于另外的程序员,可能用我们的库自行构建一个应用程序,或者用我们的库构建一个更大的库。如果不制订规则,客户程序员就可以随心所欲地操作一个类的所有成员,无论我们本来愿不愿意其中的一些成员被直接操作。所有东西都在别人面前都暴露无遗。本章讲述了如何构建类,从而制作出理想的库。首先,我们讲述如何将一组类封装到一个库里。其次,我们讲述类如何控制对自己成员的访问。一般情况下,一个C程序项目会在50K到100K行代码之间的某个地方开始中断。这是由于C仅有一个“命名空间”,所以名字会开始互相抵触,从而造成额外的管理开销。而在Java中,package关键字、包命名方案以及import关键字为我们提供对名字的完全控制,所以命名冲突的问题可以很轻易地得到避免。有两方面的原因要求我们控制对成员的访问。第一个是防止用户接触那些他们不应碰的工具。对于数据类型的内部机制,那些工具是必需的。但它们并不属于用户接口的一部分,用户不必用它来解决自己的特定问题。所以将方法和字段变成“私有”(private)后,可极大方便用户。因为他们能轻易看出哪些对于自己来说是最重要的,以及哪些是自己需要忽略的。这样便简化了用户对一个类的理解。进行访问控制的第二个、也是最重要的一个原因是:允许库设计者改变类的内部工作机制,同时不必担心它会对客户程序员产生什么影响。最开始的时候,可用一种方法构建一个类,后来发现需要重新构建代码,以便达到更快的速度。如接口和实施细节早已进行了明确的分隔与保护,就可以轻松地达到自己的目的,不要求用户改写他们的代码。 利用Java中的访问指示符,可有效控制类的创建者。那个类的用户可确切知道哪些是自己能够使用的,哪些则是可以忽略的。但更重要的一点是,它可确保没有任何用户能依赖一个类的基础实施机制的任何部分。作为一个类的创建者,我们可自由修改基础的实施细节,这一改变不会对客户程序员产生任何影响,因为他们不能访问类的那一部分。 有能力改变基础的实施细节后,除了能在以后改进自己的设置之外,也同时拥有了“犯错误”的自由。无论当初计划与设计时有多么仔细,仍然有可能出现一些失误。由于知道自己能相当安全地犯下这种错误,所以可以放心大胆地进行更多、更自由的试验。这对自己编程水平的提高是很有帮助的,使整个项目最终能更快、更好地完成。一个类的公共接口是所有用户都能看见的,所以在进行分析与设计的时候,这是应尽量保证其准确性的最重要的一个部分。但也不必过于紧张,少许的误差仍然是允许的。若最初设计的接口存在少许问题,可考虑添加更多的方法,只要保证不删除客户程序员已在他们的代码里使用的东西。1955.5 总结Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:101965.6 练习5.6 练习(1) 用public、private、protected以及“友好的”数据成员及方法成员创建一个类。创建属于这个类的一个对象,并观察在试图访问所有类成员时会获得哪种类型的编译器错误提示。注意同一个目录内的类属于“默认”包的一部分。(2) 用protected数据创建一个类。在相同的文件里创建第二个类,用一个方法操纵第一个类里的protected数据。(3) 新建一个目录,并编辑自己的CLASSPATH,以便包括那个新目录。将P.class文件复制到自己的新目录,然后改变文件名、P类以及方法名(亦可考虑添加额外的输出,观察它的运行过程)。在一个不同的目录里创建另一个程序,令其使用自己的新类。(4) 在c05目录(假定在自己的CLASSPATH里)创建下述文件:214页程序然后在c05之外的另一个目录里创建下述文件:214-215页程序解释编译器为什么会产生一个错误。将Foreign(外部)类作为c05包的一部分改变了什么东西吗?Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:10197第6章 类再生第6章 类再生“Java引人注目的一项特性是代码的重复使用或者再生。但最具革命意义的是,除代码的复制和修改以外,我们还能做多得多的其他事情。”在象C那样的程序化语言里,代码的重复使用早已可行,但效果不是特别显著。与Java的其他地方一样,这个方案解决的也是与类有关的问题。我们通过创建新类来重复使用代码,但却用不着重新创建,可以直接使用别人已建好并调试好的现成类。但这样做必须保证不会干扰原有的代码。在这一章里,我们将介绍两个达到这一目标的方法。第一个最简单:在新类里简单地创建原有类的对象。我们把这种方法叫作“合成”,因为新类由现有类的对象合并而成。我们只是简单地重复利用代码的功能,而不是采用它的形式。第二种方法则显得稍微有些技巧。它创建一个新类,将其作为现有类的一个“类型”。我们可以原样采取现有类的形式,并在其中加入新代码,同时不会对现有的类产生影响。这种魔术般的行为叫作“继承”(Inheritance),涉及的大多数工作都是由编译器完成的。对于面向对象的程序设计,“继承”是最重要的基础概念之一。它对我们下一章要讲述的内容会产生一些额外的影响。对于合成与继承这两种方法,大多数语法和行为都是类似的(因为它们都要根据现有的类型生成新类型)。在本章,我们将深入学习这些代码再生或者重复使用的机制。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:101986.1 合成的语法6.1 合成的语法就以前的学习情况来看,事实上已进行了多次“合成”操作。为进行合成,我们只需在新类里简单地置入对象句柄即可。举个例子来说,假定需要在一个对象里容纳几个String对象、两种基本数据类型以及属于另一个类的一个对象。对于非基本类型的对象来说,只需将句柄置于新类即可;而对于基本数据类型来说,则需在自己的类中定义它们。如下所示(若执行该程序时有麻烦,请参见第3章3.1.2小节“赋值”)://: SprinklerSystem.java// Composition for code reusepackage c06;class WaterSource {private String s;WaterSource() {System.out.println("WaterSource()");s = new String("Constructed");}public String toString() { return s; }}public class SprinklerSystem {private String valve1, valve2, valve3, valve4;WaterSource source;int i;float f;void print() {System.out.println("valve1 = " + valve1);System.out.println("valve2 = " + valve2);System.out.println("valve3 = " + valve3);System.out.println("valve4 = " + valve4);System.out.println("i = " + i);System.out.println("f = " + f);System.out.println("source = " + source);}public static void main(String[] args) {SprinklerSystem x = new SprinklerSystem();x.print();}} ///:~WaterSource内定义的一个方法是比较特别的:toString()。大家不久就会知道,每种非基本类型的对象都有一个toString()方法。若编译器本来希望一个String,但却获得某个这样的对象,就会调用这个方法。所以在下面这个表达式中:1996.1 合成的语法System.out.println("source = " + source) ;编译器会发现我们试图向一个WaterSource添加一个String对象("source =")。这对它来说是不可接受的,因为我们只能将一个字串“添加”到另一个字串,所以它会说:“我要调用toString(),把source转换成字串!”经这样处理后,它就能编译两个字串,并将结果字串传递给一个System.out.println()。每次随同自己创建的一个类允许这种行为的时候,都只需要写一个toString()方法。如果不深究,可能会草率地认为编译器会为上述代码中的每个句柄都自动构造对象(由于Java的安全和谨慎的形象)。例如,可能以为它会为WaterSource调用默认构建器,以便初始化source。打印语句的输出事实上是:valve1 = nullvalve2 = nullvalve3 = nullvalve4 = nulli = 0f = 0.0source = null在类内作为字段使用的基本数据会初始化成零,就象第2章指出的那样。但对象句柄会初始化成null。而且假若试图为它们中的任何一个调用方法,就会产生一次“违例”。这种结果实际是相当好的(而且很有用),我们可在不丢弃一次违例的前提下,仍然把它们打印出来。编译器并不只是为每个句柄创建一个默认对象,因为那样会在许多情况下招致不必要的开销。如希望句柄得到初始化,可在下面这些地方进行:(1) 在对象定义的时候。这意味着它们在构建器调用之前肯定能得到初始化。(2) 在那个类的构建器中。(3) 紧靠在要求实际使用那个对象之前。这样做可减少不必要的开销——假如对象并不需要创建的话。下面向大家展示了所有这三种方法:2006.1 合成的语法//: Bath.java// Constructor initialization with compositionclass Soap {private String s;Soap() {System.out.println("Soap()");s = new String("Constructed");}public String toString() { return s; }}public class Bath {private String// Initializing at point of definition:s1 = new String("Happy"),s2 = "Happy",s3, s4;Soap castille;int i;float toy;Bath() {System.out.println("Inside Bath()");s3 = new String("Joy");i = 47;toy = 3.14f;castille = new Soap();}void print() {// Delayed initialization:if(s4 == null)s4 = new String("Joy");System.out.println("s1 = " + s1);System.out.println("s2 = " + s2);System.out.println("s3 = " + s3);System.out.println("s4 = " + s4);System.out.println("i = " + i);System.out.println("toy = " + toy);System.out.println("castille = " + castille);}public static void main(String[] args) {Bath b = new Bath();b.print();}} ///:~请注意在Bath构建器中,在所有初始化开始之前执行了一个语句。如果不在定义时进行初始化,仍然不能保证能在将一条消息发给一个对象句柄之前会执行任何初始化——除非出现不可避免的运行期违例。 下面是该程序的输出:2016.1 合成的语法Inside Bath()Soap()s1 = Happys2 = Happys3 = Joys4 = Joyi = 47toy = 3.14castille = Constructed调用print()时,它会填充s4,使所有字段在使用之前都获得正确的初始化。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:102026.2 继承的语法6.2 继承的语法继承与Java(以及其他OOP语言)非常紧密地结合在一起。我们早在第1章就为大家引入了继承的概念,并在那章之后到本章之前的各章里不时用到,因为一些特殊的场合要求必须使用继承。除此以外,创建一个类时肯定会进行继承,因为若非如此,会从Java的标准根类Object中继承。用于合成的语法是非常简单且直观的。但为了进行继承,必须采用一种全然不同的形式。需要继承的时候,我们会说:“这个新类和那个旧类差不多。”为了在代码里表面这一观念,需要给出类名。但在类主体的起始花括号之前,需要放置一个关键字extends,在后面跟随“基础类”的名字。若采取这种做法,就可自动获得基础类的所有数据成员以及方法。下面是一个例子:2036.2 继承的语法//: Detergent.java// Inheritance syntax & propertiesclass Cleanser {private String s = new String("Cleanser");public void append(String a) { s += a; }public void dilute() { append(" dilute()"); }public void apply() { append(" apply()"); }public void scrub() { append(" scrub()"); }public void print() { System.out.println(s); }public static void main(String[] args) {Cleanser x = new Cleanser();x.dilute(); x.apply(); x.scrub();x.print();}}public class Detergent extends Cleanser {// Change a method:public void scrub() {append(" Detergent.scrub()");super.scrub(); // Call base-class version}// Add methods to the interface:public void foam() { append(" foam()"); }// Test the new class:public static void main(String[] args) {Detergent x = new Detergent();x.dilute();x.apply();x.scrub();x.foam();x.print();System.out.println("Testing base class:");Cleanser.main(args);}} ///:~这个例子向大家展示了大量特性。首先,在Cleanser append()方法里,字串同一个s连接起来。这是用“+=”运算符实现的。同“+”一样,“+=”被Java用于对字串进行“过载”处理。其次,无论Cleanser还是Detergent都包含了一个main()方法。我们可为自己的每个类都创建一个main()。通常建议大家象这样进行编写代码,使自己的测试代码能够封装到类内。即便在程序中含有数量众多的类,但对于在命令行请求的public类,只有main()才会得到调用。所以在这种情况下,当我们使用“java Detergent”的时候,调用的是Degergent.main()——即使Cleanser并非一个public类。采用这种将main()置入每个类的做法,可方便地为每个类都进行单元测试。而且在完成测试以后,毋需将main()删去;可把它保留下来,用于以后的测试。在这里,大家可看到Deteregent.main()对Cleanser.main()的调用是明确进行的。2046.2 继承的语法需要着重强调的是Cleanser中的所有类都是public属性。请记住,倘若省略所有访问指示符,则成员默认为“友好的”。这样一来,就只允许对包成员进行访问。在这个包内,任何人都可使用那些没有访问指示符的方法。例如,Detergent将不会遇到任何麻烦。然而,假设来自另外某个包的类准备继承Cleanser,它就只能访问那些public成员。所以在计划继承的时候,一个比较好的规则是将所有字段都设为private,并将所有方法都设为public(protected成员也允许衍生出来的类访问它;以后还会深入探讨这一问题)。当然,在一些特殊的场合,我们仍然必须作出一些调整,但这并不是一个好的做法。注意Cleanser在它的接口中含有一系列方法:append(),dilute(),apply(),scrub()以及print()。由于Detergent是从Cleanser衍生出来的(通过extends关键字),所以它会自动获得接口内的所有这些方法——即使我们在Detergent里并未看到对它们的明确定义。这样一来,就可将继承想象成“对接口的重复利用”或者“接口的再生”(以后的实施细节可以自由设置,但那并非我们强调的重点)。正如在scrub()里看到的那样,可以获得在基础类里定义的一个方法,并对其进行修改。在这种情况下,我们通常想在新版本里调用来自基础类的方法。但在scrub()里,不可只是简单地发出对scrub()的调用。那样便造成了递归调用,我们不愿看到这一情况。为解决这个问题,Java提供了一个super关键字,它引用当前类已从中继承的一个“超类”(Superclass)。所以表达式super.scrub()调用的是方法scrub()的基础类版本。进行继承时,我们并不限于只能使用基础类的方法。亦可在衍生出来的类里加入自己的新方法。这时采取的做法与在普通类里添加其他任何方法是完全一样的:只需简单地定义它即可。extends关键字提醒我们准备将新方法加入基础类的接口里,对其进行“扩展”。foam()便是这种做法的一个产物。在Detergent.main()里,我们可看到对于Detergent对象,可调用Cleanser以及Detergent内所有可用的方法(如foam())。6.2.1 初始化基础类由于这儿涉及到两个类——基础类及衍生类,而不再是以前的一个,所以在想象衍生类的结果对象时,可能会产生一些迷惑。从外部看,似乎新类拥有与基础类相同的接口,而且可包含一些额外的方法和字段。但继承并非仅仅简单地复制基础类的接口了事。创建衍生类的一个对象时,它在其中包含了基础类的一个“子对象”。这个子对象就象我们根据基础类本身创建了它的一个对象。从外部看,基础类的子对象已封装到衍生类的对象里了。当然,基础类子对象应该正确地初始化,而且只有一种方法能保证这一点:在构建器中执行初始化,通过调用基础类构建器,后者有足够的能力和权限来执行对基础类的初始化。在衍生类的构建器中,Java会自动插入对基础类构建器的调用。下面这个例子向大家展示了对这种三级继承的应用:2056.2 继承的语法//: Cartoon.java// Constructor calls during inheritanceclass Art {Art() {System.out.println("Art constructor");}}class Drawing extends Art {Drawing() {System.out.println("Drawing constructor");}}public class Cartoon extends Drawing {Cartoon() {System.out.println("Cartoon constructor");}public static void main(String[] args) {Cartoon x = new Cartoon();}} ///:~该程序的输出显示了自动调用:Art constructorDrawing constructorCartoon constructor可以看出,构建是在基础类的“外部”进行的,所以基础类会在衍生类访问它之前得到正确的初始化。 即使没有为Cartoon()创建一个构建器,编译器也会为我们自动合成一个默认构建器,并发出对基础类构建器的调用。1. 含有自变量的构建器上述例子有自己默认的构建器;也就是说,它们不含任何自变量。编译器可以很容易地调用它们,因为不存在具体传递什么自变量的问题。如果类没有默认的自变量,或者想调用含有一个自变量的某个基础类构建器,必须明确地编写对基础类的调用代码。这是用super关键字以及适当的自变量列表实现的,如下所示:2066.2 继承的语法//: Chess.java// Inheritance, constructors and argumentsclass Game {Game(int i) {System.out.println("Game constructor");}}class BoardGame extends Game {BoardGame(int i) {super(i);System.out.println("BoardGame constructor");}}public class Chess extends BoardGame {Chess() {super(11);System.out.println("Chess constructor");}public static void main(String[] args) {Chess x = new Chess();}} ///:~如果不调用BoardGames()内的基础类构建器,编译器就会报告自己找不到Games()形式的一个构建器。除此以外,在衍生类构建器中,对基础类构建器的调用是必须做的第一件事情(如操作失当,编译器会向我们指出)。1. 捕获基本构建器的违例正如刚才指出的那样,编译器会强迫我们在衍生类构建器的主体中首先设置对基础类构建器的调用。这意味着在它之前不能出现任何东西。正如大家在第9章会看到的那样,这同时也会防止衍生类构建器捕获来自一个基础类的任何违例事件。显然,这有时会为我们造成不便。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:102076.3 合成与继承的结合6.3 合成与继承的结合许多时候都要求将合成与继承两种技术结合起来使用。下面这个例子展示了如何同时采用继承与合成技术,从而创建一个更复杂的类,同时进行必要的构建器初始化工作://: PlaceSetting.java// Combining composition & inheritanceclass Plate {Plate(int i) {System.out.println("Plate constructor");}}class DinnerPlate extends Plate {DinnerPlate(int i) {super(i);System.out.println("DinnerPlate constructor");}}class Utensil {Utensil(int i) {System.out.println("Utensil constructor");}}class Spoon extends Utensil {Spoon(int i) {super(i);System.out.println("Spoon constructor");}}class Fork extends Utensil {Fork(int i) {super(i);System.out.println("Fork constructor");}}class Knife extends Utensil {Knife(int i) {super(i);System.out.println("Knife constructor");}}2086.3 合成与继承的结合// A cultural way of doing something:class Custom {Custom(int i) {System.out.println("Custom constructor");}}public class PlaceSetting extends Custom {Spoon sp;Fork frk;Knife kn;DinnerPlate pl;PlaceSetting(int i) {super(i + 1);sp = new Spoon(i + 2);frk = new Fork(i + 3);kn = new Knife(i + 4);pl = new DinnerPlate(i + 5);System.out.println("PlaceSetting constructor");}public static void main(String[] args) {PlaceSetting x = new PlaceSetting(9);}} ///:~尽管编译器会强迫我们对基础类进行初始化,并要求我们在构建器最开头做这一工作,但它并不会监视我们是否正确初始化了成员对象。所以对此必须特别加以留意。6.3.1 确保正确的清除Java不具备象C++的“破坏器”那样的概念。在C++中,一旦破坏(清除)一个对象,就会自动调用破坏器方法。之所以将其省略,大概是由于在Java中只需简单地忘记对象,不需强行破坏它们。垃圾收集器会在必要的时候自动回收内存。垃圾收集器大多数时候都能很好地工作,但在某些情况下,我们的类可能在自己的存在时期采取一些行动,而这些行动要求必须进行明确的清除工作。正如第4章已经指出的那样,我们并不知道垃圾收集器什么时候才会显身,或者说不知它何时会调用。所以一旦希望为一个类清除什么东西,必须写一个特别的方法,明确、专门地来做这件事情。同时,还要让客户程序员知道他们必须调用这个方法。而在所有这一切的后面,就如第9章(违例控制)要详细解释的那样,必须将这样的清除代码置于一个finally从句中,从而防范任何可能出现的违例事件。下面介绍的是一个计算机辅助设计系统的例子,它能在屏幕上描绘图形://: CADSystem.java// Ensuring proper cleanupimport java.util.*;2096.3 合成与继承的结合class Shape {Shape(int i) {System.out.println("Shape constructor");}void cleanup() {System.out.println("Shape cleanup");}}class Circle extends Shape {Circle(int i) {super(i);System.out.println("Drawing a Circle");}void cleanup() {System.out.println("Erasing a Circle");super.cleanup();}}class Triangle extends Shape {Triangle(int i) {super(i);System.out.println("Drawing a Triangle");}void cleanup() {System.out.println("Erasing a Triangle");super.cleanup();}}class Line extends Shape {private int start, end;Line(int start, int end) {super(start);this.start = start;this.end = end;System.out.println("Drawing a Line: " +start + ", " + end);}void cleanup() {System.out.println("Erasing a Line: " +start + ", " + end);super.cleanup();}}public class CADSystem extends Shape {private Circle c;private Triangle t;private Line[] lines = new Line[10];CADSystem(int i) {super(i + 1);2106.3 合成与继承的结合for(int j = 0; j < 10; j++)lines[j] = new Line(j, j*j);c = new Circle(1);t = new Triangle(1);System.out.println("Combined constructor");}void cleanup() {System.out.println("CADSystem.cleanup()");t.cleanup();c.cleanup();for(int i = 0; i < lines.length; i++)lines[i].cleanup();super.cleanup();}public static void main(String[] args) {CADSystem x = new CADSystem(47);try {// Code and exception handling...} finally {x.cleanup();}}} ///:~这个系统中的所有东西都属于某种Shape(几何形状)。Shape本身是一种Object(对象),因为它是从根类明确继承的。每个类都重新定义了Shape的cleanup()方法,同时还要用super调用那个方法的基础类版本。尽管对象存在期间调用的所有方法都可负责做一些要求清除的工作,但对于特定的Shape类——Circle(圆)、Triangle(三角形)以及Line(直线),它们都拥有自己的构建器,能完成“作图”(draw)任务。每个类都有它们自己的cleanup()方法,用于将非内存的东西恢复回对象存在之前的景象。在main()中,可看到两个新关键字:try和finally。我们要到第9章才会向大家正式引荐它们。其中,try关键字指出后面跟随的块(由花括号定界)是一个“警戒区”。也就是说,它会受到特别的待遇。其中一种待遇就是:该警戒区后面跟随的finally从句的代码肯定会得以执行——不管try块到底存不存在(通过违例控制技术,try块可有多种不寻常的应用)。在这里,finally从句的意思是“总是为x调用cleanup(),无论会发生什么事情”。这些关键字将在第9章进行全面、完整的解释。在自己的清除方法中,必须注意对基础类以及成员对象清除方法的调用顺序——假若一个子对象要以另一个为基础。通常,应采取与C++编译器对它的“破坏器”采取的同样的形式:首先完成与类有关的所有特殊工作(可能要求基础类元素仍然可见),然后调用基础类清除方法,就象这儿演示的那样。许多情况下,清除可能并不是个问题;只需让垃圾收集器尽它的职责即可。但一旦必须由自己明确清除,就必须特别谨慎,并要求周全的考虑。1. 垃圾收集的顺序2116.3 合成与继承的结合不能指望自己能确切知道何时会开始垃圾收集。垃圾收集器可能永远不会得到调用。即使得到调用,它也可能以自己愿意的任何顺序回收对象。除此以外,Java 1.0实现的垃圾收集器机制通常不会调用finalize()方法。除内存的回收以外,其他任何东西都最好不要依赖垃圾收集器进行回收。若想明确地清除什么,请制作自己的清除方法,而且不要依赖finalize()。然而正如以前指出的那样,可强迫Java1.1调用所有收尾模块(Finalizer)。6.3.2 名字的隐藏只有C++程序员可能才会惊讶于名字的隐藏,因为它的工作原理与在C++里是完全不同的。如果Java基础类有一个方法名被“过载”使用多次,在衍生类里对那个方法名的重新定义就不会隐藏任何基础类的版本。所以无论方法在这一级还是在一个基础类中定义,过载都会生效://: Hide.java// Overloading a base-class method name// in a derived class does not hide the// base-class versionsclass Homer {char doh(char c) {System.out.println("doh(char)");return 'd';}float doh(float f) {System.out.println("doh(float)");return 1.0f;}}class Milhouse {}class Bart extends Homer {void doh(Milhouse m) {}}class Hide {public static void main(String[] args) {Bart b = new Bart();b.doh(1); // doh(float) usedb.doh('x');b.doh(1.0f);b.doh(new Milhouse());}} ///:~正如下一章会讲到的那样,很少会用与基础类里完全一致的签名和返回类型来覆盖同名的方法,否则会使人感到迷惑(这正是C++不允许那样做的原因,所以能够防止产生一些不必要的错误)。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2126.3 合成与继承的结合2018-03-13 01:23:102136.4 到底选择合成还是继承6.4 到底选择合成还是继承无论合成还是继承,都允许我们将子对象置于自己的新类中。大家或许会奇怪两者间的差异,以及到底该如何选择。 如果想利用新类内部一个现有类的特性,而不想使用它的接口,通常应选择合成。也就是说,我们可嵌入一个对象,使自己能用它实现新类的特性。但新类的用户会看到我们已定义的接口,而不是来自嵌入对象的接口。考虑到这种效果,我们需在新类里嵌入现有类的private对象。有些时候,我们想让类用户直接访问新类的合成。也就是说,需要将成员对象的属性变为public。成员对象会将自身隐藏起来,所以这是一种安全的做法。而且在用户知道我们准备合成一系列组件时,接口就更容易理解。car(汽车)对象便是一个很好的例子:2146.4 到底选择合成还是继承//: Car.java// Composition with public objectsclass Engine {public void start() {}public void rev() {}public void stop() {}}class Wheel {public void inflate(int psi) {}}class Window {public void rollup() {}public void rolldown() {}}class Door {public Window window = new Window();public void open() {}public void close() {}}public class Car {public Engine engine = new Engine();public Wheel[] wheel = new Wheel[4];public Door left = new Door(),right = new Door(); // 2-doorCar() {for(int i = 0; i < 4; i++)wheel[i] = new Wheel();}public static void main(String[] args) {Car car = new Car();car.left.window.rollup();car.wheel[0].inflate(72);}} ///:~由于汽车的装配是故障分析时需要考虑的一项因素(并非只是基础设计简单的一部分),所以有助于客户程序员理解如何使用类,而且类创建者的编程复杂程度也会大幅度降低。如选择继承,就需要取得一个现成的类,并制作它的一个特殊版本。通常,这意味着我们准备使用一个常规用途的类,并根据特定的需求对其进行定制。只需稍加想象,就知道自己不能用一个车辆对象来合成一辆汽车——汽车并不“包含”车辆;相反,它“属于”车辆的一种类别。“属于”关系是用继承来表达的,而“包含”关系是用合成来表达的。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:102156.4 到底选择合成还是继承2166.5 protected6.5 protected现在我们已理解了继承的概念,protected这个关键字最后终于有了意义。在理想情况下,private成员随时都是“私有”的,任何人不得访问。但在实际应用中,经常想把某些东西深深地藏起来,但同时允许访问衍生类的成员。protected关键字可帮助我们做到这一点。它的意思是“它本身是私有的,但可由从这个类继承的任何东西或者同一个包内的其他任何东西访问”。也就是说,Java中的protected会成为进入“友好”状态。我们采取的最好的做法是保持成员的private状态——无论如何都应保留对基 础的实施细节进行修改的权利。在这一前提下,可通过protected方法允许类的继承者进行受到控制的访问://: Orc.java// The protected keywordimport java.util.*;class Villain {private int i;protected int read() { return i; }protected void set(int ii) { i = ii; }public Villain(int ii) { i = ii; }public int value(int m) { return m*i; }}public class Orc extends Villain {private int j;public Orc(int jj) { super(jj); j = jj; }public void change(int x) { set(x); }} ///:~可以看到,change()拥有对set()的访问权限,因为它的属性是protected(受到保护的)。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:102176.6 累积开发6.6 累积开发继承的一个好处是它支持“累积开发”,允许我们引入新的代码,同时不会为现有代码造成错误。这样可将新错误隔离到新代码里。通过从一个现成的、功能性的类继承,同时增添成员新的数据成员及方法(并重新定义现有方法),我们可保持现有代码原封不动(另外有人也许仍在使用它),不会为其引入自己的编程错误。一旦出现错误,就知道它肯定是由于自己的新代码造成的。这样一来,与修改现有代码的主体相比,改正错误所需的时间和精力就可以少很多。类的隔离效果非常好,这是许多程序员事先没有预料到的。甚至不需要方法的源代码来实现代码的再生。最多只需要导入一个包(这对于继承和合并都是成立的)。 ``` 大家要记住这样一个重点:程序开发是一个不断递增或者累积的过程,就象人们学习知识一样。当然可根据要求进行尽可能多的分析,但在一个项目的设计之初,谁都不可能提前获知所有的答案。如果能将自己的项目看作一个有机的、能不断进步的生物,从而不断地发展和改进它,就有望获得更大的成功以及更直接的反馈。尽管继承是一种非常有用的技术,但在某些情况下,特别是在项目稳定下来以后,仍然需要从新的角度考察自己的类结构,将其收缩成一个更灵活的结构。请记住,继承是对一种特殊关系的表达,意味着“这个新类属于那个旧类的一种类型”。我们的程序不应纠缠于一些细树末节,而应着眼于创建和操作各种类型的对象,用它们表达出来自“问题空间”的一个模型。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:102186.7 上溯造型6.7 上溯造型继承最值得注意的地方就是它没有为新类提供方法。继承是对新类和基础类之间的关系的一种表达。可这样总结该关系:“新类属于现有类的一种类型”。这种表达并不仅仅是对继承的一种形象化解释,继承是直接由语言提供支持的。作为一个例子,大家可考虑一个名为Instrument的基础类,它用于表示乐器;另一个衍生类叫作Wind。由于继承意味着基础类的所有方法亦可在衍生出来的类中使用,所以我们发给基础类的任何消息亦可发给衍生类。若Instrument类有一个play()方法,则Wind设备也会有这个方法。这意味着我们能肯定地认为一个Wind对象也是Instrument的一种类型。下面这个例子揭示出编译器如何提供对这一概念的支持://: Wind.java// Inheritance & upcastingimport java.util.*;class Instrument {public void play() {}static void tune(Instrument i) {// ...i.play();}}// Wind objects are instruments// because they have the same interface:class Wind extends Instrument {public static void main(String[] args) {Wind flute = new Wind();Instrument.tune(flute); // Upcasting}} ///:~这个例子中最有趣的无疑是tune()方法,它能接受一个Instrument句柄。但在Wind.main()中,tune()方法是通过为其赋予一个Wind句柄来调用的。由于Java对类型检查特别严格,所以大家可能会感到很奇怪,为什么接收一种类型的方法也能接收另一种类型呢?但是,我们一定要认识到一个Wind对象也是一个Instrument对象。而且对于不在Wind中的一个Instrument(乐器),没有方法可以由tune()调用。在tune()中,代码适用于Instrument以及从Instrument衍生出来的任何东西。在这里,我们将从一个Wind句柄转换成一个Instrument句柄的行为叫作“上溯造型”。6.7.1 何谓“上溯造型”?2196.7 上溯造型之所以叫作这个名字,除了有一定的历史原因外,也是由于在传统意义上,类继承图的画法是根位于最顶部,再逐渐向下扩展(当然,可根据自己的习惯用任何方法描绘这种图)。因素,Wind.java的继承图就象下面这个样子:由于造型的方向是从衍生类到基础类,箭头朝上,所以通常把它叫作“上溯造型”,即Upcasting。上溯造型肯定是安全的,因为我们是从一个更特殊的类型到一个更常规的类型。换言之,衍生类是基础类的一个超集。它可以包含比基础类更多的方法,但它至少包含了基础类的方法。进行上溯造型的时候,类接口可能出现的唯一一个问题是它可能丢失方法,而不是赢得这些方法。这便是在没有任何明确的造型或者其他特殊标注的情况下,编译器为什么允许上溯造型的原因所在。也可以执行下溯造型,但这时会面临第11章要详细讲述的一种困境。1. 再论合成与继承在面向对象的程序设计中,创建和使用代码最可能采取的一种做法是:将数据和方法统一封装到一个类里,并且使用那个类的对象。有些时候,需通过“合成”技术用现成的类来构造新类。而继承是最少见的一种做法。因此,尽管继承在学习OOP的过程中得到了大量的强调,但并不意味着应该尽可能地到处使用它。相反,使用它时要特别慎重。只有在清楚知道继承在所有方法中最有效的前提下,才可考虑它。为判断自己到底应该选用合成还是继承,一个最简单的办法就是考虑是否需要从新类上溯造型回基础类。若必须上溯,就需要继承。但如果不需要上溯造型,就应提醒自己防止继承的滥用。在下一章里(多形性),会向大家介绍必须进行上溯造型的一种场合。但只要记住经常问自己“我真的需要上溯造型吗”,对于合成还是继承的选择就不应该是个太大的问题。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:102206.8 final关键字6.8 final关键字由于语境(应用环境)不同,final关键字的含义可能会稍微产生一些差异。但它最一般的意思就是声明“这个东西不能改变”。之所以要禁止改变,可能是考虑到两方面的因素:设计或效率。由于这两个原因颇有些区别,所以也许会造成final关键字的误用。在接下去的小节里,我们将讨论final关键字的三种应用场合:数据、方法以及类。6.8.1 final数据许多程序设计语言都有自己的办法告诉编译器某个数据是“常数”。常数主要应用于下述两个方面:(1) 编译期常数,它永远不会改变(2) 在运行期初始化的一个值,我们不希望它发生变化对于编译期的常数,编译器(程序)可将常数值“封装”到需要的计算过程里。也就是说,计算可在编译期间提前执行,从而节省运行时的一些开销。在Java中,这些形式的常数必须属于基本数据类型(Primitives),而且要用final关键字进行表达。在对这样的一个常数进行定义的时候,必须给出一个值。无论static还是final字段,都只能存储一个数据,而且不得改变。若随同对象句柄使用final,而不是基本数据类型,它的含义就稍微让人有点儿迷糊了。对于基本数据类型,final会将值变成一个常数;但对于对象句柄,final会将句柄变成一个常数。进行声明时,必须将句柄初始化到一个具体的对象。而且永远不能将句柄变成指向另一个对象。然而,对象本身是可以修改的。Java对此未提供任何手段,可将一个对象直接变成一个常数(但是,我们可自己编写一个类,使其中的对象具有“常数”效果)。这一限制也适用于数组,它也属于对象。下面是演示final字段用法的一个例子:2216.8 final关键字//: FinalData.java// The effect of final on fieldsclass Value {int i = 1;}public class FinalData {// Can be compile-time constantsfinal int i1 = 9;static final int I2 = 99;// Typical public constant:public static final int I3 = 39;// Cannot be compile-time constants:final int i4 = (int)(Math.random()*20);static final int i5 = (int)(Math.random()*20);Value v1 = new Value();final Value v2 = new Value();static final Value v3 = new Value();//! final Value v4; // Pre-Java 1.1 Error:// no initializer// Arrays:final int[] a = { 1, 2, 3, 4, 5, 6 };public void print(String id) {System.out.println(id + ": " + "i4 = " + i4 +", i5 = " + i5);}public static void main(String[] args) {FinalData fd1 = new FinalData();//! fd1.i1++; // Error: can't change valuefd1.v2.i++; // Object isn't constant!fd1.v1 = new Value(); // OK -- not finalfor(int i = 0; i < fd1.a.length; i++)fd1.a[i]++; // Object isn't constant!//! fd1.v2 = new Value(); // Error: Can't//! fd1.v3 = new Value(); // change handle//! fd1.a = new int[3];fd1.print("fd1");System.out.println("Creating new FinalData");FinalData fd2 = new FinalData();fd1.print("fd1");fd2.print("fd2");}} ///:~2226.8 final关键字由于i1和I2都是具有final属性的基本数据类型,并含有编译期的值,所以它们除了能作为编译期的常数使用外,在任何导入方式中也不会出现任何不同。I3是我们体验此类常数定义时更典型的一种方式:public表示它们可在包外使用;Static强调它们只有一个;而final表明它是一个常数。注意对于含有固定初始化值(即编译期常数)的fianl static基本数据类型,它们的名字根据规则要全部采用大写。也要注意i5在编译期间是未知的,所以它没有大写。不能由于某样东西的属性是final,就认定它的值能在编译时期知道。i4和i5向大家证明了这一点。它们在运行期间使用随机生成的数字。例子的这一部分也向大家揭示出将final值设为static和非static之间的差异。只有当值在运行期间初始化的前提下,这种差异才会揭示出来。因为编译期间的值被编译器认为是相同的。这种差异可从输出结果中看出:fd1: i4 = 15, i5 = 9Creating new FinalDatafd1: i4 = 15, i5 = 9fd2: i4 = 10, i5 = 9注意对于fd1和fd2来说,i4的值是唯一的,但i5的值不会由于创建了另一个FinalData对象而发生改变。那是因为它的属性是static,而且在载入时初始化,而非每创建一个对象时初始化。从v1到v4的变量向我们揭示出final句柄的含义。正如大家在main()中看到的那样,并不能认为由于v2属于final,所以就不能再改变它的值。然而,我们确实不能再将v2绑定到一个新对象,因为它的属性是final。这便是final对于一个句柄的确切含义。我们会发现同样的含义亦适用于数组,后者只不过是另一种类型的句柄而已。将句柄变成final看起来似乎不如将基本数据类型变成final那么有用。1. 空白finalJava 1.1允许我们创建“空白final”,它们属于一些特殊的字段。尽管被声明成final,但却未得到一个初始值。无论在哪种情况下,空白final都必须在实际使用前得到正确的初始化。而且编译器会主动保证这一规定得以贯彻。然而,对于final关键字的各种应用,空白final具有最大的灵活性。举个例子来说,位于类内部的一个final字段现在对每个对象都可以有所不同,同时依然保持其“不变”的本质。下面列出一个例子:2236.8 final关键字//: BlankFinal.java// "Blank" final data membersclass Poppet { }class BlankFinal {final int i = 0; // Initialized finalfinal int j; // Blank finalfinal Poppet p; // Blank final handle// Blank finals MUST be initialized// in the constructor:BlankFinal() {j = 1; // Initialize blank finalp = new Poppet();}BlankFinal(int x) {j = x; // Initialize blank finalp = new Poppet();}public static void main(String[] args) {BlankFinal bf = new BlankFinal();}} ///:~现在强行要求我们对final进行赋值处理——要么在定义字段时使用一个表达 式,要么在每个构建器中。这样就可以确保final字段在使用前获得正确的初始化。1. final自变量Java 1.1允许我们将自变量设成final属性,方法是在自变量列表中对它们进行适当的声明。这意味着在一个方法的内部,我们不能改变自变量句柄指向的东西。如下所示:2246.8 final关键字//: FinalArguments.java// Using "final" with method argumentsclass Gizmo {public void spin() {}}public class FinalArguments {void with(final Gizmo g) {//! g = new Gizmo(); // Illegal -- g is finalg.spin();}void without(Gizmo g) {g = new Gizmo(); // OK -- g not finalg.spin();}// void f(final int i) { i++; } // Can't change// You can only read from a final primitive:int g(final int i) { return i + 1; }public static void main(String[] args) {FinalArguments bf = new FinalArguments();bf.without(null);bf.with(null);}} ///:~注意此时仍然能为final自变量分配一个null(空)句柄,同时编译器不会捕获它。这与我们对非final自变量采取的操作是一样的。方法f()和g()向我们展示出基本类型的自变量为final时会发生什么情况:我们只能读取自变量,不可改变它。6.8.2 final方法之所以要使用final方法,可能是出于对两方面理由的考虑。第一个是为方法“上锁”,防止任何继承类改变它的本来含义。设计程序时,若希望一个方法的行为在继承期间保持不变,而且不可被覆盖或改写,就可以采取这种做法。 采用final方法的第二个理由是程序执行的效率。将一个方法设成final后,编译器就可以把对那个方法的所有调用都置入“嵌入”调用里。只要编译器发现一个final方法调用,就会(根据它自己的判断)忽略为执行方法调用机制而采取的常规代码插入方法(将自变量压入堆栈;跳至方法代码并执行它;跳回来;清除堆栈自变量;最后对返回值进行处理)。相反,它会用方法主体内实际代码的一个副本来替换方法调用。这样做可避免方法调用时的系统开销。当然,若方法体积太大,那么程序也会变得雍肿,可能受到到不到嵌入代码所带来的任何性能提升。因为任何提升都被花在方法内部的时间抵消了。Java编译器能自动侦测这些情况,并颇为“明智”地决定是否嵌入一个final方法。然而,最好还是不要完全相信编译器能正确地作出所有判断。通常,只有在方法的代码量非常少,或者想明确禁止方法被覆盖的时候,才应考虑将一个方法设为final。2256.8 final关键字类内所有private方法都自动成为final。由于我们不能访问一个private方法,所以它绝对不会被其他方法覆盖(若强行这样做,编译器会给出错误提示)。可为一个private方法添加final指示符,但却不能为那个方法提供任何额外的含义。6.8.3 final类如果说整个类都是final(在它的定义前冠以final关键字),就表明自己不希望从这个类继承,或者不允许其他任何人采取这种操作。换言之,出于这样或那样的原因,我们的类肯定不需要进行任何改变;或者出于安全方面的理由,我们不希望进行子类化(子类处理)。除此以外,我们或许还考虑到执行效率的问题,并想确保涉及这个类各对象的所有行动都要尽可能地有效。如下所示://: Jurassic.java// Making an entire class finalclass SmallBrain {}final class Dinosaur {int i = 7;int j = 1;SmallBrain x = new SmallBrain();void f() {}}//! class Further extends Dinosaur {}// error: Cannot extend final class 'Dinosaur'public class Jurassic {public static void main(String[] args) {Dinosaur n = new Dinosaur();n.f();n.i = 40;n.j++;}} ///:~注意数据成员既可以是final,也可以不是,取决于我们具体选择。应用于final的规则同样适用于数据成员,无论类是否被定义成final。将类定义成final后,结果只是禁止进行继承——没有更多的限制。然而,由于它禁止了继承,所以一个final类中的所有方法都默认为final。因为此时再也无法覆盖它们。所以与我们将一个方法明确声明为final一样,编译器此时有相同的效率选择。可为final类内的一个方法添加final指示符,但这样做没有任何意义。6.8.4 final的注意事项2266.8 final关键字设计一个类时,往往需要考虑是否将一个方法设为final。可能会觉得使用自己的类时执行效率非常重要,没有人想覆盖自己的方法。这种想法在某些时候是正确的。但要慎重作出自己的假定。通常,我们很难预测一个类以后会以什么样的形式再生或重复利用。常规用途的类尤其如此。若将一个方法定义成final,就可能杜绝了在其他程序员的项目中对自己的类进行继承的途径,因为我们根本没有想到它会象那样使用。标准Java库是阐述这一观点的最好例子。其中特别常用的一个类是Vector。如果我们考虑代码的执行效率,就会发现只有不把任何方法设为final,才能使其发挥更大的作用。我们很容易就会想到自己应继承和覆盖如此有用的一个类,但它的设计者却否定了我们的想法。但我们至少可以用两个理由来反驳他们。首先,Stack(堆栈)是从Vector继承来的,亦即Stack“是”一个Vector,这种说法是不确切的。其次,对于Vector许多重要的方法,如addElement()以及elementAt()等,它们都变成了synchronized(同步的)。正如在第14章要讲到的那样,这会造成显著的性能开销,可能会把final提供的性能改善抵销得一干二净。因此,程序员不得不猜测到底应该在哪里进行优化。在标准库里居然采用了如此笨拙的设计,真不敢想象会在程序员里引发什么样的情绪。另一个值得注意的是Hashtable(散列表),它是另一个重要的标准类。该类没有采用任何final方法。正如我们在本书其他地方提到的那样,显然一些类的设计人员与其他设计人员有着全然不同的素质(注意比较Hashtable极短的方法名与Vecor的方法名)。对类库的用户来说,这显然是不应该如此轻易就能看出的。一个产品的设计变得不一致后,会加大用户的工作量。这也从另一个侧面强调了代码设计与检查时需要很强的责任心。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:102276.9 初始化和类装载6.9 初始化和类装载在许多传统语言里,程序都是作为启动过程的一部分一次性载入的。随后进行的是初始化,再是正式执行程序。在这些语言中,必须对初始化过程进行慎重的控制,保证static数据的初始化不会带来麻烦。比如在一个static数据获得初始化之前,就有另一个static数据希望它是一个有效值,那么在C++中就会造成问题。Java则没有这样的问题,因为它采用了不同的装载方法。由于Java中的一切东西都是对象,所以许多活动变得更加简单,这个问题便是其中的一例。正如下一章会讲到的那样,每个对象的代码都存在于独立的文件中。除非真的需要代码,否则那个文件是不会载入的。通常,我们可认为除非那个类的一个对象构造完毕,否则代码不会真的载入。由于static方法存在一些细微的歧义,所以也能认为“类代码在首次使用的时候载入”。首次使用的地方也是static初始化发生的地方。装载的时候,所有static对象和static代码块都会按照本来的顺序初始化(亦即它们在类定义代码里写入的顺序)。当然,static数据只会初始化一次。6.9.1 继承初始化我们有必要对整个初始化过程有所认识,其中包括继承,对这个过程中发生的事情有一个整体性的概念。请观察下述代码:2286.9 初始化和类装载//: Beetle.java// The full process of initialization.class Insect {int i = 9;int j;Insect() {prt("i = " + i + ", j = " + j);j = 39;}static int x1 =prt("static Insect.x1 initialized");static int prt(String s) {System.out.println(s);return 47;}}public class Beetle extends Insect {int k = prt("Beetle.k initialized");Beetle() {prt("k = " + k);prt("j = " + j);}static int x2 =prt("static Beetle.x2 initialized");static int prt(String s) {System.out.println(s);return 63;}public static void main(String[] args) {prt("Beetle constructor");Beetle b = new Beetle();}} ///:~该程序的输出如下:static Insect.x initializedstatic Beetle.x initializedBeetle constructori = 9, j = 0Beetle.k initializedk = 63j = 39对Beetle运行Java时,发生的第一件事情是装载程序到外面找到那个类。在装载过程中,装载程序注意它有一个基础类(即extends关键字要表达的意思),所以随之将其载入。无论是否准备生成那个基础类的一个对象,这个过程都会发生(请试着将对象的创建代码当作注释2296.9 初始化和类装载标注出来,自己去证实)。若基础类含有另一个基础类,则另一个基础类随即也会载入,以此类推。接下来,会在根基础类(此时是Insect)执行static初始化,再在下一个衍生类执行,以此类推。保证这个顺序是非常关键的,因为衍生类的初始化可能要依赖于对基础类成员的正确初始化。此时,必要的类已全部装载完毕,所以能够创建对象。首先,这个对象中的所有基本数据类型都会设成它们的默认值,而将对象句柄设为null。随后会调用基础类构建器。在这种情况下,调用是自动进行的。但也完全可以用super来自行指定构建器调用(就象在Beetle()构建器中的第一个操作一样)。基础类的构建采用与衍生类构建器完全相同的处理过程。基础顺构建器完成以后,实例变量会按本来的顺序得以初始化。最后,执行构建器剩余的主体部分。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:102306.10 总结6.10 总结无论继承还是合成,我们都可以在现有类型的基础上创建一个新类型。但在典型情况下,我们通过合成来实现现有类型的“再生”或“重复使用”,将其作为新类型基础实施过程的一部分使用。但如果想实现接口的“再生”,就应使用继承。由于衍生或派生出来的类拥有基础类的接口,所以能够将其“上溯造型”为基础类。对于下一章要讲述的多形性问题,这一点是至关重要的。尽管继承在面向对象的程序设计中得到了特别的强调,但在实际启动一个设计时,最好还是先考虑采用合成技术。只有在特别必要的时候,才应考虑采用继承技术(下一章还会讲到这个问题)。合成显得更加灵活。但是,通过对自己的成员类型应用一些继承技巧,可在运行期准确改变那些成员对象的类型,由此可改变它们的行为。尽管对于快速项目开发来说,通过合成和继承实现的代码再生具有很大的帮助作用。但在允许其他程序员完全依赖它之前,一般都希望能重新设计自己的类结构。我们理想的类结构应该是每个类都有自己特定的用途。它们不能过大(如集成的功能太多,则很难实现它的再生),也不能过小(造成不能由自己使用,或者不能增添新功能)。最终实现的类应该能够方便地再生。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:102316.11 练习6.11 练习(1) 用默认构建器(空自变量列表)创建两个类:A和B,令它们自己声明自己。从A继承一个名为C的新类,并在C内创建一个成员B。不要为C创建一个构建器。创建类C的一个对象,并观察结果。(2) 修改练习1,使A和B都有含有自变量的构建器,则不是采用默认构建器。为C写一个构建器,并在C的构建器中执行所有初始化工作。(3) 使用文件Cartoon.java,将Cartoon类的构建器代码变成注释内容标注出去。解释会发生什么事情。(4) 使用文件Chess.java,将Chess类的构建器代码作为注释标注出去。同样解释会发生什么。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:10232第7章 多形性第7章 多形性“对于面向对象的程序设计语言,多型性是第三种最基本的特征(前两种是数据抽象和继承。”“多形性”(Polymorphism)从另一个角度将接口从具体的实施细节中分离出来,亦即实现了“是什么”与“怎样做”两个模块的分离。利用多形性的概念,代码的组织以及可读性均能获得改善。此外,还能创建“易于扩展”的程序。无论在项目的创建过程中,还是在需要加入新特性的时候,它们都可以方便地“成长”。通过合并各种特征与行为,封装技术可创建出新的数据类型。通过对具体实施细节的隐藏,可将接口与实施细节分离,使所有细节成为“private”(私有)。这种组织方式使那些有程序化编程背景人感觉颇为舒适。但多形性却涉及对“类型”的分解。通过上一章的学习,大家已知道通过继承可将一个对象当作它自己的类型或者它自己的基础类型对待。这种能力是十分重要的,因为多个类型(从相同的基础类型中衍生出来)可被当作同一种类型对待。而且只需一段代码,即可对所有不同的类型进行同样的处理。利用具有多形性的方法调用,一种类型可将自己与另一种相似的类型区分开,只要它们都是从相同的基础类型中衍生出来的。这种区分是通过各种方法在行为上的差异实现的,可通过基础类实现对那些方法的调用。在这一章中,大家要由浅入深地学习有关多形性的问题(也叫作动态绑定、推迟绑定或者运行期绑定)。同时举一些简单的例子,其中所有无关的部分都已剥除,只保留与多形性有关的代码。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:102337.1 上溯造型7.1 上溯造型在第6章,大家已知道可将一个对象作为它自己的类型使用,或者作为它的基础类型的一个对象使用。取得一个对象句柄,并将其作为基础类型句柄使用的行为就叫作“上溯造型”——因为继承树的画法是基础类位于最上方。但这样做也会遇到一个问题,如下例所示(若执行这个程序遇到麻烦,请参考第3章的3.1.2小节“赋值”)://: Music.java// Inheritance & upcastingpackage c07;class Note {private int value;private Note(int val) { value = val; }public static final NotemiddleC = new Note(0),cSharp = new Note(1),cFlat = new Note(2);} // Etc.class Instrument {public void play(Note n) {System.out.println("Instrument.play()");}}// Wind objects are instruments// because they have the same interface:class Wind extends Instrument {// Redefine interface method:public void play(Note n) {System.out.println("Wind.play()");}}public class Music {public static void tune(Instrument i) {// ...i.play(Note.middleC);}public static void main(String[] args) {Wind flute = new Wind();tune(flute); // Upcasting}} ///:~2347.1 上溯造型其中,方法Music.tune()接收一个Instrument句柄,同时也接收从Instrument衍生出来的所有东西。当一个Wind句柄传递给tune()的时候,就会出现这种情况。此时没有造型的必要。这样做是可以接受的;Instrument里的接口必须存在于Wind中,因为Wind是从Instrument里继承得到的。从Wind向Instrument的上溯造型可能“缩小”那个接口,但不可能把它变得比Instrument的完整接口还要小。7.1.1 为什么要上溯造型这个程序看起来也许显得有些奇怪。为什么所有人都应该有意忘记一个对象的类型呢?进行上溯造型时,就可能产生这方面的疑惑。而且如果让tune()简单地取得一个Wind句柄,将其作为自己的自变量使用,似乎会更加简单、直观得多。但要注意:假如那样做,就需为系统内Instrument的每种类型写一个全新的tune()。假设按照前面的推论,加入Stringed(弦乐)和Brass(铜管)这两种Instrument(乐器)://: Music2.java// Overloading instead of upcastingclass Note2 {private int value;private Note2(int val) { value = val; }public static final Note2middleC = new Note2(0),cSharp = new Note2(1),cFlat = new Note2(2);} // Etc.class Instrument2 {public void play(Note2 n) {System.out.println("Instrument2.play()");}}class Wind2 extends Instrument2 {public void play(Note2 n) {System.out.println("Wind2.play()");}}class Stringed2 extends Instrument2 {public void play(Note2 n) {System.out.println("Stringed2.play()");}}class Brass2 extends Instrument2 {public void play(Note2 n) {System.out.println("Brass2.play()");}}2357.1 上溯造型public class Music2 {public static void tune(Wind2 i) {i.play(Note2.middleC);}public static void tune(Stringed2 i) {i.play(Note2.middleC);}public static void tune(Brass2 i) {i.play(Note2.middleC);}public static void main(String[] args) {Wind2 flute = new Wind2();Stringed2 violin = new Stringed2();Brass2 frenchHorn = new Brass2();tune(flute); // No upcastingtune(violin);tune(frenchHorn);}} ///:~这样做当然行得通,但却存在一个极大的弊端:必须为每种新增的Instrument2类编写与类紧密相关的方法。这意味着第一次就要求多得多的编程量。以后,假如想添加一个象tune()那样的新方法或者为Instrument添加一个新类型,仍然需要进行大量编码工作。此外,即使忘记对自己的某个方法进行过载设置,编译器也不会提示任何错误。这样一来,类型的整个操作过程就显得极难管理,有失控的危险。但假如只写一个方法,将基础类作为自变量或参数使用,而不是使用那些特定的衍生类,岂不是会简单得多?也就是说,如果我们能不顾衍生类,只让自己的代码与基础类打交道,那么省下的工作量将是难以估计的。这正是“多形性”大显身手的地方。然而,大多数程序员(特别是有程序化编程背景的)对于多形性的工作原理仍然显得有些生疏。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:102367.2 深入理解7.2 深入理解对于Music.java的困难性,可通过运行程序加以体会。输出是Wind.play()。这当然是我们希望的输出,但它看起来似乎并不愿按我们的希望行事。请观察一下tune()方法:public static void tune(Instrument i) {// ...i.play(Note.middleC);}它接收Instrument句柄。所以在这种情况下,编译器怎样才能知道Instrument句柄指向的是一个Wind,而不是一个Brass或Stringed呢?编译器无从得知。为了深入了理解这个问题,我们有必要探讨一下“绑定”这个主题。7.2.1 方法调用的绑定将一个方法调用同一个方法主体连接到一起就称为“绑定”(Binding)。若在程序运行以前执行绑定(由编译器和链接程序,如果有的话),就叫作“早期绑定”。大家以前或许从未听说过这个术语,因为它在任何程序化语言里都是不可能的。C编译器只有一种方法调用,那就是“早期绑定”。上述程序最令人迷惑不解的地方全与早期绑定有关,因为在只有一个Instrument句柄的前提下,编译器不知道具体该调用哪个方法。解决的方法就是“后期绑定”,它意味着绑定在运行期间进行,以对象的类型为基础。后期绑定也叫作“动态绑定”或“运行期绑定”。若一种语言实现了后期绑定,同时必须提供一些机制,可在运行期间判断对象的类型,并分别调用适当的方法。也就是说,编译器此时依然不知道对象的类型,但方法调用机制能自己去调查,找到正确的方法主体。不同的语言对后期绑定的实现方法是有所区别的。但我们至少可以这样认为:它们都要在对象中安插某些特殊类型的信息。Java中绑定的所有方法都采用后期绑定技术,除非一个方法已被声明成final。这意味着我们通常不必决定是否应进行后期绑定——它是自动发生的。为什么要把一个方法声明成final呢?正如上一章指出的那样,它能防止其他人覆盖那个方法。但也许更重要的一点是,它可有效地“关闭”动态绑定,或者告诉编译器不需要进行动态绑定。这样一来,编译器就可为final方法调用生成效率更高的代码。7.2.2 产生正确的行为知道Java里绑定的所有方法都通过后期绑定具有多形性以后,就可以相应地编写自己的代码,令其与基础类沟通。此时,所有的衍生类都保证能用相同的代码正常地工作。或者换用另一种方法,我们可以“将一条消息发给一个对象,让对象自行判断要做什么事情。”2377.2 深入理解在面向对象的程序设计中,有一个经典的“形状”例子。由于它很容易用可视化的形式表现出来,所以经常都用它说明问题。但很不幸的是,它可能误导初学者认为OOP只是为图形化编程设计的,这种认识当然是错误的。形状例子有一个基础类,名为Shape;另外还有大量衍生类型:Circle(圆形),Square(方形),Triangle(三角形)等等。大家之所以喜欢这个例子,因为很容易理解“圆属于形状的一种类型”等概念。下面这幅继承图向我们展示了它们的关系:上溯造型可用下面这个语句简单地表现出来:Shape s = new Circle();在这里,我们创建了Circle对象,并将结果句柄立即赋给一个Shape。这表面看起来似乎属于错误操作(将一种类型分配给另一个),但实际是完全可行的——因为按照继承关系,Circle属于Shape的一种。因此编译器认可上述语句,不会向我们提示一条出错消息。 当我们调用其中一个基础类方法时(已在衍生类里覆盖):s.draw();同样地,大家也许认为会调用Shape的draw(),因为这毕竟是一个Shape句柄。那么编译器怎样才能知道该做其他任何事情呢?但此时实际调用的是Circle.draw(),因为后期绑定已经介入(多形性)。 下面这个例子从一个稍微不同的角度说明了问题://: Shapes.java// Polymorphism in Javaclass Shape {void draw() {}void erase() {}}class Circle extends Shape {void draw() {System.out.println("Circle.draw()");}2387.2 深入理解void erase() {System.out.println("Circle.erase()");}}class Square extends Shape {void draw() {System.out.println("Square.draw()");}void erase() {System.out.println("Square.erase()");}}class Triangle extends Shape {void draw() {System.out.println("Triangle.draw()");}void erase() {System.out.println("Triangle.erase()");}}public class Shapes {public static Shape randShape() {switch((int)(Math.random() * 3)) {default: // To quiet the compilercase 0: return new Circle();case 1: return new Square();case 2: return new Triangle();}}public static void main(String[] args) {Shape[] s = new Shape[9];// Fill up the array with shapes:for(int i = 0; i < s.length; i++)s[i] = randShape();// Make polymorphic method calls:for(int i = 0; i < s.length; i++)s[i].draw();}} ///:~针对从Shape衍生出来的所有东西,Shape建立了一个通用接口——也就是说,所有(几何)形状都可以描绘和删除。衍生类覆盖了这些定义,为每种特殊类型的几何形状都提供了独一无二的行为。在主类Shapes里,包含了一个static方法,名为randShape()。它的作用是在每次调用它时为某个随机选择的Shape对象生成一个句柄。请注意上溯造型是在每个return语句里发生的。这个语句取得指向一个Circle,Square或者Triangle的句柄,并将其作为返回类型Shape发给方2397.2 深入理解法。所以无论什么时候调用这个方法,就绝对没机会了解它的具体类型到底是什么,因为肯定会获得一个单纯的Shape句柄。main()包含了Shape句柄的一个数组,其中的数据通过对randShape()的调用填入。在这个时候,我们知道自己拥有Shape,但不知除此之外任何具体的情况(编译器同样不知)。然而,当我们在这个数组里步进,并为每个元素调用draw()的时候,与各类型有关的正确行为会魔术般地发生,就象下面这个输出示例展示的那样:Circle.draw()Triangle.draw()Circle.draw()Circle.draw()Circle.draw()Square.draw()Triangle.draw()Square.draw()Square.draw()当然,由于几何形状是每次随机选择的,所以每次运行都可能有不同的结果。之所以要突出形状的随机选择,是为了让大家深刻体会这一点:为了在编译的时候发出正确的调用,编译器毋需获得任何特殊的情报。对draw()的所有调用都是通过动态绑定进行的。7.2.3 扩展性现在,让我们仍然返回乐器(Instrument)示例。由于存在多形性,所以可根据自己的需要向系统里加入任意多的新类型,同时毋需更改true()方法。在一个设计良好的OOP程序中,我们的大多数或者所有方法都会遵从tune()的模型,而且只与基础类接口通信。我们说这样的程序具有“扩展性”,因为可以从通用的基础类继承新的数据类型,从而新添一些功能。如果是为了适应新类的要求,那么对基础类接口进行操纵的方法根本不需要改变, 对于乐器例子,假设我们在基础类里加入更多的方法,以及一系列新类,那么会出现什么情况呢?下面是示意图:2407.2 深入理解所有这些新类都能与老类——tune()默契地工作,毋需对tune()作任何调整。即使tune()位于一个独立的文件里,而将新方法添加到Instrument的接口,tune()也能正确地工作,不需要重新编译。下面这个程序是对上述示意图的具体实现://: Music3.java// An extensible programimport java.util.*;class Instrument3 {public void play() {System.out.println("Instrument3.play()");}public String what() {return "Instrument3";}public void adjust() {}}class Wind3 extends Instrument3 {public void play() {System.out.println("Wind3.play()");}public String what() { return "Wind3"; }public void adjust() {}}class Percussion3 extends Instrument3 {public void play() {System.out.println("Percussion3.play()");}2417.2 深入理解public String what() { return "Percussion3"; }public void adjust() {}}class Stringed3 extends Instrument3 {public void play() {System.out.println("Stringed3.play()");}public String what() { return "Stringed3"; }public void adjust() {}}class Brass3 extends Wind3 {public void play() {System.out.println("Brass3.play()");}public void adjust() {System.out.println("Brass3.adjust()");}}class Woodwind3 extends Wind3 {public void play() {System.out.println("Woodwind3.play()");}public String what() { return "Woodwind3"; }}public class Music3 {// Doesn't care about type, so new types// added to the system still work right:static void tune(Instrument3 i) {// ...i.play();}static void tuneAll(Instrument3[] e) {for(int i = 0; i < e.length; i++)tune(e[i]);}public static void main(String[] args) {Instrument3[] orchestra = new Instrument3[5];int i = 0;// Upcasting during addition to the array:orchestra[i++] = new Wind3();orchestra[i++] = new Percussion3();orchestra[i++] = new Stringed3();orchestra[i++] = new Brass3();orchestra[i++] = new Woodwind3();tuneAll(orchestra);}} ///:~2427.2 深入理解新方法是what()和adjust()。前者返回一个String句柄,同时返回对那个类的说明;后者使我们能对每种乐器进行调整。在main()中,当我们将某样东西置入Instrument3数组时,就会自动上溯造型到Instrument3。可以看到,在围绕tune()方法的其他所有代码都发生变化的同时,tune()方法却丝毫不受它们的影响,依然故我地正常工作。这正是利用多形性希望达到的目标。我们对代码进行修改后,不会对程序中不应受到影响的部分造成影响。此外,我们认为多形性是一种至关重要的技术,它允许程序员“将发生改变的东西同没有发生改变的东西区分开”。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:102437.3 覆盖与过载7.3 覆盖与过载现在让我们用不同的眼光来看看本章的头一个例子。在下面这个程序中,方法play()的接口会在被覆盖的过程中发生变化。这意味着我们实际并没有“覆盖”方法,而是使其“过载”。编译器允许我们对方法进行过载处理,使其不报告出错。但这种行为可能并不是我们所希望的。下面是这个例子://: WindError.java// Accidentally changing the interfaceclass NoteX {public static final intMIDDLE_C = 0, C_SHARP = 1, C_FLAT = 2;}class InstrumentX {public void play(int NoteX) {System.out.println("InstrumentX.play()");}}class WindX extends InstrumentX {// OOPS! Changes the method interface:public void play(NoteX n) {System.out.println("WindX.play(NoteX n)");}}public class WindError {public static void tune(InstrumentX i) {// ...i.play(NoteX.MIDDLE_C);}public static void main(String[] args) {WindX flute = new WindX();tune(flute); // Not the desired behavior!}} ///:~这里还向大家引入了另一个易于混淆的概念。在InstrumentX中,play()方法采用了一个int(整数)数值,它的标识符是NoteX。也就是说,即使NoteX是一个类名,也可以把它作为一个标识符使用,编译器不会报告出错。但在WindX中,play()采用一个NoteX句柄,它有一个标识符n。即便我们使用“play(NoteX NoteX)”,编译器也不会报告错误。这样一来,看起来就象是程序员有意覆盖play()的功能,但对方法的类型定义却稍微有些不确切。然而,编译器此时假定的是程序员有意进行“过载”,而非“覆盖”。请仔细体会这两个术语的区别。“过载”是2447.3 覆盖与过载指同一样东西在不同的地方具有多种含义;而“覆盖”是指它随时随地都只有一种含义,只是原先的含义完全被后来的含义取代了。请注意如果遵守标准的Java命名规范,自变量标识符就应该是noteX,这样可把它与类名区分开。在tune中,“InstrumentX i”会发出play()消息,同时将某个NoteX成员作为自变量使用(MIDDLE_C)。由于NoteX包含了int定义,过载的play()方法的int版本会得到调用。同时由于它尚未被“覆盖”,所以会使用基础类版本。输出是:InstrumentX.play()Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:102457.4 抽象类和方法7.4 抽象类和方法在我们所有乐器(Instrument)例子中,基础类Instrument内的方法都肯定是“伪”方法。若去调用这些方法,就会出现错误。那是由于Instrument的意图是为从它衍生出去的所有类都创建一个通用接口。之所以要建立这个通用接口,唯一的原因就是它能为不同的子类型作出不同的表示。它为我们建立了一种基本形式,使我们能定义在所有衍生类里“通用”的一些东西。为阐述这个观念,另一个方法是把Instrument称为“抽象基础类”(简称“抽象类”)。若想通过该通用接口处理一系列类,就需要创建一个抽象类。对所有与基础类声明的签名相符的衍生类方法,都可以通过动态绑定机制进行调用(然而,正如上一节指出的那样,如果方法名与基础类相同,但自变量或参数不同,就会出现过载现象,那或许并非我们所愿意的)。如果有一个象Instrument那样的抽象类,那个类的对象几乎肯定没有什么意义。换言之,Instrument的作用仅仅是表达接口,而不是表达一些具体的实施细节。所以创建一个Instrument对象是没有意义的,而且我们通常都应禁止用户那样做。为达到这个目的,可令Instrument内的所有方法都显示出错消息。但这样做会延迟信息到运行期,并要求在用户那一面进行彻底、可靠的测试。无论如何,最好的方法都是在编译期间捕捉到问题。针对这个问题,Java专门提供了一种机制,名为“抽象方法”。它属于一种不完整的方法,只含有一个声明,没有方法主体。下面是抽象方法声明时采用的语法:abstract void X();包含了抽象方法的一个类叫作“抽象类”。如果一个类里包含了一个或多个抽象方法,类就必须指定成abstract(抽象)。否则,编译器会向我们报告一条出错消息。若一个抽象类是不完整的,那么一旦有人试图生成那个类的一个对象,编译器又会采取什么行动呢?由于不能安全地为一个抽象类创建属于它的对象,所以会从编译器那里获得一条出错提示。通过这种方法,编译器可保证抽象类的“纯洁性”,我们不必担心会误用它。如果从一个抽象类继承,而且想生成新类型的一个对象,就必须为基础类中的所有抽象方法提供方法定义。如果不这样做(完全可以选择不做),则衍生类也会是抽象的,而且编译器会强迫我们用abstract关键字标志那个类的“抽象”本质。即使不包括任何abstract方法,亦可将一个类声明成“抽象类”。如果一个类没必要拥有任何抽象方法,而且我们想禁止那个类的所有实例,这种能力就会显得非常有用。Instrument类可很轻松地转换成一个抽象类。只有其中一部分方法会变成抽象方法,因为使一个类抽象以后,并不会强迫我们将它的所有方法都同时变成抽象。下面是它看起来的样子:2467.4 抽象类和方法下面是我们修改过的“管弦”乐器例子,其中采用了抽象类以及方法://: Music4.java// Abstract classes and methodsimport java.util.*;abstract class Instrument4 {int i; // storage allocated for eachpublic abstract void play();public String what() {return "Instrument4";}public abstract void adjust();}class Wind4 extends Instrument4 {public void play() {System.out.println("Wind4.play()");}public String what() { return "Wind4"; }public void adjust() {}}class Percussion4 extends Instrument4 {public void play() {System.out.println("Percussion4.play()");}public String what() { return "Percussion4"; }public void adjust() {}}2477.4 抽象类和方法class Stringed4 extends Instrument4 {public void play() {System.out.println("Stringed4.play()");}public String what() { return "Stringed4"; }public void adjust() {}}class Brass4 extends Wind4 {public void play() {System.out.println("Brass4.play()");}public void adjust() {System.out.println("Brass4.adjust()");}}class Woodwind4 extends Wind4 {public void play() {System.out.println("Woodwind4.play()");}public String what() { return "Woodwind4"; }}public class Music4 {// Doesn't care about type, so new types// added to the system still work right:static void tune(Instrument4 i) {// ...i.play();}static void tuneAll(Instrument4[] e) {for(int i = 0; i < e.length; i++)tune(e[i]);}public static void main(String[] args) {Instrument4[] orchestra = new Instrument4[5];int i = 0;// Upcasting during addition to the array:orchestra[i++] = new Wind4();orchestra[i++] = new Percussion4();orchestra[i++] = new Stringed4();orchestra[i++] = new Brass4();orchestra[i++] = new Woodwind4();tuneAll(orchestra);}} ///:~可以看出,除基础类以外,实际并没有进行什么改变。创建抽象类和方法有时对我们非常有用,因为它们使一个类的抽象变成明显的事实,可明确告诉用户和编译器自己打算如何用它。2487.4 抽象类和方法Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:102497.5 接口7.5 接口“interface”(接口)关键字使抽象的概念更深入了一层。我们可将其想象为一个“纯”抽象类。它允许创建者规定一个类的基本形式:方法名、自变量列表以及返回类型,但不规定方法主体。接口也包含了基本数据类型的数据成员,但它们都默认为static和final。接口只提供一种形式,并不提供实施的细节。接口这样描述自己:“对于实现我的所有类,看起来都应该象我现在这个样子”。因此,采用了一个特定接口的所有代码都知道对于那个接口可能会调用什么方法。这便是接口的全部含义。所以我们常把接口用于建立类和类之间的一个“协议”。有些面向对象的程序设计语言采用了一个名为“protocol”(协议)的关键字,它做的便是与接口相同的事情。为创建一个接口,请使用interface关键字,而不要用class。与类相似,我们可在interface关键字的前面增加一个public关键字(但只有接口定义于同名的一个文件内);或者将其省略,营造一种“友好的”状态。为了生成与一个特定的接口(或一组接口)相符的类,要使用implements(实现)关键字。我们要表达的意思是“接口看起来就象那个样子,这儿是它具体的工作细节”。除这些之外,我们其他的工作都与继承极为相似。下面是乐器例子的示意图:具体实现了一个接口以后,就获得了一个普通的类,可用标准方式对其进行扩展。2507.5 接口可决定将一个接口中的方法声明明确定义为“public”。但即便不明确定义,它们也会默认为public。所以在实现一个接口的时候,来自接口的方法必须定义成public。否则的话,它们会默认为“友好的”,而且会限制我们在继承过程中对一个方法的访问——Java编译器不允许我们那样做。在Instrument例子的修改版本中,大家可明确地看出这一点。注意接口中的每个方法都严格地是一个声明,它是编译器唯一允许的。除此以外,Instrument5中没有一个方法被声明为public,但它们都会自动获得public属性。如下所示://: Music5.java// Interfacesimport java.util.*;interface Instrument5 {// Compile-time constant:int i = 5; // static & final// Cannot have method definitions:void play(); // Automatically publicString what();void adjust();}class Wind5 implements Instrument5 {public void play() {System.out.println("Wind5.play()");}public String what() { return "Wind5"; }public void adjust() {}}class Percussion5 implements Instrument5 {public void play() {System.out.println("Percussion5.play()");}public String what() { return "Percussion5"; }public void adjust() {}}class Stringed5 implements Instrument5 {public void play() {System.out.println("Stringed5.play()");}public String what() { return "Stringed5"; }public void adjust() {}}class Brass5 extends Wind5 {public void play() {System.out.println("Brass5.play()");}public void adjust() {2517.5 接口System.out.println("Brass5.adjust()");}}class Woodwind5 extends Wind5 {public void play() {System.out.println("Woodwind5.play()");}public String what() { return "Woodwind5"; }}public class Music5 {// Doesn't care about type, so new types// added to the system still work right:static void tune(Instrument5 i) {// ...i.play();}static void tuneAll(Instrument5[] e) {for(int i = 0; i 100)System.out.println("Over budget!");}private String label = dest;public String readLabel() { return label; }};}public static void main(String[] args) {Parcel9 p = new Parcel9();Destination d = p.dest("Tanzania", 101.395F);}} ///:~在实例初始化模块中,我们可看到代码不能作为类初始化模块(即if语句)的一部分执行。所以实际上,一个实例初始化模块就是一个匿名内部类的构建器。当然,它的功能是有限的;我们不能对实例初始化模块进行过载处理,所以只能拥有这些构建器的其中一个。7.6.3 链接到外部类迄今为止,我们见到的内部类好象仅仅是一种名字隐藏以及代码组织方案。尽管这些功能非常有用,但似乎并不特别引人注目。然而,我们还忽略了另一个重要的事实。创建自己的内部类时,那个类的对象同时拥有指向封装对象(这些对象封装或生成了内部类)的一个链接。所以它们能访问那个封装对象的成员——毋需取得任何资格。除此以外,内部类拥有对封装类所有元素的访问权限(注释②)。下面这个例子阐示了这个问题:2697.6 内部类//: Sequence.java// Holds a sequence of Objectsinterface Selector {boolean end();Object current();void next();}public class Sequence {private Object[] o;private int next = 0;public Sequence(int size) {o = new Object[size];}public void add(Object x) {if(next < o.length) {o[next] = x;next++;}}private class SSelector implements Selector {int i = 0;public boolean end() {return i == o.length;}public Object current() {return o[i];}public void next() {if(i < o.length) i++;}}public Selector getSelector() {return new SSelector();}public static void main(String[] args) {Sequence s = new Sequence(10);for(int i = 0; i = evtTime;}abstract public void action();abstract public String description();} ///:~希望Event(事件)运行的时候,构建器即简单地捕获时间。同时ready()告诉我们何时该运行它。当然,ready()也可以在一个衍生类中被覆盖,将事件建立在除时间以外的其他东西上。action()是事件就绪后需要调用的方法,而description()提供了与事件有关的文字信息。下面这个文件包含了实际的控制框架,用于管理和触发事件。第一个类实际只是一个“助手”类,它的职责是容纳Event对象。可用任何适当的集合替换它。而且通过第8章的学习,大家会知道另一些集合可简化我们的工作,不需要我们编写这些额外的代码:2797.6 内部类//: Controller.java// Along with Event, the generic// framework for all control systems:package c07.controller;// This is just a way to hold Event objects.class EventSet {private Event[] events = new Event[100];private int index = 0;private int next = 0;public void add(Event e) {if(index >= events.length)return; // (In real life, throw exception)events[index++] = e;}public Event getNext() {boolean looped = false;int start = next;do {next = (next + 1) % events.length;// See if it has looped to the beginning:if(start == next) looped = true;// If it loops past start, the list// is empty:if((next == (start + 1) % events.length)&& looped)return null;} while(events[next] == null);return events[next];}public void removeCurrent() {events[next] = null;}}public class Controller {private EventSet es = new EventSet();public void addEvent(Event c) { es.add(c); }public void run() {Event e;while((e = es.getNext()) != null) {if(e.ready()) {e.action();System.out.println(e.description());es.removeCurrent();}}}} ///:~2807.6 内部类EventSet可容纳100个事件(若在这里使用来自第8章的一个“真实”集合,就不必担心它的最大尺寸,因为它会根据情况自动改变大小)。index(索引)在这里用于跟踪下一个可用的空间,而next(下一个)帮助我们寻找列表中的下一个事件,了解自己是否已经循环到头。在对getNext()的调用中,这一点是至关重要的,因为一旦运行,Event对象就会从列表中删去(使用removeCurrent())。所以getNext()会在列表中向前移动时遇到“空洞”。注意removeCurrent()并不只是指示一些标志,指出对象不再使用。相反,它将句柄设为null。这一点是非常重要的,因为假如垃圾收集器发现一个句柄仍在使用,就不会清除对象。若认为自己的句柄可能象现在这样被挂起,那么最好将其设为null,使垃圾收集器能够正常地清除它们。Controller是进行实际工作的地方。它用一个EventSet容纳自己的Event对象,而且addEvent()允许我们向这个列表加入新事件。但最重要的方法是run()。该方法会在EventSet中遍历,搜索一个准备运行的Event对象——ready()。对于它发现ready()的每一个对象,都会调用action()方法,打印出description(),然后将事件从列表中删去。注意在迄今为止的所有设计中,我们仍然不能准确地知道一个“事件”要做什么。这正是整个设计的关键;它怎样“将发生变化的东西同没有变化的东西区分开”?或者用我的话来讲,“改变的意图”造成了各类Event对象的不同行动。我们通过创建不同的Event子类,从而表达出不同的行动。这里正是内部类大显身手的地方。它们允许我们做两件事情:(1) 在单独一个类里表达一个控制框架应用的全部实施细节,从而完整地封装与那个实施有关的所有东西。内部类用于表达多种不同类型的action(),它们用于解决实际的问题。除此以外,后续的例子使用了private内部类,所以实施细节会完全隐藏起来,可以安全地修改。(2) 内部类使我们具体的实施变得更加巧妙,因为能方便地访问外部类的任何成员。若不具备这种能力,代码看起来就可能没那么使人舒服,最后不得不寻找其他方法解决。现在要请大家思考控制框架的一种具体实施方式,它设计用来控制温室(Greenhouse)功能(注释④)。每个行动都是完全不同的:控制灯光、供水以及温度自动调节的开与关,控制响铃,以及重新启动系统。但控制框架的设计宗旨是将不同的代码方便地隔离开。对每种类型的行动,都要继承一个新的Event内部类,并在action()内编写相应的控制代码。④:由于某些特殊原因,这对我来说是一个经常需要解决的、非常有趣的问题;原来的例子在《C++ Inside & Out》一书里也出现过,但Java提供了一种更令人舒适的解决方案。作为应用程序框架的一种典型行为,GreenhouseControls类是从Controller继承的://: GreenhouseControls.java// This produces a specific application of the// control system, all in a single class. Inner// classes allow you to encapsulate different// functionality for each type of event.package c07.controller;2817.6 内部类public class GreenhouseControlsextends Controller {private boolean light = false;private boolean water = false;private String thermostat = "Day";private class LightOn extends Event {public LightOn(long eventTime) {super(eventTime);}public void action() {// Put hardware control code here to// physically turn on the light.light = true;}public String description() {return "Light is on";}}private class LightOff extends Event {public LightOff(long eventTime) {super(eventTime);}public void action() {// Put hardware control code here to// physically turn off the light.light = false;}public String description() {return "Light is off";}}private class WaterOn extends Event {public WaterOn(long eventTime) {super(eventTime);}public void action() {// Put hardware control code herewater = true;}public String description() {return "Greenhouse water is on";}}private class WaterOff extends Event {public WaterOff(long eventTime) {super(eventTime);}public void action() {// Put hardware control code herewater = false;}public String description() {2827.6 内部类return "Greenhouse water is off";}}private class ThermostatNight extends Event {public ThermostatNight(long eventTime) {super(eventTime);}public void action() {// Put hardware control code herethermostat = "Night";}public String description() {return "Thermostat on night setting";}}private class ThermostatDay extends Event {public ThermostatDay(long eventTime) {super(eventTime);}public void action() {// Put hardware control code herethermostat = "Day";}public String description() {return "Thermostat on day setting";}}// An example of an action() that inserts a// new one of itself into the event list:private int rings;private class Bell extends Event {public Bell(long eventTime) {super(eventTime);}public void action() {// Ring bell every 2 seconds, rings times:System.out.println("Bing!");if(--rings > 0)addEvent(new Bell(System.currentTimeMillis() + 2000));}public String description() {return "Ring bell";}}private class Restart extends Event {public Restart(long eventTime) {super(eventTime);}public void action() {long tm = System.currentTimeMillis();// Instead of hard-wiring, you could parse// configuration information from a text2837.6 内部类// file here:rings = 5;addEvent(new ThermostatNight(tm));addEvent(new LightOn(tm + 1000));addEvent(new LightOff(tm + 2000));addEvent(new WaterOn(tm + 3000));addEvent(new WaterOff(tm + 8000));addEvent(new Bell(tm + 9000));addEvent(new ThermostatDay(tm + 10000));// Can even add a Restart object!addEvent(new Restart(tm + 20000));}public String description() {return "Restarting system";}}public static void main(String[] args) {GreenhouseControls gc =new GreenhouseControls();long tm = System.currentTimeMillis();gc.addEvent(gc.new Restart(tm));gc.run();}} ///:~注意light(灯光)、water(供水)、thermostat(调温)以及rings都隶属于外部类GreenhouseControls,所以内部类可以毫无阻碍地访问那些字段。此外,大多数action()方法也涉及到某些形式的硬件控制,这通常都要求发出对非Java代码的调用。大多数Event类看起来都是相似的,但Bell(铃)和Restart(重启)属于特殊情况。Bell会发出响声,若尚未响铃足够的次数,它会在事件列表里添加一个新的Bell对象,所以以后会再度响铃。请注意内部类看起来为什么总是类似于多重继承:Bell拥有Event的所有方法,而且也拥有外部类GreenhouseControls的所有方法。Restart负责对系统进行初始化,所以会添加所有必要的事件。当然,一种更灵活的做法是避免进行“硬编码”,而是从一个文件里读入它们(第10章的一个练习会要求大家修改这个例子,从而达到这个目标)。由于Restart()仅仅是另一个Event对象,所以也可以在Restart.action()里添加一个Restart对象,使系统能够定期重启。在main()中,我们需要做的全部事情就是创建一个GreenhouseControls对象,并添加一个Restart对象,令其工作起来。 这个例子应该使大家对内部类的价值有一个更加深刻的认识,特别是在一个控制框架里使用它们的时候。此外,在第13章的后半部分,大家还会看到如何巧妙地利用内部类描述一个图形用户界面的行为。完成那里的学习后,对内部类的认识将上升到一个前所未有的新高度。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:102847.6 内部类2857.7 构建器和多形性7.7 构建器和多形性同往常一样,构建器与其他种类的方法是有区别的。在涉及到多形性的问题后,这种方法依然成立。尽管构建器并不具有多形性(即便可以使用一种“虚拟构建器”——将在第11章介绍),但仍然非常有必要理解构建器如何在复杂的分级结构中以及随同多形性使用。这一理解将有助于大家避免陷入一些令人不快的纠纷。7.7.1 构建器的调用顺序构建器调用的顺序已在第4章进行了简要说明,但那是在继承和多形性问题引入之前说的话。用于基础类的构建器肯定在一个衍生类的构建器中调用,而且逐渐向上链接,使每个基础类使用的构建器都能得到调用。之所以要这样做,是由于构建器负有一项特殊任务:检查对象是否得到了正确的构建。一个衍生类只能访问它自己的成员,不能访问基础类的成员(这些成员通常都具有private属性)。只有基础类的构建器在初始化自己的元素时才知道正确的方法以及拥有适当的权限。所以,必须令所有构建器都得到调用,否则整个对象的构建就可能不正确。那正是编译器为什么要强迫对衍生类的每个部分进行构建器调用的原因。在衍生类的构建器主体中,若我们没有明确指定对一个基础类构建器的调用,它就会“默默”地调用默认构建器。如果不存在默认构建器,编译器就会报告一个错误(若某个类没有构建器,编译器会自动组织一个默认构建器)。下面让我们看看一个例子,它展示了按构建顺序进行合成、继承以及多形性的效果:2867.7 构建器和多形性//: Sandwich.java// Order of constructor callsclass Meal {Meal() { System.out.println("Meal()"); }}class Bread {Bread() { System.out.println("Bread()"); }}class Cheese {Cheese() { System.out.println("Cheese()"); }}class Lettuce {Lettuce() { System.out.println("Lettuce()"); }}class Lunch extends Meal {Lunch() { System.out.println("Lunch()");}}class PortableLunch extends Lunch {PortableLunch() {System.out.println("PortableLunch()");}}class Sandwich extends PortableLunch {Bread b = new Bread();Cheese c = new Cheese();Lettuce l = new Lettuce();Sandwich() {System.out.println("Sandwich()");}public static void main(String[] args) {new Sandwich();}} ///:~这个例子在其他类的外部创建了一个复杂的类,而且每个类都有一个构建器对自己进行了宣布。其中最重要的类是Sandwich,它反映出了三个级别的继承(若将从Object的默认继承算在内,就是四级)以及三个成员对象。在main()里创建了一个Sandwich对象后,输出结果如下:2877.7 构建器和多形性Meal()Lunch()PortableLunch()Bread()Cheese()Lettuce()Sandwich()这意味着对于一个复杂的对象,构建器的调用遵照下面的顺序:(1) 调用基础类构建器。这个步骤会不断重复下去,首先得到构建的是分级结构的根部,然后是下一个衍生类,等等。直到抵达最深一层的衍生类。(2) 按声明顺序调用成员初始化模块。(3) 调用衍生构建器的主体。构建器调用的顺序是非常重要的。进行继承时,我们知道关于基础类的一切,并且能访问基础类的任何public和protected成员。这意味着当我们在衍生类的时候,必须能假定基础类的所有成员都是有效的。采用一种标准方法,构建行动已经进行,所以对象所有部分的成员均已得到构建。但在构建器内部,必须保证使用的所有成员都已构建。为达到这个要求,唯一的办法就是首先调用基础类构建器。然后在进入衍生类构建器以后,我们在基础类能够访问的所有成员都已得到初始化。此外,所有成员对象(亦即通过合成方法置于类内的对象)在类内进行定义的时候(比如上例中的b,c和l),由于我们应尽可能地对它们进行初始化,所以也应保证构建器内部的所有成员均为有效。若坚持按这一规则行事,会有助于我们确定所有基础类成员以及当前对象的成员对象均已获得正确的初始化。但不幸的是,这种做法并不适用于所有情况,这将在下一节具体说明。7.7.2 继承和finalize()通过“合成”方法创建新类时,永远不必担心对那个类的成员对象的收尾工作。每个成员都是一个独立的对象,所以会得到正常的垃圾收集以及收尾处理——无论它是不是不自己某个类一个成员。但在进行初始化的时候,必须覆盖衍生类中的finalize()方法——如果已经设计了某个特殊的清除进程,要求它必须作为垃圾收集的一部分进行。覆盖衍生类的finalize()时,务必记住调用finalize()的基础类版本。否则,基础类的初始化根本不会发生。下面这个例子便是明证://: Frog.java// Testing finalize with inheritanceclass DoBaseFinalization {public static boolean flag = false;}class Characteristic {String s;2887.7 构建器和多形性Characteristic(String c) {s = c;System.out.println("Creating Characteristic " + s);}protected void finalize() {System.out.println("finalizing Characteristic " + s);}}class LivingCreature {Characteristic p =new Characteristic("is alive");LivingCreature() {System.out.println("LivingCreature()");}protected void finalize() {System.out.println("LivingCreature finalize");// Call base-class version LAST!if(DoBaseFinalization.flag)try {super.finalize();} catch(Throwable t) {}}}class Animal extends LivingCreature {Characteristic p =new Characteristic("has heart");Animal() {System.out.println("Animal()");}protected void finalize() {System.out.println("Animal finalize");if(DoBaseFinalization.flag)try {super.finalize();} catch(Throwable t) {}}}class Amphibian extends Animal {Characteristic p =new Characteristic("can live in water");Amphibian() {System.out.println("Amphibian()");}protected void finalize() {System.out.println("Amphibian finalize");if(DoBaseFinalization.flag)try {2897.7 构建器和多形性super.finalize();} catch(Throwable t) {}}}public class Frog extends Amphibian {Frog() {System.out.println("Frog()");}protected void finalize() {System.out.println("Frog finalize");if(DoBaseFinalization.flag)try {super.finalize();} catch(Throwable t) {}}public static void main(String[] args) {if(args.length != 0 &&args[0].equals("finalize"))DoBaseFinalization.flag = true;elseSystem.out.println("not finalizing bases");new Frog(); // Instantly becomes garbageSystem.out.println("bye!");// Must do this to guarantee that all// finalizers will be called:System.runFinalizersOnExit(true);}} ///:~DoBasefinalization类只是简单地容纳了一个标志,向分级结构中的每个类指出是否应调用super.finalize()。这个标志的设置建立在命令行参数的基础上,所以能够在进行和不进行基础类收尾工作的前提下查看行为。 分级结构中的每个类也包含了Characteristic类的一个成员对象。大家可以看到,无论是否调用了基础类收尾模块,Characteristic成员对象都肯定会得到收尾(清除)处理。每个被覆盖的finalize()至少要拥有对protected成员的访问权力,因为Object类中的finalize()方法具有protected属性,而编译器不允许我们在继承过程中消除访问权限(“友好的”比“受到保护的”具有更小的访问权限)。在Frog.main()中,DoBaseFinalization标志会得到配置,而且会创建单独一个Frog对象。请记住垃圾收集(特别是收尾工作)可能不会针对任何特定的对象发生,所以为了强制采取这一行动,System.runFinalizersOnExit(true)添加了额外的开销,以保证收尾工作的正常进行。若没有基础类初始化,则输出结果是:2907.7 构建器和多形性not finalizing basesCreating Characteristic is aliveLivingCreature()Creating Characteristic has heartAnimal()Creating Characteristic can live in waterAmphibian()Frog()bye!Frog finalizefinalizing Characteristic is alivefinalizing Characteristic has heartfinalizing Characteristic can live in water从中可以看出确实没有为基础类Frog调用收尾模块。但假如在命令行加入“finalize”自变量,则会获得下述结果:Creating Characteristic is aliveLivingCreature()Creating Characteristic has heartAnimal()Creating Characteristic can live in waterAmphibian()Frog()bye!Frog finalizeAmphibian finalizeAnimal finalizeLivingCreature finalizefinalizing Characteristic is alivefinalizing Characteristic has heartfinalizing Characteristic can live in water尽管成员对象按照与它们创建时相同的顺序进行收尾,但从技术角度说,并没有指定对象收尾的顺序。但对于基础类,我们可对收尾的顺序进行控制。采用的最佳顺序正是在这里采用的顺序,它与初始化顺序正好相反。按照与C++中用于“破坏器”相同的形式,我们应该首先执行衍生类的收尾,再是基础类的收尾。这是由于衍生类的收尾可能调用基础类中相同的方法,要求基础类组件仍然处于活动状态。因此,必须提前将它们清除(破坏)。7.7.3 构建器内部的多形性方法的行为构建器调用的分级结构(顺序)为我们带来了一个有趣的问题,或者说让我们进入了一种进退两难的局面。若当前位于一个构建器的内部,同时调用准备构建的那个对象的一个动态绑定方法,那么会出现什么情况呢?在原始的方法内部,我们完全可以想象会发生什么——动态绑定的调用会在运行期间进行解析,因为对象不知道它到底从属于方法所在的那个类,还是从属于从它衍生出来的某些类。为保持一致性,大家也许会认为这应该在构建器内部发2917.7 构建器和多形性生。 但实际情况并非完全如此。若调用构建器内部一个动态绑定的方法,会使用那个方法被覆盖的定义。然而,产生的效果可能并不如我们所愿,而且可能造成一些难于发现的程序错误。从概念上讲,构建器的职责是让对象实际进入存在状态。在任何构建器内部,整个对象可能只是得到部分组织——我们只知道基础类对象已得到初始化,但却不知道哪些类已经继承。然而,一个动态绑定的方法调用却会在分级结构里“向前”或者“向外”前进。它调用位于衍生类里的一个方法。如果在构建器内部做这件事情,那么对于调用的方法,它要操纵的成员可能尚未得到正确的初始化——这显然不是我们所希望的。 通过观察下面这个例子,这个问题便会昭然若揭://: PolyConstructors.java// Constructors and polymorphism// don't produce what you might expect.abstract class Glyph {abstract void draw();Glyph() {System.out.println("Glyph() before draw()");draw();System.out.println("Glyph() after draw()");}}class RoundGlyph extends Glyph {int radius = 1;RoundGlyph(int r) {radius = r;System.out.println("RoundGlyph.RoundGlyph(), radius = "+ radius);}void draw() {System.out.println("RoundGlyph.draw(), radius = " + radius);}}public class PolyConstructors {public static void main(String[] args) {new RoundGlyph(5);}} ///:~在Glyph中,draw()方法是“抽象的”(abstract),所以它可以被其他方法覆盖。事实上,我们在RoundGlyph中不得不对其进行覆盖。但Glyph构建器会调用这个方法,而且调用会在RoundGlyph.draw()中止,这看起来似乎是有意的。但请看看输出结果:2927.7 构建器和多形性Glyph() before draw()RoundGlyph.draw(), radius = 0Glyph() after draw()RoundGlyph.RoundGlyph(), radius = 5当Glyph的构建器调用draw()时,radius的值甚至不是默认的初始值1,而是0。这可能是由于一个点号或者屏幕上根本什么都没有画而造成的。这样就不得不开始查找程序中的错误,试着找出程序不能工作的原因。 前一节讲述的初始化顺序并不十分完整,而那是解决问题的关键所在。初始化的实际过程是这样的:(1) 在采取其他任何操作之前,为对象分配的存储空间初始化成二进制零。(2) 就象前面叙述的那样,调用基础类构建器。此时,被覆盖的draw()方法会得到调用(的确是在RoundGlyph构建器调用之前),此时会发现radius的值为0,这是由于步骤(1)造成的。(3) 按照原先声明的顺序调用成员初始化代码。(4) 调用衍生类构建器的主体。采取这些操作要求有一个前提,那就是所有东西都至少要初始化成零(或者某些特殊数据类型与“零”等价的值),而不是仅仅留作垃圾。其中包括通过“合成”技术嵌入一个类内部的对象句柄。如果假若忘记初始化那个句柄,就会在运行期间出现违例事件。其他所有东西都会变成零,这在观看结果时通常是一个严重的警告信号。在另一方面,应对这个程序的结果提高警惕。从逻辑的角度说,我们似乎已进行了无懈可击的设计,所以它的错误行为令人非常不可思议。而且没有从编译器那里收到任何报错信息(C++在这种情况下会表现出更合理的行为)。象这样的错误会很轻易地被人忽略,而且要花很长的时间才能找出。因此,设计构建器时一个特别有效的规则是:用尽可能简单的方法使对象进入就绪状态;如果可能,避免调用任何方法。在构建器内唯一能够安全调用的是在基础类中具有final属性的那些方法(也适用于private方法,它们自动具有final属性)。这些方法不能被覆盖,所以不会出现上述潜在的问题。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:102937.8 通过继承进行设计7.8 通过继承进行设计学习了多形性的知识后,由于多形性是如此“聪明”的一种工具,所以看起来似乎所有东西都应该继承。但假如过度使用继承技术,也会使自己的设计变得不必要地复杂起来。事实上,当我们以一个现成类为基础建立一个新类时,如首先选择继承,会使情况变得异常复杂。一个更好的思路是首先选择“合成”——如果不能十分确定自己应使用哪一个。合成不会强迫我们的程序设计进入继承的分级结构中。同时,合成显得更加灵活,因为可以动态选择一种类型(以及行为),而继承要求在编译期间准确地知道一种类型。下面这个例子对此进行了阐释://: Transmogrify.java// Dynamically changing the behavior of// an object via composition.interface Actor {void act();}class HappyActor implements Actor {public void act() {System.out.println("HappyActor");}}class SadActor implements Actor {public void act() {System.out.println("SadActor");}}class Stage {Actor a = new HappyActor();void change() { a = new SadActor(); }void go() { a.act(); }}public class Transmogrify {public static void main(String[] args) {Stage s = new Stage();s.go(); // Prints "HappyActor"s.change();s.go(); // Prints "SadActor"}} ///:~2947.8 通过继承进行设计在这里,一个Stage对象包含了指向一个Actor的句柄,后者被初始化成一个HappyActor对象。这意味着go()会产生特定的行为。但由于句柄在运行期间可以重新与一个不同的对象绑定或结合起来,所以SadActor对象的句柄可在a中得到替换,然后由go()产生的行为发生改变。这样一来,我们在运行期间就获得了很大的灵活性。与此相反,我们不能在运行期间换用不同的形式来进行继承;它要求在编译期间完全决定下来。一条常规的设计准则是:用继承表达行为间的差异,并用成员变量表达状态的变化。在上述例子中,两者都得到了应用:继承了两个不同的类,用于表达act()方法的差异;而Stage通过合成技术允许它自己的状态发生变化。在这种情况下,那种状态的改变同时也产生了行为的变化。7.8.1 纯继承与扩展学习继承时,为了创建继承分级结构,看来最明显的方法是采取一种“纯粹”的手段。也就是说,只有在基础类或“接口”中已建立的方法才可在衍生类中被覆盖,如下面这张图所示:可将其描述成一种纯粹的“属于”关系,因为一个类的接口已规定了它到底“是什么”或者“属于什么”。通过继承,可保证所有衍生类都只拥有基础类的接口。如果按上述示意图操作,衍生出来的类除了基础类的接口之外,也不会再拥有其他什么。可将其想象成一种“纯替换”,因为衍生类对象可为基础类完美地替换掉。使用它们的时候,我们根本没必要知道与子类有关的任何额外信息。如下所示:也就是说,基础类可接收我们发给衍生类的任何消息,因为两者拥有完全一致的接口。我们要做的全部事情就是从衍生上溯造型,而且永远不需要回过头来检查对象的准确类型是什么。所有细节都已通过多形性获得了完美的控制。 若按这种思路考虑问题,那么一个纯粹的“属于”关系似乎是唯一明智的设计方法,其他任何设计方法都会导致混乱不清的思路,而且在定义上存在很大的困难。但这种想法又属于另一个极端。经过细致的研究,我们发现扩展2957.8 通过继承进行设计接口对于一些特定问题来说是特别有效的方案。可将其称为“类似于”关系,因为扩展后的衍生类“类似于”基础类——它们有相同的基础接口——但它增加了一些特性,要求用额外的方法加以实现。如下所示:尽管这是一种有用和明智的做法(由具体的环境决定),但它也有一个缺点:衍生类中对接口扩展的那一部分不可在基础类中使用。所以一旦上溯造型,就不可再调用新方法:若在此时不进行上溯造型,则不会出现此类问题。但在许多情况下,都需要重新核实对象的准确类型,使自己能访问那个类型的扩展方法。在后面的小节里,我们具体讲述了这是如何实现的。7.8.2 下溯造型与运行期类型标识由于我们在上溯造型(在继承结构中向上移动)期间丢失了具体的类型信息,所以为了获取具体的类型信息——亦即在分级结构中向下移动——我们必须使用 “下溯造型”技术。然而,我们知道一个上溯造型肯定是安全的;基础类不可能再拥有一个比衍生类更大的接口。因此,我们通过基础类接口发送的每一条消息都肯定能够接收到。但在进行下溯造型的时候,我们(举个例子来说)并不真的知道一个几何形状实际是一个圆,它完全可能是一个三角形、方形或者其他形状。2967.8 通过继承进行设计为解决这个问题,必须有一种办法能够保证下溯造型正确进行。只有这样,我们才不会冒然造型成一种错误的类型,然后发出一条对象不可能收到的消息。这样做是非常不安全的。在某些语言中(如C++),为了进行保证“类型安全”的下溯造型,必须采取特殊的操作。但在Java中,所有造型都会自动得到检查和核实!所以即使我们只是进行一次普通的括弧造型,进入运行期以后,仍然会毫无留情地对这个造型进行检查,保证它的确是我们希望的那种类型。如果不是,就会得到一个ClassCastException(类造型违例)。在运行期间对类型进行检查的行为叫作“运行期类型标识”(RTTI)。下面这个例子向大家演示了RTTI的行为:2977.8 通过继承进行设计//: RTTI.java// Downcasting & Run-Time Type// Identification (RTTI)import java.util.*;class Useful {public void f() {}public void g() {}}class MoreUseful extends Useful {public void f() {}public void g() {}public void u() {}public void v() {}public void w() {}}public class RTTI {public static void main(String[] args) {Useful[] x = {new Useful(),new MoreUseful()};x[0].f();x[1].g();// Compile-time: method not found in Useful://! x[1].u();((MoreUseful)x[1]).u(); // Downcast/RTTI((MoreUseful)x[0]).u(); // Exception thrown}} ///:~和在示意图中一样,MoreUseful(更有用的)对Useful(有用的)的接口进行了扩展。但由于它是继承来的,所以也能上溯造型到一个Useful。我们可看到这会在对数组x(位于main()中)进行初始化的时候发生。由于数组中的两个对象都属于Useful类,所以可将f()和g()方法同时发给它们两个。而且假如试图调用u()(它只存在于MoreUseful),就会收到一条编译期出错提示。若想访问一个MoreUseful对象的扩展接口,可试着进行下溯造型。如果它是正确的类型,这一行动就会成功。否则,就会得到一个ClassCastException。我们不必为这个违例编写任何特殊的代码,因为它指出的是一个可能在程序中任何地方发生的一个编程错误。RTTI的意义远不仅仅反映在造型处理上。例如,在试图下溯造型之前,可通过一种方法了解自己处理的是什么类型。整个第11章都在讲述Java运行期类型标识的方方面面。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:102987.8 通过继承进行设计2997.9 总结7.9 总结“多形性”意味着“不同的形式”。在面向对象的程序设计中,我们有相同的外观(基础类的通用接口)以及使用那个外观的不同形式:动态绑定或组织的、不同版本的方法。通过这一章的学习,大家已知道假如不利用数据抽象以及继承技术,就不可能理解、甚至去创建多形性的一个例子。多形性是一种不可独立应用的特性(就象一个switch语句),只可与其他元素协同使用。我们应将其作为类总体关系的一部分来看待。人们经常混淆Java其他的、非面向对象的特性,比如方法过载等,这些特性有时也具有面向对象的某些特征。但不要被愚弄:如果以后没有绑定,就不成其为多形性。为使用多形性乃至面向对象的技术,特别是在自己的程序中,必须将自己的编程视野扩展到不仅包括单独一个类的成员和消息,也要包括类与类之间的一致性以及它们的关系。尽管这要求学习时付出更多的精力,但却是非常值得的,因为只有这样才可真正有效地加快自己的编程速度、更好地组织代码、更容易做出包容面广的程序以及更易对自己的代码进行维护与扩展。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:103007.10 练习7.10 练习(1) 创建Rodent(啮齿动物):Mouse(老鼠),Gerbil(鼹鼠),Hamster(大颊鼠)等的一个继承分级结构。在基础类中,提供适用于所有Rodent的方法,并在衍生类中覆盖它们,从而根据不同类型的Rodent采取不同的行动。创建一个Rodent数组,在其中填充不同类型的Rodent,然后调用自己的基础类方法,看看会有什么情况发生。(2) 修改练习1,使Rodent成为一个接口。(3) 改正WindError.java中的问题。(4) 在GreenhouseControls.java中,添加Event内部类,使其能打开和关闭风扇。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:10301第8章 对象的容纳第8章 对象的容纳“如果一个程序只含有数量固定的对象,而且已知它们的存在时间,那么这个程序可以说是相当简单的。”通常,我们的程序需要根据程序运行时才知道的一些标准创建新对象。若非程序正式运行,否则我们根本不知道自己到底需要多少数量的对象,甚至不知道它们的准确类型。为了满足常规编程的需要,我们要求能在任何时候、任何地点创建任意数量的对象。所以不可依赖一个已命名的句柄来容纳自己的每一个对象,就象下面这样:MyObject myHandle;因为根本不知道自己实际需要多少这样的东西。为解决这个非常关键的问题,Java提供了容纳对象(或者对象的句柄)的多种方式。其中内建的类型是数组,我们之前已讨论过它,本章准备加深大家对它的认识。此外,Java的工具(实用程序)库提供了一些“集合类”(亦称作“容器类”,但该术语已由AWT使用,所以这里仍采用“集合”这一称呼)。利用这些集合类,我们可以容纳乃至操纵自己的对象。本章的剩余部分会就此进行详细讨论。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:103028.1 数组8.1 数组对数组的大多数必要的介绍已在第4章的最后一节进行。通过那里的学习,大家已知道自己该如何定义及初始化一个数组。对象的容纳是本章的重点,而数组只是容纳对象的一种方式。但由于还有其他大量方法可容纳数组,所以是哪些地方使数组显得如此特别呢? 有两方面的问题将数组与其他集合类型区分开来:效率和类型。对于Java来说,为保存和访问一系列对象(实际是对象的句柄)数组,最有效的方法莫过于数组。数组实际代表一个简单的线性序列,它使得元素的访问速度非常快,但我们却要为这种速度付出代价:创建一个数组对象时,它的大小是固定的,而且不可在那个数组对象的“存在时间”内发生改变。可创建特定大小的一个数组,然后假如用光了存储空间,就再创建一个新数组,将所有句柄从旧数组移到新数组。这属于“矢量”(Vector)类的行为,本章稍后还会详细讨论它。然而,由于为这种大小的灵活性要付出较大的代价,所以我们认为矢量的效率并没有数组高。C++的矢量类知道自己容纳的是什么类型的对象,但同Java的数组相比,它却有一个明显的缺点:C++矢量类的operator[]不能进行范围检查,所以很容易超出边界(然而,它可以查询vector有多大,而且at()方法确实能进行范围检查)。在Java中,无论使用的是数组还是集合,都会进行范围检查——若超过边界,就会获得一个RuntimeException(运行期违例)错误。正如大家在第9章会学到的那样,这类违例指出的是一个程序员错误,所以不需要在代码中检查它。在另一方面,由于C++的vector不进行范围检查,所以访问速度较快——在Java中,由于对数组和集合都要进行范围检查,所以对性能有一定的影响。本章还要学习另外几种常见的集合类:Vector(矢量)、Stack(堆栈)以及Hashtable(散列表)。这些类都涉及对对象的处理——好象它们没有特定的类型。换言之,它们将其当作Object类型处理(Object类型是Java中所有类的“根”类)。从某个角度看,这种处理方法是非常合理的:我们仅需构建一个集合,然后任何Java对象都可以进入那个集合(除基本数据类型外——可用Java的基本类型封装类将其作为常数置入集合,或者将其封装到自己的类内,作为可以变化的值使用)。这再一次反映了数组优于常规集合:创建一个数组时,可令其容纳一种特定的类型。这意味着可进行编译期类型检查,预防自己设置了错误的类型,或者错误指定了准备提取的类型。当然,在编译期或者运行期,Java会防止我们将不当的消息发给一个对象。所以我们不必考虑自己的哪种做法更加危险,只要编译器能及时地指出错误,同时在运行期间加快速度,目的也就达到了。此外,用户很少会对一次违例事件感到非常惊讶的。考虑到执行效率和类型检查,应尽可能地采用数组。然而,当我们试图解决一个更常规的问题时,数组的局限也可能显得非常明显。在研究过数组以后,本章剩余的部分将把重点放到Java提供的集合类身上。8.1.1 数组和第一类对象3038.1 数组无论使用的数组属于什么类型,数组标识符实际都是指向真实对象的一个句柄。那些对象本身是在内存“堆”里创建的。堆对象既可“隐式”创建(即默认产生),亦可“显式”创建(即明确指定,用一个new表达式)。堆对象的一部分(实际是我们能访问的唯一字段或方法)是只读的length(长度)成员,它告诉我们那个数组对象里最多能容纳多少元素。对于数组对象,“[]”语法是我们能采用的唯一另类访问方法。下面这个例子展示了对数组进行初始化的不同方式,以及如何将数组句柄分配给不同的数组对象。它也揭示出对象数组和基本数据类型数组在使用方法上几乎是完全一致的。唯一的差别在于对象数组容纳的是句柄,而基本数据类型数组容纳的是具体的数值(若在执行此程序时遇到困难,请参考第3章的“赋值”小节)://: ArraySize.java// Initialization & re-assignment of arrayspackage c08;class Weeble {} // A small mythical creaturepublic class ArraySize {public static void main(String[] args) {// Arrays of objects:Weeble[] a; // Null handleWeeble[] b = new Weeble[5]; // Null handlesWeeble[] c = new Weeble[4];for(int i = 0; i < c.length; i++)c[i] = new Weeble();Weeble[] d = {new Weeble(), new Weeble(), new Weeble()};// Compile error: variable a not initialized://!System.out.println("a.length=" + a.length);System.out.println("b.length = " + b.length);// The handles inside the array are// automatically initialized to null:for(int i = 0; i < b.length; i++)System.out.println("b[" + i + "]=" + b[i]);System.out.println("c.length = " + c.length);System.out.println("d.length = " + d.length);a = d;System.out.println("a.length = " + a.length);// Java 1.1 initialization syntax:a = new Weeble[] {new Weeble(), new Weeble()};System.out.println("a.length = " + a.length);// Arrays of primitives:int[] e; // Null handleint[] f = new int[5];int[] g = new int[4];for(int i = 0; i < g.length; i++)3048.1 数组g[i] = i*i;int[] h = { 11, 47, 93 };// Compile error: variable e not initialized://!System.out.println("e.length=" + e.length);System.out.println("f.length = " + f.length);// The primitives inside the array are// automatically initialized to zero:for(int i = 0; i < f.length; i++)System.out.println("f[" + i + "]=" + f[i]);System.out.println("g.length = " + g.length);System.out.println("h.length = " + h.length);e = h;System.out.println("e.length = " + e.length);// Java 1.1 initialization syntax:e = new int[] { 1, 2 };System.out.println("e.length = " + e.length);}} ///:~Here’s the output from the program:b.length = 5b[0]=nullb[1]=nullb[2]=nullb[3]=nullb[4]=nullc.length = 4d.length = 3a.length = 3a.length = 2f.length = 5f[0]=0f[1]=0f[2]=0f[3]=0f[4]=0g.length = 4h.length = 3e.length = 3e.length = 2其中,数组a只是初始化成一个null句柄。此时,编译器会禁止我们对这个句柄作任何实际操作,除非已正确地初始化了它。数组b被初始化成指向由Weeble句柄构成的一个数组,但那个数组里实际并未放置任何Weeble对象。然而,我们仍然可以查询那个数组的大小,因为b指向的是一个合法对象。这也为我们带来了一个难题:不可知道那个数组里实际包含了多少个元素,因为length只告诉我们可将多少元素置入那个数组。换言之,我们只知道数组对象的大小或容量,不知其实际容纳了多少个元素。尽管如此,由于数组对象在创建之初会自动初始化3058.1 数组成null,所以可检查它是否为null,判断一个特定的数组“空位”是否容纳一个对象。类似地,由基本数据类型构成的数组会自动初始化成零(针对数值类型)、null(字符类型)或者false(布尔类型)。数组c显示出我们首先创建一个数组对象,再将Weeble对象赋给那个数组的所有“空位”。数组d揭示出“集合初始化”语法,从而创建数组对象(用new命令明确进行,类似于数组c),然后用Weeble对象进行初始化,全部工作在一条语句里完成。 下面这个表达式:a = d;向我们展示了如何取得同一个数组对象连接的句柄,然后将其赋给另一个数组对象,就象我们针对对象句柄的其他任何类型做的那样。现在,a和d都指向内存堆内同样的数组对象。Java 1.1加入了一种新的数组初始化语法,可将其想象成“动态集合初始化”。由d采用的Java1.0集合初始化方法则必须在定义d的同时进行。但若采用Java 1.1的语法,却可以在任何地方创建和初始化一个数组对象。例如,假设hide()方法用于取得一个Weeble对象数组,那么调用它时传统的方法是:hide(d);但在Java 1.1中,亦可动态创建想作为参数传递的数组,如下所示:hide(new Weeble[] {new Weeble(), new Weeble() });这一新式语法使我们在某些场合下写代码更方便了。上述例子的第二部分揭示出这样一个问题:对于由基本数据类型构成的数组,它们的运作方式与对象数组极为相似,只是前者直接包容了基本类型的数据值。1. 基本数据类型集合集合类只能容纳对象句柄。但对一个数组,却既可令其直接容纳基本类型的数据,亦可容纳指向对象的句柄。利用象Integer、Double之类的“封装器”类,可将基本数据类型的值置入一个集合里。但正如本章后面会在WordCount.java例子中讲到的那样,用于基本数据类型的封装器类只是在某些场合下才能发挥作用。无论将基本类型的数据置入数组,还是将其封装进入位于集合的一个类内,都涉及到执行效率的问题。显然,若能创建和访问一个基本数据类型数组,那么比起访问一个封装数据的集合,前者的效率会高出许多。当然,假如准备一种基本数据类型,同时又想要集合的灵活性(在需要的时候可自动扩展,腾出更多的空间),就不宜使用数组,必须使用由封装的数据构成的一个集合。大家或许认为针对每种基本数据类型,都应有一种特殊类型的Vector。但Java并未提供这一特性。某些形式的建模机制或许会在某一天帮助Java更好地解决这个问题(注释①)。3068.1 数组①:这儿是C++比Java做得好的一个地方,因为C++通过template关键字提供了对“参数化类型”的支持。8.1.2 数组的返回假定我们现在想写一个方法,同时不希望它仅仅返回一样东西,而是想返回一系列东西。此时,象C和C++这样的语言会使问题复杂化,因为我们不能返回一个数组,只能返回指向数组的一个指针。这样就非常麻烦,因为很难控制数组的“存在时间”,它很容易造成内存“漏洞”的出现。Java采用的是类似的方法,但我们能“返回一个数组”。当然,此时返回的实际仍是指向数组的指针。但在Java里,我们永远不必担心那个数组的是否可用——只要需要,它就会自动存在。而且垃圾收集器会在我们完成后自动将其清除。 作为一个例子,请思考如何返回一个字串数组:3078.1 数组//: IceCream.java// Returning arrays from methodspublic class IceCream {static String[] flav = {"Chocolate", "Strawberry","Vanilla Fudge Swirl", "Mint Chip","Mocha Almond Fudge", "Rum Raisin","Praline Cream", "Mud Pie"};static String[] flavorSet(int n) {// Force it to be positive & within bounds:n = Math.abs(n) % (flav.length + 1);String[] results = new String[n];int[] picks = new int[n];for(int i = 0; i < picks.length; i++)picks[i] = -1;for(int i = 0; i < picks.length; i++) {retry:while(true) {int t =(int)(Math.random() * flav.length);for(int j = 0; j < i; j++)if(picks[j] == t) continue retry;picks[i] = t;results[i] = flav[t];break;}}return results;}public static void main(String[] args) {for(int i = 0; i < 20; i++) {System.out.println("flavorSet(" + i + ") = ");String[] fl = flavorSet(flav.length);for(int j = 0; j < fl.length; j++)System.out.println("\t" + fl[j]);}}} ///:~flavorSet()方法创建了一个名为results的String数组。该数组的大小为n——具体数值取决于我们传递给方法的自变量。随后,它从数组flav里随机挑选一些“香料”(Flavor),并将它们置入results里,并最终返回results。返回数组与返回其他任何对象没什么区别——最终返回的都是一个句柄。至于数组到底是在flavorSet()里创建的,还是在其他什么地方创建的,这个问题并不重要,因为反正返回的仅是一个句柄。一旦我们的操作完成,垃圾收集器会自动关照数组的清除工作。而且只要我们需要数组,它就会乖乖地听候调遣。3088.1 数组另一方面,注意当flavorSet()随机挑选香料的时候,它需要保证以前出现过的一次随机选择不会再次出现。为达到这个目的,它使用了一个无限while循环,不断地作出随机选择,直到发现未在picks数组里出现过的一个元素为止(当然,也可以进行字串比较,检查随机选择是否在results数组里出现过,但字串比较的效率比较低)。若成功,就添加这个元素,并中断循环(break),再查找下一个(i值会递增)。但假若t是一个已在picks里出现过的数组,就用标签式的continue往回跳两级,强制选择一个新t。用一个调试程序可以很清楚地看到这个过程。main()能显示出20个完整的香料集合,所以我们看到flavorSet()每次都用一个随机顺序选择香料。为体会这一点,最简单的方法就是将输出重导向进入一个文件,然后直接观看这个文件的内容。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:103098.2 集合8.2 集合现在总结一下我们前面学过的东西:为容纳一组对象,最适宜的选择应当是数组。而且假如容纳的是一系列基本数据类型,更是必须采用数组。在本章剩下的部分,大家将接触到一些更常规的情况。当我们编写程序时,通常并不能确切地知道最终需要多少个对象。有些时候甚至想用更复杂的方式来保存对象。为解决这个问题,Java提供了四种类型的“集合类”:Vector(矢量)、BitSet(位集)、Stack(堆栈)以及Hashtable(散列表)。与拥有集合功能的其他语言相比,尽管这儿的数量显得相当少,但仍然能用它们解决数量惊人的实际问题。这些集合类具有形形色色的特征。例如,Stack实现了一个LIFO(先入先出)序列,而Hashtable是一种“关联数组”,允许我们将任何对象关联起来。除此以外,所有Java集合类都能自动改变自身的大小。所以,我们在编程时可使用数量众多的对象,同时不必担心会将集合弄得有多大。8.2.1 缺点:类型未知使用Java集合的“缺点”是在将对象置入一个集合时丢失了类型信息。之所以会发生这种情况,是由于当初编写集合时,那个集合的程序员根本不知道用户到底想把什么类型置入集合。若指示某个集合只允许特定的类型,会妨碍它成为一个“常规用途”的工具,为用户带来麻烦。为解决这个问题,集合实际容纳的是类型为Object的一些对象的句柄。这种类型当然代表Java中的所有对象,因为它是所有类的根。当然,也要注意这并不包括基本数据类型,因为它们并不是从“任何东西”继承来的。这是一个很好的方案,只是不适用下述场合:(1) 将一个对象句柄置入集合时,由于类型信息会被抛弃,所以任何类型的对象都可进入我们的集合——即便特别指示它只能容纳特定类型的对象。举个例子来说,虽然指示它只能容纳猫,但事实上任何人都可以把一条狗扔进来。(2) 由于类型信息不复存在,所以集合能肯定的唯一事情就是自己容纳的是指向一个对象的句柄。正式使用它之前,必须对其进行造型,使其具有正确的类型。值得欣慰的是,Java不允许人们滥用置入集合的对象。假如将一条狗扔进一个猫的集合,那么仍会将集合内的所有东西都看作猫,所以在使用那条狗时会得到一个“违例”错误。在同样的意义上,假若试图将一条狗的句柄“造型”到一只猫,那么运行期间仍会得到一个“违例”错误。下面是个例子:3108.2 集合//: CatsAndDogs.java// Simple collection example (Vector)import java.util.*;class Cat {private int catNumber;Cat(int i) {catNumber = i;}void print() {System.out.println("Cat #" + catNumber);}}class Dog {private int dogNumber;Dog(int i) {dogNumber = i;}void print() {System.out.println("Dog #" + dogNumber);}}public class CatsAndDogs {public static void main(String[] args) {Vector cats = new Vector();for(int i = 0; i < 7; i++)cats.addElement(new Cat(i));// Not a problem to add a dog to cats:cats.addElement(new Dog(7));for(int i = 0; i < cats.size(); i++)((Cat)cats.elementAt(i)).print();// Dog is detected only at run-time}} ///:~可以看出,Vector的使用是非常简单的:先创建一个,再用addElement()置入对象,以后用elementAt()取得那些对象(注意Vector有一个size()方法,可使我们知道已添加了多少个元素,以便防止误超边界,造成违例错误)。Cat和Dog类都非常浅显——除了都是“对象”之外,它们并无特别之处(倘若不明确指出从什么类继承,就默认为从Object继承。所以我们不仅能用Vector方法将Cat对象置入这个集合,也能添加Dog对象,同时不会在编译期和运行期得到任何出错提示。用Vector方法elementAt()获取原本认为是Cat的对象时,实际获得的是指向一个Object的句柄,必须将那个对象造型为Cat。随后,需要将整个表达式用括号封闭起来,在为Cat调用print()方法之前进行强制造型;否则就会出现一个语法错误。在运行期间,如果试图将Dog对象造型为Cat,就会得到一个违例。3118.2 集合这些处理的意义都非常深远。尽管显得有些麻烦,但却获得了安全上的保证。我们从此再难偶然造成一些隐藏得深的错误。若程序的一个部分(或几个部分)将对象插入一个集合,但我们只是通过一次违例在程序的某个部分发现一个错误的对象置入了集合,就必须找出插入错误的位置。当然,可通过检查代码达到这个目的,但这或许是最笨的调试工具。另一方面,我们可从一些标准化的集合类开始自己的编程。尽管它们在功能上存在一些不足,且显得有些笨拙,但却能保证没有隐藏的错误。1. 错误有时并不显露出来在某些情况下,程序似乎正确地工作,不造型回我们原来的类型。第一种情况是相当特殊的:String类从编译器获得了额外的帮助,使其能够正常工作。只要编译器期待的是一个String对象,但它没有得到一个,就会自动调用在Object里定义、并且能够由任何Java类覆盖的toString()方法。这个方法能生成满足要求的String对象,然后在我们需要的时候使用。因此,为了让自己类的对象能显示出来,要做的全部事情就是覆盖toString()方法,如下例所示:3128.2 集合//: WorksAnyway.java// In special cases, things just seem// to work correctly.import java.util.*;class Mouse {private int mouseNumber;Mouse(int i) {mouseNumber = i;}// Magic method:public String toString() {return "This is Mouse #" + mouseNumber;}void print(String msg) {if(msg != null) System.out.println(msg);System.out.println("Mouse number " + mouseNumber);}}class MouseTrap {static void caughtYa(Object m) {Mouse mouse = (Mouse)m; // Cast from Objectmouse.print("Caught one!");}}public class WorksAnyway {public static void main(String[] args) {Vector mice = new Vector();for(int i = 0; i < 3; i++)mice.addElement(new Mouse(i));for(int i = 0; i < mice.size(); i++) {// No cast necessary, automatic call// to Object.toString():System.out.println("Free mouse: " + mice.elementAt(i));MouseTrap.caughtYa(mice.elementAt(i));}}} ///:~可在Mouse里看到对toString()的重定义代码。在main()的第二个for循环中,可发现下述语句:System.out.println("Free mouse: " +mice.elementAt(i));3138.2 集合在“+”后,编译器预期看到的是一个String对象。elementAt()生成了一个Object,所以为获得希望的String,编译器会默认调用toString()。但不幸的是,只有针对String才能得到象这样的结果;其他任何类型都不会进行这样的转换。 隐藏造型的第二种方法已在Mousetrap里得到了应用。caughtYa()方法接收的不是一个Mouse,而是一个Object。随后再将其造型为一个Mouse。当然,这样做是非常冒失的,因为通过接收一个Object,任何东西都可以传递给方法。然而,假若造型不正确——如果我们传递了错误的类型——就会在运行期间得到一个违例错误。这当然没有在编译期进行检查好,但仍然能防止问题的发生。注意在使用这个方法时毋需进行造型:MouseTrap.caughtYa(mice.elementAt(i));1. 生成能自动判别类型的Vector大家或许不想放弃刚才那个问题。一个更“健壮”的方案是用Vector创建一个新类,使其只接收我们指定的类型,也只生成我们希望的类型。如下所示:3148.2 集合//: GopherVector.java// A type-conscious Vectorimport java.util.*;class Gopher {private int gopherNumber;Gopher(int i) {gopherNumber = i;}void print(String msg) {if(msg != null) System.out.println(msg);System.out.println("Gopher number " + gopherNumber);}}class GopherTrap {static void caughtYa(Gopher g) {g.print("Caught one!");}}class GopherVector {private Vector v = new Vector();public void addElement(Gopher m) {v.addElement(m);}public Gopher elementAt(int index) {return (Gopher)v.elementAt(index);}public int size() { return v.size(); }public static void main(String[] args) {GopherVector gophers = new GopherVector();for(int i = 0; i < 3; i++)gophers.addElement(new Gopher(i));for(int i = 0; i < gophers.size(); i++)GopherTrap.caughtYa(gophers.elementAt(i));}} ///:~这前一个例子类似,只是新的GopherVector类有一个类型为Vector的private成员(从Vector继承有些麻烦,理由稍后便知),而且方法也和Vector类似。然而,它不会接收和产生普通Object,只对Gopher对象感兴趣。 由于GopherVector只接收一个Gopher(地鼠),所以假如我们使用:gophers.addElement(new Pigeon());3158.2 集合就会在编译期间获得一条出错消息。采用这种方式,尽管从编码的角度看显得更令人沉闷,但可以立即判断出是否使用了正确的类型。注意在使用elementAt()时不必进行造型——它肯定是一个Gopher。1. 参数化类型这类问题并不是孤立的——我们许多时候都要在其他类型的基础上创建新类型。此时,在编译期间拥有特定的类型信息是非常有帮助的。这便是“参数化类型”的概念。在C++中,它由语言通过“模板”获得了直接支持。至少,Java保留了关键字generic,期望有一天能够支持参数化类型。但我们现在无法确定这一天何时会来临。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:103168.3 枚举器(反复器)8.3 枚举器(反复器)在任何集合类中,必须通过某种方法在其中置入对象,再用另一种方法从中取得对象。毕竟,容纳各种各样的对象正是集合的首要任务。在Vector中,addElement()便是我们插入对象采用的方法,而elementAt()是提取对象的唯一方法。Vector非常灵活,我们可在任何时候选择任何东西,并可使用不同的索引选择多个元素。若从更高的角度看这个问题,就会发现它的一个缺陷:需要事先知道集合的准确类型,否则无法使用。乍看来,这一点似乎没什么关系。但假若最开始决定使用Vector,后来在程序中又决定(考虑执行效率的原因)改变成一个List(属于Java1.2集合库的一部分),这时又该如何做呢?可利用“反复器”(Iterator)的概念达到这个目的。它可以是一个对象,作用是遍历一系列对象,并选择那个序列中的每个对象,同时不让客户程序员知道或关注那个序列的基础结构。此外,我们通常认为反复器是一种“轻量级”对象;也就是说,创建它只需付出极少的代价。但也正是由于这个原因,我们常发现反复器存在一些似乎很奇怪的限制。例如,有些反复器只能朝一个方向移动。 Java的Enumeration(枚举,注释②)便是具有这些限制的一个反复器的例子。除下面这些外,不可再用它做其他任何事情:(1) 用一个名为elements()的方法要求集合为我们提供一个Enumeration。我们首次调用它的nextElement()时,这个Enumeration会返回序列中的第一个元素。(2) 用nextElement()获得下一个对象。(3) 用hasMoreElements()检查序列中是否还有更多的对象。②:“反复器”这个词在C++和OOP的其他地方是经常出现的,所以很难确定为什么Java的开发者采用了这样一个奇怪的名字。Java 1.2的集合库修正了这个问题以及其他许多问题。只可用Enumeration做这些事情,不能再有更多。它属于反复器一种简单的实现方式,但功能依然十分强大。为体会它的运作过程,让我们复习一下本章早些时候提到的CatsAndDogs.java程序。在原始版本中,elementAt()方法用于选择每一个元素,但在下述修订版中,可看到使用了一个“枚举”:3178.3 枚举器(反复器)//: CatsAndDogs2.java// Simple collection with Enumerationimport java.util.*;class Cat2 {private int catNumber;Cat2(int i) {catNumber = i;}void print() {System.out.println("Cat number " +catNumber);}}class Dog2 {private int dogNumber;Dog2(int i) {dogNumber = i;}void print() {System.out.println("Dog number " +dogNumber);}}public class CatsAndDogs2 {public static void main(String[] args) {Vector cats = new Vector();for(int i = 0; i < 7; i++)cats.addElement(new Cat2(i));// Not a problem to add a dog to cats:cats.addElement(new Dog2(7));Enumeration e = cats.elements();while(e.hasMoreElements())((Cat2)e.nextElement()).print();// Dog is detected only at run-time}} ///:~我们看到唯一的改变就是最后几行。不再是:for(int i = 0; i < cats.size(); i++)((Cat)cats.elementAt(i)).print();而是用一个Enumeration遍历整个序列:while(e.hasMoreElements())((Cat2)e.nextElement()).print();3188.3 枚举器(反复器)使用Enumeration,我们不必关心集合中的元素数量。所有工作均由hasMoreElements()和nextElement()自动照管了。 下面再看看另一个例子,让我们创建一个常规用途的打印方法://: HamsterMaze.java// Using an Enumerationimport java.util.*;class Hamster {private int hamsterNumber;Hamster(int i) {hamsterNumber = i;}public String toString() {return "This is Hamster #" + hamsterNumber;}}class Printer {static void printAll(Enumeration e) {while(e.hasMoreElements())System.out.println(e.nextElement().toString());}}public class HamsterMaze {public static void main(String[] args) {Vector v = new Vector();for(int i = 0; i < 3; i++)v.addElement(new Hamster(i));Printer.printAll(v.elements());}} ///:~仔细研究一下打印方法:static void printAll(Enumeration e) {while(e.hasMoreElements())System.out.println(e.nextElement().toString());}注意其中没有与序列类型有关的信息。我们拥有的全部东西便是Enumeration。为了解有关序列的情况,一个Enumeration便足够了:可取得下一个对象,亦可知道是否已抵达了末尾。取得一系列对象,然后在其中遍历,从而执行一个特定的操作——这是一个颇有价值的编程概念,本书许多地方都会沿用这一思路。3198.3 枚举器(反复器)这个看似特殊的例子甚至可以更为通用,因为它使用了常规的toString()方法(之所以称为常规,是由于它属于Object类的一部分)。下面是调用打印的另一个方法(尽管在效率上可能会差一些):System.out.println("" + e.nextElement());它采用了封装到Java内部的“自动转换成字串”技术。一旦编译器碰到一个字串,后面跟随一个“+”,就会希望后面又跟随一个字串,并自动调用toString()。在Java 1.1中,第一个字串是不必要的;所有对象都会转换成字串。亦可对此执行一次造型,获得与调用toString()同样的效果:System.out.println((String)e.nextElement())但我们想做的事情通常并不仅仅是调用Object方法,所以会再度面临类型造型的问题。对于自己感兴趣的类型,必须假定自己已获得了一个Enumeration,然后将结果对象造型成为那种类型(若操作错误,会得到运行期违例)。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:103208.4 集合的类型8.4 集合的类型标准Java 1.0和1.1库配套提供了非常少的一系列集合类。但对于自己的大多数编程要求,它们基本上都能胜任。正如大家到本章末尾会看到的,Java 1.2提供的是一套重新设计过的大型集合库。8.4.1 VectorVector的用法很简单,这已在前面的例子中得到了证明。尽管我们大多数时候只需用addElement()插入对象,用elementAt()一次提取一个对象,并用elements()获得对序列的一个“枚举”。但仍有其他一系列方法是非常有用的。同我们对于Java库惯常的做法一样,在这里并不使用或讲述所有这些方法。但请务必阅读相应的电子文档,对它们的工作有一个大概的认识。1. 崩溃JavaJava标准集合里包含了toString()方法,所以它们能生成自己的String表达方式,包括它们容纳的对象。例如在Vector中,toString()会在Vector的各个元素中步进和遍历,并为每个元素调用toString()。假定我们现在想打印出自己类的地址。看起来似乎简单地引用this即可(特别是C++程序员有这样做的倾向)://: CrashJava.java// One way to crash Javaimport java.util.*;public class CrashJava {public String toString() {return "CrashJava address: " + this + "\n";}public static void main(String[] args) {Vector v = new Vector();for(int i = 0; i =0; i--)if(((1 <=0; i--)if(((1 <=0; i--)if(((1 <= 64 bits:BitSet b127 = new BitSet();b127.set(127);System.out.println("set bit 127: " + b127);BitSet b255 = new BitSet(65);b255.set(255);System.out.println("set bit 255: " + b255);BitSet b1023 = new BitSet(512);// Without the following, an exception is thrown// in the Java 1.0 implementation of BitSet://b1023.set(1023);b1023.set(1024);System.out.println("set bit 1023: " + b1023);}static void printBitSet(BitSet b) {System.out.println("bits: " + b);String bbits = new String();for(int j = 0; j < b.size() ; j++)bbits += (b.get(j) ? "1" : "0");System.out.println("bit pattern: " + bbits);}} ///:~随机数字生成器用于创建一个随机的byte、short和int。每一个都会转换成BitSet内相应的位模型。此时一切都很正常,因为BitSet是64位的,所以它们都不会造成最终尺寸的增大。但在Java 1.0中,一旦BitSet大于64位,就会出现一些令人迷惑不解的行为。假如我们设置一个只比BitSet当前分配存储空间大出1的一个位,它能够正常地扩展。但一旦试图在更高的位置设置位,同时不先接触边界,就会得到一个恼人的违例。这正是由于BitSet在Java 1.0里不能正确扩展造成的。本例创建了一个512位的BitSet。构建器分配的存储空间是位数的两倍。所以假如设置位1024或更高的位,同时没有先设置位1023,就会在Java 1.0里得到一个违例。但幸运的是,这个问题已在Java 1.1得到了改正。所以如果是为Java 1.0写代码,请尽量避免使用BitSet。3238.4 集合的类型8.4.3 StackStack有时也可以称为“后入先出”(LIFO)集合。换言之,我们在堆栈里最后“压入”的东西将是以后第一个“弹出”的。和其他所有Java集合一样,我们压入和弹出的都是“对象”,所以必须对自己弹出的东西进行“造型”。一种很少见的做法是拒绝使用Vector作为一个Stack的基本构成元素,而是从Vector里“继承”一个Stack。这样一来,它就拥有了一个Vector的所有特征及行为,另外加上一些额外的Stack行为。很难判断出设计者到底是明确想这样做,还是属于一种固有的设计。下面是一个简单的堆栈示例,它能读入数组的每一行,同时将其作为字串压入堆栈。//: Stacks.java// Demonstration of Stack Classimport java.util.*;public class Stacks {static String[] months = {"January", "February", "March", "April","May", "June", "July", "August", "September","October", "November", "December" };public static void main(String[] args) {Stack stk = new Stack();for(int i = 0; i < months.length; i++)stk.push(months[i] + " ");System.out.println("stk = " + stk);// Treating a stack as a Vector:stk.addElement("The last line");System.out.println("element 5 = " + stk.elementAt(5));System.out.println("popping elements:");while(!stk.empty())System.out.println(stk.pop());}} ///:~months数组的每一行都通过push()继承进入堆栈,稍后用pop()从堆栈的顶部将其取出。要声明的一点是,Vector操作亦可针对Stack对象进行。这可能是由继承的特质决定的——Stack“属于”一种Vector。因此,能对Vector进行的操作亦可针对Stack进行,例如elementAt()方法。8.4.4 HashtableVector允许我们用一个数字从一系列对象中作出选择,所以它实际是将数字同对象关联起来了。但假如我们想根据其他标准选择一系列对象呢?堆栈就是这样的一个例子:它的选择标准是“最后压入堆栈的东西”。这种“从一系列对象中选择”的概念亦可叫作一个“映射”、“字典”或者“关联数组”。从概念上讲,它看起来象一个Vector,但却不是通过数字来查找对象,而是用另一个对象来查找它们!这通常都属于一个程序中的重要进程。3248.4 集合的类型在Java中,这个概念具体反映到抽象类Dictionary身上。该类的接口是非常直观的size()告诉我们其中包含了多少元素;isEmpty()判断是否包含了元素(是则为true);put(Object key,Object value)添加一个值(我们希望的东西),并将其同一个键关联起来(想用于搜索它的东西);get(Object key)获得与某个键对应的值;而remove(Object Key)用于从列表中删除“键-值”对。还可以使用枚举技术:keys()产生对键的一个枚举(Enumeration);而elements()产生对所有值的一个枚举。这便是一个Dictionary(字典)的全部。Dictionary的实现过程并不麻烦。下面列出一种简单的方法,它使用了两个Vector,一个用于容纳键,另一个用来容纳值:3258.4 集合的类型//: AssocArray.java// Simple version of a Dictionaryimport java.util.*;public class AssocArray extends Dictionary {private Vector keys = new Vector();private Vector values = new Vector();public int size() { return keys.size(); }public boolean isEmpty() {return keys.isEmpty();}public Object put(Object key, Object value) {keys.addElement(key);values.addElement(value);return key;}public Object get(Object key) {int index = keys.indexOf(key);// indexOf() Returns -1 if key not found:if(index == -1) return null;return values.elementAt(index);}public Object remove(Object key) {int index = keys.indexOf(key);if(index == -1) return null;keys.removeElementAt(index);Object returnval = values.elementAt(index);values.removeElementAt(index);return returnval;}public Enumeration keys() {return keys.elements();}public Enumeration elements() {return values.elements();}// Test it:public static void main(String[] args) {AssocArray aa = new AssocArray();for(char c = 'a'; c <= 'z'; c++)aa.put(String.valueOf(c),String.valueOf(c).toUpperCase());char[] ca = { 'a', 'e', 'i', 'o', 'u' };for(int i = 0; i < ca.length; i++)System.out.println("Uppercase: " +aa.get(String.valueOf(ca[i])));}} ///:~3268.4 集合的类型在对AssocArray的定义中,我们注意到的第一个问题是它“扩展”了字典。这意味着AssocArray属于Dictionary的一种类型,所以可对其发出与Dictionary一样的请求。如果想生成自己的Dictionary,而且就在这里进行,那么要做的全部事情只是填充位于Dictionary内的所有方法(而且必须覆盖所有方法,因为它们——除构建器外——都是抽象的)。Vector key和value通过一个标准索引编号链接起来。也就是说,如果用“roof”的一个键以及“blue”的一个值调用put()——假定我们准备将一个房子的各部分与它们的油漆颜色关联起来,而且AssocArray里已有100个元素,那么“roof”就会有101个键元素,而“blue”有101个值元素。而且要注意一下get(),假如我们作为键传递“roof”,它就会产生与keys.index.Of()的索引编号,然后用那个索引编号生成相关的值矢量内的值。main()中进行的测试是非常简单的;它只是将小写字符转换成大写字符,这显然可用更有效的方式进行。但它向我们揭示出了AssocArray的强大功能。标准Java库只包含Dictionary的一个变种,名为Hashtable(散列表,注释③)。Java的散列表具有与AssocArray相同的接口(因为两者都是从Dictionary继承来的)。但有一个方面却反映出了差别:执行效率。若仔细想想必须为一个get()做的事情,就会发现在一个Vector里搜索键的速度要慢得多。但此时用散列表却可以加快不少速度。不必用冗长的线性搜索技术来查找一个键,而是用一个特殊的值,名为“散列码”。散列码可以获取对象中的信息,然后将其转换成那个对象“相对唯一”的整数(int)。所有对象都有一个散列码,而hashCode()是根类Object的一个方法。Hashtable获取对象的hashCode(),然后用它快速查找键。这样可使性能得到大幅度提升(④)。散列表的具体工作原理已超出了本书的范围(⑤)——大家只需要知道散列表是一种快速的“字典”(Dictionary)即可,而字典是一种非常有用的工具。③:如计划使用RMI(在第15章详述),应注意将远程对象置入散列表时会遇到一个问题(参阅《Core Java》,作者Conrell和Horstmann,Prentice-Hall 1997年出版)④:如这种速度的提升仍然不能满足你对性能的要求,甚至可以编写自己的散列表例程,从而进一步加快表格的检索过程。这样做可避免在与Object之间进行造型的时间延误,也可以避开由Java类库散列表例程内建的同步过程。 ⑤:我的知道的最佳参考读物是《PracticalAlgorithms for Programmers》,作者为Andrew Binstock和John Rex,Addison-Wesley 1995年出版。作为应用散列表的一个例子,可考虑用一个程序来检验Java的Math.random()方法的随机性到底如何。在理想情况下,它应该产生一系列完美的随机分布数字。但为了验证这一点,我们需要生成数量众多的随机数字,然后计算落在不同范围内的数字多少。散列表可以极大简化这一工作,因为它能将对象同对象关联起来(此时是将Math.random()生成的值同那些值出现的次数关联起来)。如下所示:3278.4 集合的类型//: Statistics.java// Simple demonstration of Hashtableimport java.util.*;class Counter {int i = 1;public String toString() {return Integer.toString(i);}}class Statistics {public static void main(String[] args) {Hashtable ht = new Hashtable();for(int i = 0; i 0.5;public String toString() {if(shadow)return "Six more weeks of Winter!";elsereturn "Early Spring!";}}public class SpringDetector {public static void main(String[] args) {Hashtable ht = new Hashtable();for(int i = 0; i < 10; i++)ht.put(new Groundhog(i), new Prediction());System.out.println("ht = " + ht + "\n");System.out.println("Looking up prediction for groundhog #3:");Groundhog gh = new Groundhog(3);if(ht.containsKey(gh))System.out.println((Prediction)ht.get(gh));}} ///:~3298.4 集合的类型每个Groundhog都具有一个标识号码,所以赤了在散列表中查找一个Prediction,只需指示它“告诉我与Groundhog号码3相关的Prediction”。Prediction类包含了一个布尔值,用Math.random()进行初始化,以及一个toString()为我们解释结果。在main()中,用Groundhog以及与它们相关的Prediction填充一个散列表。散列表被打印出来,以便我们看到它们确实已被填充。随后,用标识号码为3的一个Groundhog查找与Groundhog #3对应的预报。看起来似乎非常简单,但实际是不可行的。问题在于Groundhog是从通用的Object根类继承的(若当初未指定基础类,则所有类最终都是从Object继承的)。事实上是用Object的hashCode()方法生成每个对象的散列码,而且默认情况下只使用它的对象的地址。所以,Groundhog(3)的第一个实例并不会产生与Groundhog(3)第二个实例相等的散列码,而我们用第二个实例进行检索。 大家或许认为此时要做的全部事情就是正确地覆盖hashCode()。但这样做依然行不能,除非再做另一件事情:覆盖也属于Object一部分的equals()。当散列表试图判断我们的键是否等于表内的某个键时,就会用到这个方法。同样地,默认的Object.equals()只是简单地比较对象地址,所以一个Groundhog(3)并不等于另一个Groundhog(3)。因此,为了在散列表中将自己的类作为键使用,必须同时覆盖hashCode()和equals(),就象下面展示的那样://: SpringDetector2.java// If you create a class that's used as a key in// a Hashtable, you must override hashCode()// and equals().import java.util.*;class Groundhog2 {int ghNumber;Groundhog2(int n) { ghNumber = n; }public int hashCode() { return ghNumber; }public boolean equals(Object o) {return (o instanceof Groundhog2)&& (ghNumber == ((Groundhog2)o).ghNumber);}}public class SpringDetector2 {public static void main(String[] args) {Hashtable ht = new Hashtable();for(int i = 0; i < 10; i++)ht.put(new Groundhog2(i),new Prediction());System.out.println("ht = " + ht + "\n");System.out.println("Looking up prediction for groundhog #3:");Groundhog2 gh = new Groundhog2(3);if(ht.containsKey(gh))System.out.println((Prediction)ht.get(gh));}} ///:~3308.4 集合的类型注意这段代码使用了来自前一个例子的Prediction,所以SpringDetector.java必须首先编译,否则就会在试图编译SpringDetector2.java时得到一个编译期错误。Groundhog2.hashCode()将土拔鼠号码作为一个标识符返回(在这个例子中,程序员需要保证没有两个土拔鼠用同样的ID号码并存)。为了返回一个独一无二的标识符,并不需要hashCode(),equals()方法必须能够严格判断两个对象是否相等。 equals()方法要进行两种检查:检查对象是否为null;若不为null,则继续检查是否为Groundhog2的一个实例(要用到instanceof关键字,第11章会详加论述)。即使为了继续执行equals(),它也应该是一个Groundhog2。正如大家看到的那样,这种比较建立在实际ghNumber的基础上。这一次一旦我们运行程序,就会看到它终于产生了正确的输出(许多Java库的类都覆盖了hashcode()和equals()方法,以便与自己提供的内容适应)。1. 属性:Hashtable的一种类型在本书的第一个例子中,我们使用了一个名为Properties(属性)的Hashtable类型。在那个例子中,下述程序行:Properties p = System.getProperties();p.list(System.out);调用了一个名为getProperties()的static方法,用于获得一个特殊的Properties对象,对系统的某些特征进行描述。list()属于Properties的一个方法,可将内容发给我们选择的任何流式输出。也有一个save()方法,可用它将属性列表写入一个文件,以便日后用load()方法读取。尽管Properties类是从Hashtable继承的,但它也包含了一个散列表,用于容纳“默认”属性的列表。所以假如没有在主列表里找到一个属性,就会自动搜索默认属性。Properties类亦可在我们的程序中使用(第17章的ClassScanner.java便是一例)。在Java库的用户文档中,往往可以找到更多、更详细的说明。8.4.5 再论枚举器我们现在可以开始演示Enumeration(枚举)的真正威力:将穿越一个序列的操作与那个序列的基础结构分隔开。在下面的例子里,PrintData类用一个Enumeration在一个序列中移动,并为每个对象都调用toString()方法。此时创建了两个不同类型的集合:一个Vector和一个Hashtable。并且在它们里面分别填充Mouse和Hamster对象(本章早些时候已定义了这些类;注意必须先编译HamsterMaze.java和WorksAnyway.java,否则下面的程序不能编译)。由于Enumeration隐藏了基层集合的结构,所以PrintData不知道或者不关心Enumeration来自于什么类型的集合:3318.4 集合的类型//: Enumerators2.java// Revisiting Enumerationsimport java.util.*;class PrintData {static void print(Enumeration e) {while(e.hasMoreElements())System.out.println(e.nextElement().toString());}}class Enumerators2 {public static void main(String[] args) {Vector v = new Vector();for(int i = 0; i < 5; i++)v.addElement(new Mouse(i));Hashtable h = new Hashtable();for(int i = 0; i left) {Object o1 = elementAt(right);int i = left - 1;int j = right;while(true) {while(compare.lessThan(elementAt(++i), o1));while(j > 0)if(compare.lessThanOrEqual(elementAt(--j), o1))break; // out of whileif(i >= j) break;swap(i, j);}swap(i , right);quickSort(left, i-1);quickSort(i+1, right);}}private void swap(int loc1, int loc2) {Object tmp = elementAt(loc1);setElementAt(elementAt(loc2), loc1);setElementAt(tmp, loc2);}} ///:~现在,大家可以明白“回调”一词的来历,这是由于quickSort()方法“往回调用”了Compare中的方法。从中亦可理解这种技术如何生成通用的、可重复利用(再生)的代码。为使用SortVector,必须创建一个类,令其为我们准备排序的对象实现Compare。此时内部类并不显得特别重要,但对于代码的组织却是有益的。下面是针对String对象的一个例子:3348.5 排序//: StringSortTest.java// Testing the generic sorting Vectorpackage c08;import java.util.*;public class StringSortTest {static class StringCompare implements Compare {public boolean lessThan(Object l, Object r) {return ((String)l).toLowerCase().compareTo(((String)r).toLowerCase()) < 0;}public booleanlessThanOrEqual(Object l, Object r) {return ((String)l).toLowerCase().compareTo(((String)r).toLowerCase()) <= 0;}}public static void main(String[] args) {SortVector sv =new SortVector(new StringCompare());sv.addElement("d");sv.addElement("A");sv.addElement("C");sv.addElement("c");sv.addElement("b");sv.addElement("B");sv.addElement("D");sv.addElement("a");sv.sort();Enumeration e = sv.elements();while(e.hasMoreElements())System.out.println(e.nextElement());}} ///:~内部类是“静态”(Static)的,因为它毋需连接一个外部类即可工作。大家可以看到,一旦设置好框架,就可以非常方便地重复使用象这样的一个设计——只需简单地写一个类,将“需要发生变化”的东西封装进去,然后将一个对象传给SortVector即可。比较时将字串强制为小写形式,所以大写A会排列于小写a的旁边,而不会移动一个完全不同的地方。然而,该例也显示了这种方法的一个不足,因为上述测试代码按照出现顺序排列同一个字母的大写和小写形式:A a b B c C d D。但这通常不是一个大问题,因为经常处理的都是更长的字串,所以上述效果不会显露出来(Java 1.2的集合提供了排序功能,已解决了这个问题)。继承(extends)在这儿用于创建一种新类型的Vector——也就是说,SortVector属于一种Vector,并带有一些附加的功能。继承在这里可发挥很大的作用,但了带来了问题。它使一些方法具有了final属性(已在第7章讲述),所以不能覆盖它们。如果想创建一个排好序的3358.5 排序Vector,令其只接收和生成String对象,就会遇到麻烦。因为addElement()和elementAt()都具有final属性,而且它们都是我们必须覆盖的方法,否则便无法实现只能接收和产生String对象。但在另一方面,请考虑采用“合成”方法:将一个对象置入一个新类的内部。此时,不是改写上述代码来达到这个目的,而是在新类里简单地使用一个SortVector。在这种情况下,用于实现Compare接口的内部类就可以“匿名”地创建。如下所示://: StrSortVector.java// Automatically sorted Vector that// accepts and produces only Stringspackage c08;import java.util.*;public class StrSortVector {private SortVector v = new SortVector(// Anonymous inner class:new Compare() {public booleanlessThan(Object l, Object r) {return((String)l).toLowerCase().compareTo(((String)r).toLowerCase()) < 0;}public booleanlessThanOrEqual(Object l, Object r) {return((String)l).toLowerCase().compareTo(((String)r).toLowerCase()) <= 0;}});private boolean sorted = false;public void addElement(String s) {v.addElement(s);sorted = false;}public String elementAt(int index) {if(!sorted) {v.sort();sorted = true;}return (String)v.elementAt(index);}public Enumeration elements() {if(!sorted) {v.sort();sorted = true;}return v.elements();}3368.5 排序// Test it:public static void main(String[] args) {StrSortVector sv = new StrSortVector();sv.addElement("d");sv.addElement("A");sv.addElement("C");sv.addElement("c");sv.addElement("b");sv.addElement("B");sv.addElement("D");sv.addElement("a");Enumeration e = sv.elements();while(e.hasMoreElements())System.out.println(e.nextElement());}} ///:~这样便可快速再生来自SortVector的代码,从而获得希望的功能。然而,并不是来自SortVector和Vector的所有public方法都能在StrSortVector中出现。若按这种形式再生代码,可在新类里为包含类内的每一个方法都生成一个定义。当然,也可以在刚开始时只添加少数几个,以后根据需要再添加更多的。新类的设计最终会稳定下来。这种方法的好处在于它仍然只接纳String对象,也只产生String对象。而且相应的检查是在编译期间进行的,而非在运行期。当然,只有addElement()和elementAt()才具备这一特性;elements()仍然会产生一个Enumeration(枚举),它在编译期的类型是未定的。当然,对Enumeration以及在StrSortVector中的类型检查会照旧进行;如果真的有什么错误,运行期间会简单地产生一个违例。事实上,我们在编译或运行期间能保证一切都正确无误吗?(也就是说,“代码测试时也许不能保证”,以及“该程序的用户有可能做一些未经我们测试的事情”)。尽管存在其他选择和争论,使用继承都要容易得多,只是在造型时让人深感不便。同样地,一旦为Java加入参数化类型,就有望解决这个问题。大家在这个类中可以看到有一个名为“sorted”的标志。每次调用addElement()时,都可对Vector进行排序,而且将其连续保持在一个排好序的状态。但在开始读取之前,人们总是向一个Vector添加大量元素。所以与其在每个addElement()后排序,不如一直等到有人想读取Vector,再对其进行排序。后者的效率要高得多。这种除非绝对必要,否则就不采取行动的方法叫作“懒惰求值”(还有一种类似的技术叫作“懒惰初始化”——除非真的需要一个字段值,否则不进行初始化)。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:103378.6 通用集合库8.6 通用集合库通过本章的学习,大家已知道标准Java库提供了一些特别有用的集合,但距完整意义的集合尚远。除此之外,象排序这样的算法根本没有提供支持。C++出色的一个地方就是它的库,特别是“标准模板库”(STL)提供了一套相当完整的集合,以及许多象排序和检索这样的算法,可以非常方便地对那些集合进行操作。有感这一现状,并以这个模型为基础,ObjectSpace公司设计了Java版本的“通用集合库”(从前叫作“Java通用库”,即JGL;但JGL这个缩写形式侵犯了Sun公司的版权——尽管本书仍然沿用这个简称)。这个库尽可能遵照STL的设计(照顾到两种语言间的差异)。JGL实现了许多功能,可满足对一个集合库的大多数常规需求,它与C++的模板机制非常相似。JGL包括相互链接起来的列表、设置、队列、映射、堆栈、序列以及反复器,它们的功能比Enumeration(枚举)强多了。同时提供了一套完整的算法,如检索和排序等。在某些方面,ObjectSpace的设计也显得比Sun的库设计方案“智能”一些。举个例子来说,JGL集合中的方法不会进入final状态,所以很容易继承和改写那些方法。JGL已包括到一些厂商发行的Java套件中,而且ObjectSpace公司自己也允许所有用户免费使用JGL,包括商业性的使用。详细情况和软件下载可访问 http://www.ObjectSpace.com 。与JGL配套提供的联机文档做得非常好,可作为自己的一个绝佳起点使用。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:103388.7 新集合8.7 新集合对我来说,集合类属于最强大的一种工具,特别适合在原创编程中使用。大家可能已感觉到我对Java 1.1提供的集合多少有点儿失望。因此,看到Java 1.2对集合重新引起了正确的注意后,确实令人非常愉快。这个版本的集合也得到了完全的重新设计(由Sun公司的JoshuaBloch)。我认为新设计的集合是Java 1.2中两项最主要的特性之一(另一项是Swing库,将在第13章叙述),因为它们极大方便了我们的编程,也使Java变成一种更成熟的编程系统。有些设计使得元素间的结合变得更紧密,也更容易让人理解。例如,许多名字都变得更短、更明确了,而且更易使用;类型同样如此。有些名字进行了修改,更接近于通俗:我感觉特别好的一个是用“反复器”(Inerator)代替了“枚举”(Enumeration)。此次重新设计也加强了集合库的功能。现在新增的行为包括链接列表、队列以及撤消组队(即“双终点队列”)。集合库的设计是相当困难的(会遇到大量库设计问题)。在C++中,STL用多个不同的类来覆盖基础。这种做法比起STL以前是个很大的进步,那时根本没做这方面的考虑。但仍然没有很好地转换到Java里面。结果就是一大堆特别容易混淆的类。在另一个极端,我曾发现一个集合库由单个类构成:colleciton,它同时作为Vector和Hashtable使用。新集合库的设计者则希望达到一种新的平衡:实现人们希望从一个成熟集合库上获得的完整功能,同时又要比STL和其他类似的集合库更易学习和使用。这样得到的结果在某些场合显得有些古怪。但和早期Java库的一些决策不同,这些古怪之处并非偶然出现的,而是以复杂性作为代价,在进行仔细权衡之后得到的结果。这样做也许会延长人们掌握一些库概念的时间,但很快就会发现自己很乐于使用那些新工具,而且变得越来越离不了它。新的集合库考虑到了“容纳自己对象”的问题,并将其分割成两个明确的概念:(1) 集合(Collection):一组单独的元素,通常应用了某种规则。在这里,一个List(列表)必须按特定的顺序容纳元素,而一个Set(集)不可包含任何重复的元素。相反,“包”(Bag)的概念未在新的集合库中实现,因为“列表”已提供了类似的功能。(2) 映射(Map):一系列“键-值”对(这已在散列表身上得到了充分的体现)。从表面看,这似乎应该成为一个“键-值”对的“集合”,但假若试图按那种方式实现它,就会发现实现过程相当笨拙。这进一步证明了应该分离成单独的概念。另一方面,可以方便地查看Map的某个部分。只需创建一个集合,然后用它表示那一部分即可。这样一来,Map就可以返回自己键的一个Set、一个包含自己值的List或者包含自己“键-值”对的一个List。和数组相似,Map可方便扩充到多个“维”,毋需涉及任何新概念。只需简单地在一个Map里包含其他Map(后者又可以包含更多的Map,以此类推)。Collection和Map可通过多种形式实现,具体由编程要求决定。下面列出的是一个帮助大家理解的新集合示意图:3398.7 新集合这张图刚开始的时候可能让人有点儿摸不着头脑,但在通读了本章以后,相信大家会真正理解它实际只有三个集合组件:Map,List和Set。而且每个组件实际只有两、三种实现方式(注释⑥),而且通常都只有一种特别好的方式。只要看出了这一点,集合就不会再令人生畏。⑥:写作本章时,Java 1.2尚处于β测试阶段,所以这张示意图没有包括以后会加入的TreeSet。虚线框代表“接口”,点线框代表“抽象”类,而实线框代表普通(实际)类。点线箭头表示一个特定的类准备实现一个接口(在抽象类的情况下,则是“部分”实现一个接口)。双线箭头表示一个类可生成箭头指向的那个类的对象。例如,任何集合都可以生成一个反复器(Iterator),而一个列表可以生成一个ListIterator(以及原始的反复器,因为列表是从集合继承的)。致力于容纳对象的接口是Collection,List,Set和Map。在传统情况下,我们需要写大量代码才能同这些接口打交道。而且为了指定自己想使用的准确类型,必须在创建之初进行设置。所以可能创建下面这样的一个List:List x = new LinkedList();当然,也可以决定将x作为一个LinkedList使用(而不是一个普通的List),并用x负载准确的类型信息。使用接口的好处就是一旦决定改变自己的实施细节,要做的全部事情就是在创建的时候改变它,就象下面这样:3408.7 新集合List x = new ArrayList();其余代码可以保持原封不动。在类的分级结构中,可看到大量以“Abstract”(抽象)开头的类,这刚开始可能会使人感觉迷惑。它们实际上是一些工具,用于“部分”实现一个特定的接口。举个例子来说,假如想生成自己的Set,就不是从Set接口开始,然后自行实现所有方法。相反,我们可以从AbstractSet继承,只需极少的工作即可得到自己的新类。尽管如此,新集合库仍然包含了足够的功能,可满足我们的几乎所有需求。所以考虑到我们的目的,可忽略所有以“Abstract”开头的类。因此,在观看这张示意图时,真正需要关心的只有位于最顶部的“接口”以及普通(实际)类——均用实线方框包围。通常需要生成实际类的一个对象,将其上溯造型为对应的接口。以后即可在代码的任何地方使用那个接口。下面是一个简单的例子,它用String对象填充一个集合,然后打印出集合内的每一个元素://: SimpleCollection.java// A simple example using the new Collectionspackage c08.newcollections;import java.util.*;public class SimpleCollection {public static void main(String[] args) {Collection c = new ArrayList();for(int i = 0; i < 10; i++)c.add(Integer.toString(i));Iterator it = c.iterator();while(it.hasNext())System.out.println(it.next());}} ///:~新集合库的所有代码示例都置于子目录newcollections下,这样便可提醒自己这些工作只对于Java 1.2有效。这样一来,我们必须用下述代码来调用程序:java c08.newcollections.SimpleCollection采用的语法与其他程序是差不多的。大家可以看到新集合属于java.util库的一部分,所以在使用时不需要再添加任何额外的import语句。main()的第一行创建了一个ArrayList对象,然后将其上溯造型成为一个集合。由于这个例子只使用了Collection方法,所以从Collection继承的一个类的任何对象都可以正常工作。但ArrayList是一个典型的Collection,它代替了Vector的位置。 显然,add()方法的作用是将一个3418.7 新集合新元素置入集合里。然而,用户文档谨慎地指出add()“保证这个集合包含了指定的元素”。这一点是为Set作铺垫的,后者只有在元素不存在的前提下才会真的加入那个元素。对于ArrayList以及其他任何形式的List,add()肯定意味着“直接加入”。利用iterator()方法,所有集合都能生成一个“反复器”(Iterator)。反复器其实就象一个“枚举”(Enumeration),是后者的一个替代物,只是:(1) 它采用了一个历史上默认、而且早在OOP中得到广泛采纳的名字(反复器)。(2) 采用了比Enumeration更短的名字:hasNext()代替了hasMoreElement(),而next()代替了nextElement()。(3) 添加了一个名为remove()的新方法,可删除由Iterator生成的上一个元素。所以每次调用next()的时候,只需调用remove()一次。在SimpleCollection.java中,大家可看到创建了一个反复器,并用它在集合里遍历,打印出每个元素。8.7.1 使用Collections下面这张表格总结了用一个集合能做的所有事情(亦可对Set和List做同样的事情,尽管List还提供了一些额外的功能)。Map不是从Collection继承的,所以要单独对待。Boolean add(Object)*Ensures that the Collection contains the argument. Returns false if it doesn’t add the argument.Boolean addAll(Collection)*Adds all the elements in the argument. Returns true if any elements were added.void clear( )*Removes all the elements in the Collection.Boolean contains(Object)True if the Collection contains the argument.Boolean containsAll(Collection)True if the Collection contains all the elements in the argument.Boolean isEmpty( )True if the Collection has no elements.Iterator iterator( )3428.7 新集合Returns an Iterator that you can use to move through the elements in the Collection.Boolean remove(Object)*If the argument is in the Collection, one instance of that element is removed. Returns true if a removal occurred.Boolean removeAll(Collection)*Removes all the elements that are contained in the argument. Returns true if any removals occurred.Boolean retainAll(Collection)*Retains only elements that are contained in the argument (an “intersection” from settheory). Returns true if any changes occurred.int size( )Returns the number of elements in the Collection.Object[] toArray( )Returns an array containing all the elements in the Collection.Object[] toArray(Object[] a)Returns an array containing all the elements in the Collection, whose type is that ofthe array a rather than plain Object (you must cast the array to the right type).*This is an “optional” method, which means it might not be implemented by a particularCollection. If not, that method throws an UnsupportedOperationException. Exceptions will be covered in Chapter 9.boolean add(Object) *保证集合内包含了自变量。如果它没有添加自变量,就返回false(假)boolean addAll(Collection) *添加自变量内的所有元素。如果没有添加元素,则返回true(真)void clear() *删除集合内的所有元素boolean contains(Object) 若集合包含自变量,就返回“真”boolean containsAll(Collection) 若集合包含了自变量内的所有元素,就返回“真”boolean isEmpty() 若集合内没有元素,就返回“真”Iterator iterator() 返回一个反复器,以用它遍历集合的各元素boolean remove(Object) *如自变量在集合里,就删除那个元素的一个实例。如果已进行了删除,就返回“真”boolean removeAll(Collection) *删除自变量里的所有元素。如果已进行了任何删除,就返回“真”boolean retainAll(Collection) *只保留包含在一个自变量里的元素(一个理论的“交集”)。如果已进行了任何改变,就返回“真”int size() 返回集合内的元素数量Object[] toArray() 返回包含了集合内所有元素的一个数组*这是一个“可选的”方法,有的集合可能并未实现它。若确实如此,该方法就会遇到一个UnsupportedOperatiionException,即一个“操作不支持”违例,详见第9章。3438.7 新集合下面这个例子向大家演示了所有方法。同样地,它们只对从集合继承的东西有效,一个ArrayList作为一种“不常用的分母”使用://: Collection1.java// Things you can do with all Collectionspackage c08.newcollections;import java.util.*;public class Collection1 {// Fill with 'size' elements, start// counting at 'start':public static Collectionfill(Collection c, int start, int size) {for(int i = start; i < start + size; i++)c.add(Integer.toString(i));return c;}// Default to a "start" of 0:public static Collectionfill(Collection c, int size) {return fill(c, 0, size);}// Default to 10 elements:public static Collection fill(Collection c) {return fill(c, 0, 10);}// Create & upcast to Collection:public static Collection newCollection() {return fill(new ArrayList());// ArrayList is used for simplicity, but it's// only seen as a generic Collection// everywhere else in the program.}// Fill a Collection with a range of values:public static CollectionnewCollection(int start, int size) {return fill(new ArrayList(), start, size);}// Moving through a List with an iterator:public static void print(Collection c) {for(Iterator x = c.iterator(); x.hasNext();)System.out.print(x.next() + " ");System.out.println();}public static void main(String[] args) {Collection c = newCollection();c.add("ten");c.add("eleven");print(c);// Make an array from the List:Object[] array = c.toArray();// Make a String array from the List:3448.7 新集合String[] str =(String[])c.toArray(new String[1]);// Find max and min elements; this means// different things depending on the way// the Comparable interface is implemented:System.out.println("Collections.max(c) = " +Collections.max(c));System.out.println("Collections.min(c) = " +Collections.min(c));// Add a Collection to another Collectionc.addAll(newCollection());print(c);c.remove("3"); // Removes the first oneprint(c);c.remove("3"); // Removes the second oneprint(c);// Remove all components that are in the// argument collection:c.removeAll(newCollection());print(c);c.addAll(newCollection());print(c);// Is an element in this Collection?System.out.println("c.contains(\"4\") = " + c.contains("4"));// Is a Collection in this Collection?System.out.println("c.containsAll(newCollection()) = " +c.containsAll(newCollection()));Collection c2 = newCollection(5, 3);// Keep all the elements that are in both// c and c2 (an intersection of sets):c.retainAll(c2);print(c);// Throw away all the elements in c that// also appear in c2:c.removeAll(c2);System.out.println("c.isEmpty() = " +c.isEmpty());c = newCollection();print(c);c.clear(); // Remove all elementsSystem.out.println("after c.clear():");print(c);}} ///:~通过第一个方法,我们可用测试数据填充任何集合。在当前这种情况下,只是将int转换成String。第二个方法将在本章其余的部分经常采用。3458.7 新集合newCollection()的两个版本都创建了ArrayList,用于包含不同的数据集,并将它们作为集合对象返回。所以很明显,除了Collection接口之外,不会再用到其他什么。print()方法也会在本节经常用到。由于它用一个反复器(Iterator)在一个集合内遍历,而任何集合都可以产生这样的一个反复器,所以它适用于List和Set,也适用于由一个Map生成的Collection。main()用简单的手段显示出了集合内的所有方法。在后续的小节里,我们将比较List,Set和Map的不同实现方案,同时指出在各种情况下哪一种方案应成为首选(带有星号的那个)。大家会发现这里并未包括一些传统的类,如Vector,Stack以及Hashtable等。因为不管在什么情况下,新集合内都有自己首选的类。8.7.2 使用ListsList (interface)Order is the most important feature of a List; it promises to maintain elements in a particular sequence. List adds a number of methods to Collection that allow insertion and removal of elements in the middle of a List. (This is recommended only for a LinkedList.) A List will produce a ListIterator, and using this you can traverse the List inboth directions, as well as insert and remove elements in the middle of the list (again, recommended only for a LinkedList).ArrayList*A List backed by an array. Use instead of Vector as a general-purpose object holder. Allows rapid random access to elements, but is slow when inserting and removing elements from the middle of a list. ListIterator should be used only for back-and-forth traversal of an ArrayList, but not for inserting and removing elements, which is expensivecompared to LinkedList.LinkedListProvides optimal sequential access, with inexpensive insertions and deletions from themiddle of the list. Relatively slow for random access. (Use ArrayList instead.) Alsohas addFirst( ), addLast( ), getFirst( ), getLast( ), removeFirst( ), and removeLast() (which are not defined in any interfaces or base classes) to allow it to be used asa stack, a queue, and a dequeue.List(接口) 顺序是List最重要的特性;它可保证元素按照规定的顺序排列。List为Collection添加了大量方法,以便我们在List中部插入和删除元素(只推荐对LinkedList这样做)。List也会生成一个ListIterator(列表反复器),利用它可在一个列表里朝两个方向遍历,同时插入和删除位于列表中部的元素(同样地,只建议对LinkedList这样做)ArrayList* 由一个数组后推得到的List。作为一个常规用途的对象容器使用,用于替换原先的Vector。允许我们快速访问元素,但在从列表中部插入和删除元素时,速度却嫌稍慢。一般只应该用ListIterator对一个ArrayList进行向前和向后遍历,不要用它删除和插入元素;与3468.7 新集合LinkedList相比,它的效率要低许多LinkedList 提供优化的顺序访问性能,同时可以高效率地在列表中部进行插入和删除操作。但在进行随机访问时,速度却相当慢,此时应换用ArrayList。也提供了addFirst(),addLast(),getFirst(),getLast(),removeFirst()以及removeLast()(未在任何接口或基础类中定义),以便将其作为一个规格、队列以及一个双向队列使用下面这个例子中的方法每个都覆盖了一组不同的行为:每个列表都能做的事情(basicTest()),通过一个反复器遍历(iterMotion())、用一个反复器改变某些东西(iterManipulation())、体验列表处理的效果(testVisual())以及只有LinkedList才能做的事情等://: List1.java// Things you can do with Listspackage c08.newcollections;import java.util.*;public class List1 {// Wrap Collection1.fill() for convenience:public static List fill(List a) {return (List)Collection1.fill(a);}// You can use an Iterator, just as with a// Collection, but you can also use random// access with get():public static void print(List a) {for(int i = 0; i < a.size(); i++)System.out.print(a.get(i) + " ");System.out.println();}static boolean b;static Object o;static int i;static Iterator it;static ListIterator lit;public static void basicTest(List a) {a.add(1, "x"); // Add at location 1a.add("x"); // Add at end// Add a collection:a.addAll(fill(new ArrayList()));// Add a collection starting at location 3:a.addAll(3, fill(new ArrayList()));b = a.contains("1"); // Is it in there?// Is the entire collection in there?b = a.containsAll(fill(new ArrayList()));// Lists allow random access, which is cheap// for ArrayList, expensive for LinkedList:o = a.get(1); // Get object at location 1i = a.indexOf("1"); // Tell index of object// indexOf, starting search at location 2:3478.7 新集合i = a.indexOf("1", 2);b = a.isEmpty(); // Any elements inside?it = a.iterator(); // Ordinary Iteratorlit = a.listIterator(); // ListIteratorlit = a.listIterator(3); // Start at loc 3i = a.lastIndexOf("1"); // Last matchi = a.lastIndexOf("1", 2); // ...after loc 2a.remove(1); // Remove location 1a.remove("3"); // Remove this objecta.set(1, "y"); // Set location 1 to "y"// Keep everything that's in the argument// (the intersection of the two sets):a.retainAll(fill(new ArrayList()));// Remove elements in this range:a.removeRange(0, 2);// Remove everything that's in the argument:a.removeAll(fill(new ArrayList()));i = a.size(); // How big is it?a.clear(); // Remove all elements}public static void iterMotion(List a) {ListIterator it = a.listIterator();b = it.hasNext();b = it.hasPrevious();o = it.next();i = it.nextIndex();o = it.previous();i = it.previousIndex();}public static void iterManipulation(List a) {ListIterator it = a.listIterator();it.add("47");// Must move to an element after add():it.next();// Remove the element that was just produced:it.remove();// Must move to an element after remove():it.next();// Change the element that was just produced:it.set("47");}public static void testVisual(List a) {print(a);List b = new ArrayList();fill(b);System.out.print("b = ");print(b);a.addAll(b);a.addAll(fill(new ArrayList()));print(a);// Shrink the list by removing all the// elements beyond the first 1/2 of the listSystem.out.println(a.size());3488.7 新集合System.out.println(a.size()/2);a.removeRange(a.size()/2, a.size()/2 + 2);print(a);// Insert, remove, and replace elements// using a ListIterator:ListIterator x = a.listIterator(a.size()/2);x.add("one");print(a);System.out.println(x.next());x.remove();System.out.println(x.next());x.set("47");print(a);// Traverse the list backwards:x = a.listIterator(a.size());while(x.hasPrevious())System.out.print(x.previous() + " ");System.out.println();System.out.println("testVisual finished");}// There are some things that only// LinkedLists can do:public static void testLinkedList() {LinkedList ll = new LinkedList();Collection1.fill(ll, 5);print(ll);// Treat it like a stack, pushing:ll.addFirst("one");ll.addFirst("two");print(ll);// Like "peeking" at the top of a stack:System.out.println(ll.getFirst());// Like popping a stack:System.out.println(ll.removeFirst());System.out.println(ll.removeFirst());// Treat it like a queue, pulling elements// off the tail end:System.out.println(ll.removeLast());// With the above operations, it's a dequeue!print(ll);}public static void main(String args[]) {// Make and fill a new list each time:basicTest(fill(new LinkedList()));basicTest(fill(new ArrayList()));iterMotion(fill(new LinkedList()));iterMotion(fill(new ArrayList()));iterManipulation(fill(new LinkedList()));iterManipulation(fill(new ArrayList()));testVisual(fill(new LinkedList()));testLinkedList();}} ///:~3498.7 新集合在basicTest()和iterMotiion()中,只是简单地发出调用,以便揭示出正确的语法。而且尽管捕获了返回值,但是并未使用它。在某些情况下,之所以不捕获返回值,是由于它们没有什么特别的用处。在正式使用它们前,应仔细研究一下自己的联机文档,掌握这些方法完整、正确的用法。8.7.3 使用SetsSet拥有与Collection完全相同的接口,所以和两种不同的List不同,它没有什么额外的功能。相反,Set完全就是一个Collection,只是具有不同的行为(这是实例和多形性最理想的应用:用于表达不同的行为)。在这里,一个Set只允许每个对象存在一个实例(正如大家以后会看到的那样,一个对象的“值”的构成是相当复杂的)。Set (interface)Each element that you add to the Set must be unique; otherwise the Set doesn’t add theduplicate element. Objects added to a Set must define equals( ) to establish object uniqueness. Set has exactly the same interface as Collection. The Set interface does not guarantee it will maintain its elements in any particular order.HashSet*For Sets where fast lookup time is important. Objects must also define hashCode( ).TreeSetAn ordered Set backed by a red-black tree. This way, you can extract an ordered sequence from a Set.Set(接口) 添加到Set的每个元素都必须是独一无二的;否则Set就不会添加重复的元素。添加到Set里的对象必须定义equals(),从而建立对象的唯一性。Set拥有与Collection完全相同的接口。一个Set不能保证自己可按任何特定的顺序维持自己的元素HashSet* 用于除非常小的以外的所有Set。对象也必须定义hashCode() ArraySet 由一个数组后推得到的Set。面向非常小的Set设计,特别是那些需要频繁创建和删除的。对于小Set,与HashSet相比,ArraySet创建和反复所需付出的代价都要小得多。但随着Set的增大,它的性能也会大打折扣。不需要HashCode() TreeSet 由一个“红黑树”后推得到的顺序Set(注释⑦)。这样一来,我们就可以从一个Set里提到一个顺序集合⑦:直至本书写作的时候,TreeSet仍然只是宣布,尚未正式实现。所以这里没有提供使用TreeSet的例子。下面这个例子并没有列出用一个Set能够做的全部事情,因为接口与Collection是相同的,前例已经练习过了。相反,我们要例示的重点在于使一个Set独一无二的行为:3508.7 新集合//: Set1.java// Things you can do with Setspackage c08.newcollections;import java.util.*;public class Set1 {public static void testVisual(Set a) {Collection1.fill(a);Collection1.fill(a);Collection1.fill(a);Collection1.print(a); // No duplicates!// Add another set to this one:a.addAll(a);a.add("one");a.add("one");a.add("one");Collection1.print(a);// Look something up:System.out.println("a.contains(\"one\"): " +a.contains("one"));}public static void main(String[] args) {testVisual(new HashSet());testVisual(new TreeSet());}} ///:~重复的值被添加到Set,但在打印的时候,我们会发现Set只接受每个值的一个实例。运行这个程序时,会注意到由HashSet维持的顺序与ArraySet是不同的。这是由于它们采用了不同的方法来保存元素,以便它们以后的定位。ArraySet保持着它们的顺序状态,而HashSet使用一个散列函数,这是特别为快速检索设计的)。创建自己的类型时,一定要注意Set需要通过一种方式来维持一种存储顺序,就象本章早些时候展示的“groundhog”(土拔鼠)例子那样。下面是一个例子:3518.7 新集合//: Set2.java// Putting your own type in a Setpackage c08.newcollections;import java.util.*;class MyType implements Comparable {private int i;public MyType(int n) { i = n; }public boolean equals(Object o) {return(o instanceof MyType)&& (i == ((MyType)o).i);}public int hashCode() { return i; }public String toString() { return i + " "; }public int compareTo(Object o) {int i2 = ((MyType) o).i;return (i2 < i ? -1 : (i2 == i ? 0 : 1));}}public class Set2 {public static Set fill(Set a, int size) {for(int i = 0; i < size; i++)a.add(new MyType(i));return a;}public static Set fill(Set a) {return fill(a, 10);}public static void test(Set a) {fill(a);fill(a); // Try to add duplicatesfill(a);a.addAll(fill(new TreeSet()));System.out.println(a);}public static void main(String[] args) {test(new HashSet());test(new TreeSet());}} ///:~对equals()及hashCode()的定义遵照“groundhog”例子已经给出的形式。在两种情况下都必须定义一个equals()。但只有要把类置入一个HashSet的前提下,才有必要使用hashCode()——这种情况是完全有可能的,因为通常应先选择作为一个Set实现。8.7.4 使用Maps3528.7 新集合Map (interface)Maintains key-value associations (pairs), so you can look up a value using a key.HashMap*Implementation based on a hash table. (Use this instead of Hashtable.) Provides constant-time performance for inserting and locating pairs. Performance can be adjusted viaconstructors that allow you to set the capacity and load factor of the hash table.TreeMapImplementation based on a red-black tree. When you view the keys or the pairs, they will be in sorted order (determined by Comparable or Comparator, discussed later). The point of a TreeMap is that you get the results in sorted order. TreeMap is the only Mapwith the subMap( ) method, which allows you to return a portion of the tree.Map(接口) 维持“键-值”对应关系(对),以便通过一个键查找相应的值HashMap*基于一个散列表实现(用它代替Hashtable)。针对“键-值”对的插入和检索,这种形式具有最稳定的性能。可通过构建器对这一性能进行调整,以便设置散列表的“能力”和“装载因子”ArrayMap 由一个ArrayList后推得到的Map。对反复的顺序提供了精确的控制。面向非常小的Map设计,特别是那些需要经常创建和删除的。对于非常小的Map,创建和反复所付出的代价要比HashMap低得多。但在Map变大以后,性能也会相应地大幅度降低TreeMap 在一个“红-黑”树的基础上实现。查看键或者“键-值”对时,它们会按固定的顺序排列(取决于Comparable或 Comparator,稍后即会讲到)。TreeMap最大的好处就是我们得到的是已排好序的结果。TreeMap是含有subMap()方法的唯一一种Map,利用它可以返回树的一部分下例包含了两套测试数据以及一个fill()方法,利用该方法可以用任何两维数组(由Object构成)填充任何Map。这些工具也会在其他Map例子中用到。//: Map1.java// Things you can do with Mapspackage c08.newcollections;import java.util.*;public class Map1 {public final static String[][] testData1 = {{ "Happy", "Cheerful disposition" },{ "Sleepy", "Prefers dark, quiet places" },{ "Grumpy", "Needs to work on attitude" },{ "Doc", "Fantasizes about advanced degree"},{ "Dopey", "'A' for effort" },{ "Sneezy", "Struggles with allergies" },3538.7 新集合{ "Bashful", "Needs self-esteem workshop"},};public final static String[][] testData2 = {{ "Belligerent", "Disruptive influence" },{ "Lazy", "Motivational problems" },{ "Comatose", "Excellent behavior" }};public static Map fill(Map m, Object[][] o) {for(int i = 0; i < o.length; i++)m.put(o[i][0], o[i][1]);return m;}// Producing a Set of the keys:public static void printKeys(Map m) {System.out.print("Size = " + m.size() +", ");System.out.print("Keys: ");Collection1.print(m.keySet());}// Producing a Collection of the values:public static void printValues(Map m) {System.out.print("Values: ");Collection1.print(m.values());}// Iterating through Map.Entry objects (pairs):public static void print(Map m) {Collection entries = m.entries();Iterator it = entries.iterator();while(it.hasNext()) {Map.Entry e = (Map.Entry)it.next();System.out.println("Key = " + e.getKey() +", Value = " + e.getValue());}}public static void test(Map m) {fill(m, testData1);// Map has 'Set' behavior for keys:fill(m, testData1);printKeys(m);printValues(m);print(m);String key = testData1[4][0];String value = testData1[4][1];System.out.println("m.containsKey(\"" + key +"\"): " + m.containsKey(key));System.out.println("m.get(\"" + key + "\"): "+ m.get(key));System.out.println("m.containsValue(\""+ value + "\"): " +m.containsValue(value));Map m2 = fill(new TreeMap(), testData2);m.putAll(m2);printKeys(m);m.remove(testData2[0][0]);3548.7 新集合printKeys(m);m.clear();System.out.println("m.isEmpty(): "+ m.isEmpty());fill(m, testData1);// Operations on the Set change the Map:m.keySet().removeAll(m.keySet());System.out.println("m.isEmpty(): "+ m.isEmpty());}public static void main(String args[]) {System.out.println("Testing HashMap");test(new HashMap());System.out.println("Testing TreeMap");test(new TreeMap());}} ///:~printKeys(),printValues()以及print()方法并不只是有用的工具,它们也清楚地揭示了一个Map的Collection“景象”的产生过程。keySet()方法会产生一个Set,它由Map中的键后推得来。在这儿,它只被当作一个Collection对待。values()也得到了类似的对待,它的作用是产生一个List,其中包含了Map中的所有值(注意键必须是独一无二的,而值可以有重复)。由于这些Collection是由Map后推得到的,所以一个Collection中的任何改变都会在相应的Map中反映出来。print()方法的作用是收集由entries产生的Iterator(反复器),并用它同时打印出每个“键-值”对的键和值。程序剩余的部分提供了每种Map操作的简单示例,并对每种类型的Map进行了测试。当创建自己的类,将其作为Map中的一个键使用时,必须注意到和以前的Set相同的问题。8.7.5 决定实施方案从早些时候的那幅示意图可以看出,实际上只有三个集合组件:Map,List和Set。而且每个接口只有两种或三种实施方案。若需使用由一个特定的接口提供的功能,如何才能决定到底采取哪一种方案呢?为理解这个问题,必须认识到每种不同的实施方案都有自己的特点、优点和缺点。比如在那张示意图中,可以看到Hashtable,Vector和Stack的“特点”是它们都属于“传统”类,所以不会干扰原有的代码。但在另一方面,应尽量避免为新的(Java 1.2)代码使用它们。其他集合间的差异通常都可归纳为它们具体是由什么“后推”的。换言之,取决于物理意义上用于实施目标接口的数据结构是什么。例如,ArrayList,LinkedList以及Vector(大致等价于ArrayList)都实现了List接口,所以无论选用哪一个,我们的程序都会得到类似的结果。然而,ArrayList(以及Vector)是由一个数组后推得到的;而LinkedList是根据常规的双重链接列表方式实现的,因为每个单独的对象都包含了数据以及指向列表内前后元素的句柄。正是3558.7 新集合由于这个原因,假如想在一个列表中部进行大量插入和删除操作,那么LinkedList无疑是最恰当的选择(LinkedList还有一些额外的功能,建立于AbstractSequentialList中)。若非如此,就情愿选择ArrayList,它的速度可能要快一些。作为另一个例子,Set既可作为一个ArraySet实现,亦可作为HashSet实现。ArraySet是由一个ArrayList后推得到的,设计成只支持少量元素,特别适合要求创建和删除大量Set对象的场合使用。然而,一旦需要在自己的Set中容纳大量元素,ArraySet的性能就会大打折扣。写一个需要Set的程序时,应默认选择HashSet。而且只有在某些特殊情况下(对性能的提升有迫切的需求),才应切换到ArraySet。1. 决定使用何种List为体会各种List实施方案间的差异,最简便的方法就是进行一次性能测验。下述代码的作用是建立一个内部基础类,将其作为一个测试床使用。然后为每次测验都创建一个匿名内部类。每个这样的内部类都由一个test()方法调用。利用这种方法,可以方便添加和删除测试项目。//: ListPerformance.java// Demonstrates performance differences in Listspackage c08.newcollections;import java.util.*;public class ListPerformance {private static final int REPS = 100;private abstract static class Tester {String name;int size; // Test quantityTester(String name, int size) {this.name = name;this.size = size;}abstract void test(List a);}private static Tester[] tests = {new Tester("get", 300) {void test(List a) {for(int i = 0; i < REPS; i++) {for(int j = 0; j < a.size(); j++)a.get(j);}}},new Tester("iteration", 300) {void test(List a) {for(int i = 0; i < REPS; i++) {Iterator it = a.iterator();while(it.hasNext())it.next();}}},3568.7 新集合new Tester("insert", 1000) {void test(List a) {int half = a.size()/2;String s = "test";ListIterator it = a.listIterator(half);for(int i = 0; i < size * 10; i++)it.add(s);}},new Tester("remove", 5000) {void test(List a) {ListIterator it = a.listIterator(3);while(it.hasNext()) {it.next();it.remove();}}},};public static void test(List a) {// A trick to print out the class name:System.out.println("Testing " +a.getClass().getName());for(int i = 0; i < tests.length; i++) {Collection1.fill(a, tests[i].size);System.out.print(tests[i].name);long t1 = System.currentTimeMillis();tests[i].test(a);long t2 = System.currentTimeMillis();System.out.println(": " + (t2 - t1));}}public static void main(String[] args) {test(new ArrayList());test(new LinkedList());}} ///:~内部类Tester是一个抽象类,用于为特定的测试提供一个基础类。它包含了一个要在测试开始时打印的字串、一个用于计算测试次数或元素数量的size参数、用于初始化字段的一个构建器以及一个抽象方法test()。test()做的是最实际的测试工作。各种类型的测试都集中到一个地方:tests数组。我们用继承于Tester的不同匿名内部类来初始化该数组。为添加或删除一个测试项目,只需在数组里简单地添加或移去一个内部类定义即可,其他所有工作都是自动进行的。首先用元素填充传递给test()的List,然后对tests数组中的测试计时。由于测试用机器的不同,结果当然也会有所区别。这个程序的宗旨是揭示出不同集合类型的相对性能比较。下面是某一次运行得到的结果:类型 获取 反复 插入 删除3578.7 新集合ArrayList 110 270 1920 4780LinkedList 1870 7580 170 110可以看出,在ArrayList中进行随机访问(即get())以及循环反复是最划得来的;但对于LinkedList却是一个不小的开销。但另一方面,在列表中部进行插入和删除操作对于LinkedList来说却比ArrayList划算得多。我们最好的做法也许是先选择一个ArrayList作为自己的默认起点。以后若发现由于大量的插入和删除造成了性能的降低,再考虑换成LinkedList不迟。1. 决定使用何种Set可在ArraySet以及HashSet间作出选择,具体取决于Set的大小(如果需要从一个Set中获得一个顺序列表,请用TreeSet;注释⑧)。下面这个测试程序将有助于大家作出这方面的抉择://: SetPerformance.javapackage c08.newcollections;import java.util.*;public class SetPerformance {private static final int REPS = 200;private abstract static class Tester {String name;Tester(String name) { this.name = name; }abstract void test(Set s, int size);}private static Tester[] tests = {new Tester("add") {void test(Set s, int size) {for(int i = 0; i < REPS; i++) {s.clear();Collection1.fill(s, size);}}},new Tester("contains") {void test(Set s, int size) {for(int i = 0; i < REPS; i++)for(int j = 0; j < size; j++)s.contains(Integer.toString(j));}},new Tester("iteration") {void test(Set s, int size) {for(int i = 0; i < REPS * 10; i++) {Iterator it = s.iterator();while(it.hasNext())it.next();}}3588.7 新集合},};public static void test(Set s, int size) {// A trick to print out the class name:System.out.println("Testing " +s.getClass().getName() + " size " + size);Collection1.fill(s, size);for(int i = 0; i < tests.length; i++) {System.out.print(tests[i].name);long t1 = System.currentTimeMillis();tests[i].test(s, size);long t2 = System.currentTimeMillis();System.out.println(": " +((double)(t2 - t1)/(double)size));}}public static void main(String[] args) {// Small:test(new TreeSet(), 10);test(new HashSet(), 10);// Medium:test(new TreeSet(), 100);test(new HashSet(), 100);// Large:test(new HashSet(), 1000);test(new TreeSet(), 1000);}} ///:~⑧:TreeSet在本书写作时尚未成为一个正式的特性,但在这个例子中可以很轻松地为其添加一个测试。最后对ArraySet的测试只有500个元素,而不是1000个,因为它太慢了。类型 测试大小 添加 包含 反复TypeTest sizeAddContainsIteration1022.011.03598.7 新集合16.0TreeSet10022.513.212.1100031.118.711.8105.06.027.0HashSet1006.66.610.910007.46.69.5进行add()以及contains()操作时,HashSet显然要比ArraySet出色得多,而且性能明显与元素的多寡关系不大。一般编写程序的时候,几乎永远用不着使用ArraySet。1. 决定使用何种Map3608.7 新集合选择不同的Map实施方案时,注意Map的大小对于性能的影响是最大的,下面这个测试程序清楚地阐示了这一点://: MapPerformance.java// Demonstrates performance differences in Mapspackage c08.newcollections;import java.util.*;public class MapPerformance {private static final int REPS = 200;public static Map fill(Map m, int size) {for(int i = 0; i < size; i++) {String x = Integer.toString(i);m.put(x, x);}return m;}private abstract static class Tester {String name;Tester(String name) { this.name = name; }abstract void test(Map m, int size);}private static Tester[] tests = {new Tester("put") {void test(Map m, int size) {for(int i = 0; i < REPS; i++) {m.clear();fill(m, size);}}},new Tester("get") {void test(Map m, int size) {for(int i = 0; i < REPS; i++)for(int j = 0; j < size; j++)m.get(Integer.toString(j));}},new Tester("iteration") {void test(Map m, int size) {for(int i = 0; i < REPS * 10; i++) {Iterator it = m.entries().iterator();while(it.hasNext())it.next();}}},};public static void test(Map m, int size) {// A trick to print out the class name:System.out.println("Testing " +m.getClass().getName() + " size " + size);3618.7 新集合fill(m, size);for(int i = 0; i < tests.length; i++) {System.out.print(tests[i].name);long t1 = System.currentTimeMillis();tests[i].test(m, size);long t2 = System.currentTimeMillis();System.out.println(": " +((double)(t2 - t1)/(double)size));}}public static void main(String[] args) {// Small:test(new Hashtable(), 10);test(new HashMap(), 10);test(new TreeMap(), 10);// Medium:test(new Hashtable(), 100);test(new HashMap(), 100);test(new TreeMap(), 100);// Large:test(new HashMap(), 1000);test(new Hashtable(), 1000);test(new TreeMap(), 1000);}} ///:~由于Map的大小是最严重的问题,所以程序的计时测试按Map的大小(或容量)来分割时间,以便得到令人信服的测试结果。下面列出一系列结果(在你的机器上可能不同):类型 测试大小 置入 取出 反复 TypeTest sizePutGetIteration1011.05.044.0Hashtable1007.73628.7 新集合7.716.510008.08.014.41016.011.022.0TreeMap10025.815.413.2100033.820.913.61011.06.033.0HashMap1008.27.73638.7 新集合13.710008.07.811.9即使大小为10,ArrayMap的性能也要比HashMap差——除反复循环时以外。而在使用Map时,反复的作用通常并不重要(get()通常是我们时间花得最多的地方)。TreeMap提供了出色的put()以及反复时间,但get()的性能并不佳。但是,我们为什么仍然需要使用TreeMap呢?这样一来,我们可以不把它作为Map使用,而作为创建顺序列表的一种途径。树的本质在于它总是顺序排列的,不必特别进行排序(它的排序方式马上就要讲到)。一旦填充了一个TreeMap,就可以调用keySet()来获得键的一个Set“景象”。然后用toArray()产生包含了那些键的一个数组。随后,可用static方法Array.binarySearch()快速查找排好序的数组中的内容。当然,也许只有在HashMap的行为不可接受的时候,才需要采用这种做法。因为HashMap的设计宗旨就是进行快速的检索操作。最后,当我们使用Map时,首要的选择应该是HashMap。只有在极少数情况下才需要考虑其他方法。 此外,在上面那张表里,有另一个性能问题没有反映出来。下述程序用于测试不同类型Map的创建速度:3648.7 新集合//: MapCreation.java// Demonstrates time differences in Map creationpackage c08.newcollections;import java.util.*;public class MapCreation {public static void main(String[] args) {final long REPS = 100000;long t1 = System.currentTimeMillis();System.out.print("Hashtable");for(long i = 0; i < REPS; i++)new Hashtable();long t2 = System.currentTimeMillis();System.out.println(": " + (t2 - t1));t1 = System.currentTimeMillis();System.out.print("TreeMap");for(long i = 0; i < REPS; i++)new TreeMap();t2 = System.currentTimeMillis();System.out.println(": " + (t2 - t1));t1 = System.currentTimeMillis();System.out.print("HashMap");for(long i = 0; i < REPS; i++)new HashMap();t2 = System.currentTimeMillis();System.out.println(": " + (t2 - t1));}} ///:~在写这个程序期间,TreeMap的创建速度比其他两种类型明显快得多(但你应亲自尝试一下,因为据说新版本可能会改善ArrayMap的性能)。考虑到这方面的原因,同时由于前述TreeMap出色的put()性能,所以如果需要创建大量Map,而且只有在以后才需要涉及大量检索操作,那么最佳的策略就是:创建和填充TreeMap;以后检索量增大的时候,再将重要的TreeMap转换成HashMap——使用HashMap(Map)构建器。同样地,只有在事实证明确实存在性能瓶颈后,才应关心这些方面的问题——先用起来,再根据需要加快速度。8.7.6 未支持的操作利用static(静态)数组Arrays.toList(),也许能将一个数组转换成List,如下所示:3658.7 新集合//: Unsupported.java// Sometimes methods defined in the Collection// interfaces don't work!package c08.newcollections;import java.util.*;public class Unsupported {private static String[] s = {"one", "two", "three", "four", "five","six", "seven", "eight", "nine", "ten",};static List a = Arrays.toList(s);static List a2 = Arrays.toList(new String[] { s[3], s[4], s[5] });public static void main(String[] args) {Collection1.print(a); // IterationSystem.out.println("a.contains(" + s[0] + ") = " +a.contains(s[0]));System.out.println("a.containsAll(a2) = " +a.containsAll(a2));System.out.println("a.isEmpty() = " +a.isEmpty());System.out.println("a.indexOf(" + s[5] + ") = " +a.indexOf(s[5]));// Traverse backwards:ListIterator lit = a.listIterator(a.size());while(lit.hasPrevious())System.out.print(lit.previous());System.out.println();// Set the elements to different values:for(int i = 0; i < a.size(); i++)a.set(i, "47");Collection1.print(a);// Compiles, but won't run:lit.add("X"); // Unsupported operationa.clear(); // Unsupporteda.add("eleven"); // Unsupporteda.addAll(a2); // Unsupporteda.retainAll(a2); // Unsupporteda.remove(s[0]); // Unsupporteda.removeAll(a2); // Unsupported}} ///:~从中可以看出,实际只实现了Collection和List接口的一部分。剩余的方法导致了不受欢迎的一种情况,名为UnsupportedOperationException。在下一章里,我们会讲述违例的详细情况,但在这里有必要进行一下简单说明。这里的关键在于“集合接口”,以及新集合库内的另一3668.7 新集合些接口,它们都包含了“可选的”方法。在实现那些接口的集合类中,或者提供、或者没有提供对那些方法的支持。若调用一个未获支持的方法,就会导致一个UnsupportedOperationException(操作未支持违例),这表明出现了一个编程错误。大家或许会觉得奇怪,不是说“接口”和基础类最大的“卖点”就是它们许诺这些方法能产生一些有意义的行为吗?上述违例破坏了那个许诺——它调用的一部分方法不仅不能产生有意义的行为,而且还会中止程序的运行。在这些情况下,类型的所谓安全保证似乎显得一钱不值!但是,情况并没有想象的那么坏。通过Collection,List,Set或者Map,编译器仍然限制我们只能调用那个接口中的方法,所以它和Smalltalk还是存在一些区别的(在Smalltalk中,可为任何对象调用任何方法,而且只有在运行程序时才知道这些调用是否可行)。除此以外,以Collection作为自变量的大多数方法只能从那个集合中读取数据——Collection的所有“read”方法都不是可选的。这样一来,系统就可避免在设计期间出现接口的冲突。而在集合库的其他设计方案中,最终经常都会得到数量过多的接口,用它们描述基本方案的每一种变化形式,所以学习和掌握显得非常困难。有些时候,甚至难于捕捉接口中的所有特殊情况,因为人们可能设计出任何新接口。但Java的“不支持的操作”方法却达到了新集合库的一个重要设计目标:易于学习和使用。但是,为了使这一方法真正有效,却需满足下述条件:(1) UnsupportedOperationException必须属于一种“非常”事件。也就是说,对于大多数类来说,所有操作都应是可行的。只有在一些特殊情况下,一、两个操作才可能未获支持。新集合库满足了这一条件,因为绝大多数时候用到的类——ArrayList,LinkedList,HashList和HashMap,以及其他集合方案——都提供了对所有操作的支持。但是,如果想新建一个集合,同时不想为集合接口中的所有方法都提供有意义的定义,同时令其仍与现有库配合,这种设计方法也确实提供了一个“后门”可以利用。(2) 若一个操作未获支持,那么UnsupportedOperationException(未支持的操作违例)极有可能在实现期间出现,则不是在产品已交付给客户以后才会出现。它毕竟指出的是一个编程错误——不正确地使用了一个类。这一点不能十分确定,通过也可以看出这种方案的“试验”特征——只有经过多次试验,才能找出最理想的工作方式。在上面的例子中,Arrays.toList()产生了一个List(列表),该列表是由一个固定长度的数组后推出来的。因此唯一能够支持的就是那些不改变数组长度的操作。在另一方面,若请求一个新接口表达不同种类的行为(可能叫作“FixedSizeList”——固定长度列表),就有遭遇更大的复杂程度的危险。这样一来,以后试图使用库的时候,很快就会发现自己不知从何处下手。对那些采用Collection,List,Set或者Map作为参数的方法,它们的文档应当指出哪些可选的方法是必须实现的。举个例子来说,排序要求实现set()和Iterator.set()方法,但不包括add()和remove()。8.7.7 排序和搜索3678.7 新集合Java 1.2添加了自己的一套实用工具,可用来对数组或列表进行排列和搜索。这些工具都属于两个新类的“静态”方法。这两个类分别是用于排序和搜索数组的Arrays,以及用于排序和搜索列表的Collections。1. 数组Arrays类为所有基本数据类型的数组提供了一个过载的sort()和binarySearch(),它们亦可用于String和Object。下面这个例子显示出如何排序和搜索一个字节数组(其他所有基本数据类型都是类似的)以及一个String数组://: Array1.java// Testing the sorting & searching in Arrayspackage c08.newcollections;import java.util.*;public class Array1 {static Random r = new Random();static String ssource ="ABCDEFGHIJKLMNOPQRSTUVWXYZ" +"abcdefghijklmnopqrstuvwxyz";static char[] src = ssource.toCharArray();// Create a random Stringpublic static String randString(int length) {char[] buf = new char[length];int rnd;for(int i = 0; i < length; i++) {rnd = Math.abs(r.nextInt()) % src.length;buf[i] = src[rnd];}return new String(buf);}// Create a random array of Strings:public staticString[] randStrings(int length, int size) {String[] s = new String[size];for(int i = 0; i < size; i++)s[i] = randString(length);return s;}public static void print(byte[] b) {for(int i = 0; i < b.length; i++)System.out.print(b[i] + " ");System.out.println();}public static void print(String[] s) {for(int i = 0; i < s.length; i++)System.out.print(s[i] + " ");System.out.println();}public static void main(String[] args) {byte[] b = new byte[15];3688.7 新集合r.nextBytes(b); // Fill with random bytesprint(b);Arrays.sort(b);print(b);int loc = Arrays.binarySearch(b, b[10]);System.out.println("Location of " + b[10] +" = " + loc);// Test String sort & search:String[] s = randStrings(4, 10);print(s);Arrays.sort(s);print(s);loc = Arrays.binarySearch(s, s[4]);System.out.println("Location of " + s[4] +" = " + loc);}} ///:~类的第一部分包含了用于产生随机字串对象的实用工具,可供选择的随机字母保存在一个字符数组中。randString()返回一个任意长度的字串;而readStrings()创建随机字串的一个数组,同时给定每个字串的长度以及希望的数组大小。两个print()方法简化了对示范数组的显示。在main()中,Random.nextBytes()用随机选择的字节填充数组自变量(没有对应的Random方法用于创建其他基本数据类型的数组)。获得一个数组后,便可发现为了执行sort()或者binarySearch(),只需发出一次方法调用即可。与binarySearch()有关的还有一个重要的警告:若在执行一次binarySearch()之前不调用sort(),便会发生不可预测的行为,其中甚至包括无限循环。对String的排序以及搜索是相似的,但在运行程序的时候,我们会注意到一个有趣的现象:排序遵守的是字典顺序,亦即大写字母在字符集中位于小写字母的前面。因此,所有大写字母都位于列表的最前面,后面再跟上小写字母——Z居然位于a的前面。似乎连电话簿也是这样排序的。1. 可比较与比较器但假若我们不满足这一排序方式,又该如何处理呢?例如本书后面的索引,如果必须对以A或a开头的词条分别到两处地方查看,那么肯定会使读者颇不耐烦。若想对一个Object数组进行排序,那么必须解决一个问题。根据什么来判定两个Object的顺序呢?不幸的是,最初的Java设计者并不认为这是一个重要的问题,否则就已经在根类Object里定义它了。这样造成的一个后果便是:必须从外部进行Object的排序,而且新的集合库提供了实现这一操作的标准方式(最理想的是在Object里定义它)。针对Object数组(以及String,它当然属于Object的一种),可使用一个sort(),并令其接纳另一个参数:实现了Comparator接口(即“比较器”接口,新集合库的一部分)的一个对象,并用它的单个compare()方法进行比较。这个方法将两个准备比较的对象作为自己的参数使用3698.7 新集合——若第一个参数小于第二个,返回一个负整数;若相等,返回零;若第一个参数大于第二个,则返回正整数。基于这一规则,上述例子的String部分便可重新写过,令其进行真正按字母顺序的排序://: AlphaComp.java// Using Comparator to perform an alphabetic sortpackage c08.newcollections;import java.util.*;public class AlphaComp implements Comparator {public int compare(Object o1, Object o2) {// Assume it's used only for Strings...String s1 = ((String)o1).toLowerCase();String s2 = ((String)o2).toLowerCase();return s1.compareTo(s2);}public static void main(String[] args) {String[] s = Array1.randStrings(4, 10);Array1.print(s);AlphaComp ac = new AlphaComp();Arrays.sort(s, ac);Array1.print(s);// Must use the Comparator to search, also:int loc = Arrays.binarySearch(s, s[3], ac);System.out.println("Location of " + s[3] +" = " + loc);}} ///:~通过造型为String,compare()方法会进行“暗示”性的测试,保证自己操作的只能是String对象——运行期系统会捕获任何差错。将两个字串都强迫换成小写形式后,String.compareTo()方法会产生预期的结果。若用自己的Comparator来进行一次sort(),那么在使用binarySearch()时必须使用那个相同的Comparator。Arrays类提供了另一个sort()方法,它会采用单个自变量:一个Object数组,但没有Comparator。这个sort()方法也必须用同样的方式来比较两个Object。通过实现Comparable接口,它采用了赋予一个类的“自然比较方法”。这个接口含有单独一个方法——compareTo(),能分别根据它小于、等于或者大于自变量而返回负数、零或者正数,从而实现对象的比较。下面这个例子简单地阐示了这一点:3708.7 新集合//: CompClass.java// A class that implements Comparablepackage c08.newcollections;import java.util.*;public class CompClass implements Comparable {private int i;public CompClass(int ii) { i = ii; }public int compareTo(Object o) {// Implicitly tests for correct type:int argi = ((CompClass)o).i;if(i == argi) return 0;if(i < argi) return -1;return 1;}public static void print(Object[] a) {for(int i = 0; i < a.length; i++)System.out.print(a[i] + " ");System.out.println();}public String toString() { return i + ""; }public static void main(String[] args) {CompClass[] a = new CompClass[20];for(int i = 0; i < a.length; i++)a[i] = new CompClass((int)(Math.random() *100));print(a);Arrays.sort(a);print(a);int loc = Arrays.binarySearch(a, a[3]);System.out.println("Location of " + a[3] +" = " + loc);}} ///:~当然,我们的compareTo()方法亦可根据实际情况增大复杂程度。1. 列表可用与数组相同的形式排序和搜索一个列表(List)。用于排序和搜索列表的静态方法包含在类Collections中,但它们拥有与Arrays中差不多的签名:sort(List)用于对一个实现了Comparable的对象列表进行排序;binarySearch(List,Object)用于查找列表中的某个对象;sort(List,Comparator)利用一个“比较器”对一个列表进行排序;而binarySearch(List,Object,Comparator)则用于查找那个列表中的一个对象(注释⑨)。下面这个例子利用了预先定义好的CompClass和AlphaComp来示范Collections中的各种排序工具:3718.7 新集合//: ListSort.java// Sorting and searching Lists with 'Collections'package c08.newcollections;import java.util.*;public class ListSort {public static void main(String[] args) {final int SZ = 20;// Using "natural comparison method":List a = new ArrayList();for(int i = 0; i < SZ; i++)a.add(new CompClass((int)(Math.random() *100)));Collection1.print(a);Collections.sort(a);Collection1.print(a);Object find = a.get(SZ/2);int loc = Collections.binarySearch(a, find);System.out.println("Location of " + find +" = " + loc);// Using a Comparator:List b = new ArrayList();for(int i = 0; i < SZ; i++)b.add(Array1.randString(4));Collection1.print(b);AlphaComp ac = new AlphaComp();Collections.sort(b, ac);Collection1.print(b);find = b.get(SZ/2);// Must use the Comparator to search, also:loc = Collections.binarySearch(b, find, ac);System.out.println("Location of " + find +" = " + loc);}} ///:~⑨:在本书写作时,已宣布了一个新的Collections.stableSort(),可用它进行合并式排序,但还没有它的测试版问世。这些方法的用法与在Arrays中的用法是完全一致的,只是用一个列表代替了数组。TreeMap也必须根据Comparable或者Comparator对自己的对象进行排序。8.7.8 实用工具Collections类中含有其他大量有用的实用工具:3728.7 新集合enumeration(Collection)Produces an old-style Enumeration for the argument.max(Collection)min(Collection)Produces the maximum or minimum element in the argument using the natural comparison method of the objects in the Collection.max(Collection, Comparator)min(Collection, Comparator)Produces the maximum or minimum element in the Collection using the Comparator.nCopies(int n, Object o)Returns an immutable List of size n whose handles all point to o.subList(List, int min, int max)Returns a new List backed by the specified argument List that is a window into that argument with indexes starting at min and stopping just before max.enumeration(Collection) 为自变量产生原始风格的Enumeration(枚举)max(Collection),min(Collection) 在自变量中用集合内对象的自然比较方法产生最大或最小元素max(Collection,Comparator),min(Collection,Comparator) 在集合内用比较器产生最大或最小元素nCopies(int n, Object o) 返回长度为n的一个不可变列表,它的所有句柄均指向osubList(List,int min,int max) 返回由指定参数列表后推得到的一个新列表。可将这个列表想象成一个“窗口”,它自索引为min的地方开始,正好结束于max的前面注意min()和max()都是随同Collection对象工作的,而非随同List,所以不必担心Collection是否需要排序(就象早先指出的那样,在执行一次binarySearch()——即二进制搜索——之前,必须对一个List或者一个数组执行sort())。1. 使Collection或Map不可修改通常,创建Collection或Map的一个“只读”版本显得更有利一些。Collections类允许我们达到这个目标,方法是将原始容器传递进入一个方法,并令其传回一个只读版本。这个方法共有四种变化形式,分别用于Collection(如果不想把集合当作一种更特殊的类型对待)、List、Set以及Map。下面这个例子演示了为它们分别构建只读版本的正确方法:3738.7 新集合//: ReadOnly.java// Using the Collections.unmodifiable methodspackage c08.newcollections;import java.util.*;public class ReadOnly {public static void main(String[] args) {Collection c = new ArrayList();Collection1.fill(c); // Insert useful datac = Collections.unmodifiableCollection(c);Collection1.print(c); // Reading is OK//! c.add("one"); // Can't change itList a = new ArrayList();Collection1.fill(a);a = Collections.unmodifiableList(a);ListIterator lit = a.listIterator();System.out.println(lit.next()); // Reading OK//! lit.add("one"); // Can't change itSet s = new HashSet();Collection1.fill(s);s = Collections.unmodifiableSet(s);Collection1.print(s); // Reading OK//! s.add("one"); // Can't change itMap m = new HashMap();Map1.fill(m, Map1.testData1);m = Collections.unmodifiableMap(m);Map1.print(m); // Reading OK//! m.put("Ralph", "Howdy!");}} ///:~对于每种情况,在将其正式变为只读以前,都必须用有有效的数据填充容器。一旦载入成功,最佳的做法就是用“不可修改”调用产生的句柄替换现有的句柄。这样做可有效避免将其变成不可修改后不慎改变其中的内容。在另一方面,该工具也允许我们在一个类中将能够修改的容器保持为private状态,并可从一个方法调用中返回指向那个容器的一个只读句柄。这样一来,虽然我们可在类里修改它,但其他任何人都只能读。为特定类型调用“不可修改”的方法不会造成编译期间的检查,但一旦发生任何变化,对修改特定容器的方法的调用便会产生一个UnsupportedOperationException违例。1. Collection或Map的同步synchronized关键字是“多线程”机制一个非常重要的部分。我们到第14章才会对这一机制作深入的探讨。在这儿,大家只需注意到Collections类提供了对整个容器进行自动同步的一种途径。它的语法与“不可修改”的方法是类似的:3748.7 新集合//: Synchronization.java// Using the Collections.synchronized methodspackage c08.newcollections;import java.util.*;public class Synchronization {public static void main(String[] args) {Collection c =Collections.synchronizedCollection(new ArrayList());List list = Collections.synchronizedList(new ArrayList());Set s = Collections.synchronizedSet(new HashSet());Map m = Collections.synchronizedMap(new HashMap());}} ///:~在这种情况下,我们通过适当的“同步”方法直接传递新容器;这样做可避免不慎暴露出未同步的版本。新集合也提供了能防止多个进程同时修改一个容器内容的机制。若在一个容器里反复,同时另一些进程介入,并在那个容器中插入、删除或修改一个对象,便会面临发生冲突的危险。我们可能已传递了那个对象,可能它位位于我们前面,可能容器的大小在我们调用size()后已发生了收缩——我们面临各种各样可能的危险。针对这个问题,新的集合库集成了一套解决的机制,能查出除我们的进程自己需要负责的之外的、对容器的其他任何修改。若探测到有其他方面也准备修改容器,便会立即产生一个ConcurrentModificationException(并发修改违例)。我们将这一机制称为“立即失败”——它并不用更复杂的算法在“以后”侦测问题,而是“立即”产生违例。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:103758.8 总结8.8 总结下面复习一下由标准Java(1.0和1.1)库提供的集合(BitSet未包括在这里,因为它更象一种负有特殊使命的类):(1) 数组包含了对象的数字化索引。它容纳的是一种已知类型的对象,所以在查找一个对象时,不必对结果进行造型处理。数组可以是多维的,而且能够容纳基本数据类型。但是,一旦把它创建好以后,大小便不能变化了。(2) Vector(矢量)也包含了对象的数字索引——可将数组和Vector想象成随机访问集合。当我们加入更多的元素时,Vector能够自动改变自身的大小。但Vector只能容纳对象的句柄,所以它不可包含基本数据类型;而且将一个对象句柄从集合中取出来的时候,必须对结果进行造型处理。(3) Hashtable(散列表)属于Dictionary(字典)的一种类型,是一种将对象(而不是数字)同其他对象关联到一起的方式。散列表也支持对对象的随机访问,事实上,它的整个设计方案都在突出访问的“高速度”。(4) Stack(堆栈)是一种“后入先出”(LIFO)的队列。若你曾经熟悉数据结构,可能会疑惑为何没看到一套更大的集合。从功能的角度出发,你真的需要一套更大的集合吗?对于Hashtable,可将任何东西置入其中,并以非常快的速度检索;对于Enumeration(枚举),可遍历一个序列,并对其中的每个元素都采取一个特定的操作。那是一种功能足够强劲的工具。但Hashtable没有“顺序”的概念。Vector和数组为我们提供了一种线性顺序,但若要把一个元素插入它们任何一个的中部,一般都要付出“惨重”的代价。除此以外,队列、拆散队列、优先级队列以及树都涉及到元素的“排序”——并非仅仅将它们置入,以便以后能按线性顺序查找或移动它们。这些数据结构也非常有用,这也正是标准C++中包含了它们的原因。考虑到这个原因,只应将标准Java库的集合看作自己的一个起点。而且倘若必须使用Java 1.0或1.1,则可在需要超越它们的时候使用JGL。如果能使用Java 1.2,那么只使用新集合即可,它一般能满足我们的所有需要。注意本书在Java 1.1身上花了大量篇幅,所以书中用到的大量集合都是只能在Java1.1中用到的那些:Vector和Hashtable。就目前来看,这是一个不得以而为之的做法。但是,这样处理亦可提供与老Java代码更出色的向后兼容能力。若要用Java1.2写新代码,新的集合往往能更好地为你服务。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:103768.8 总结3778.9 练习8.9 练习(1) 新建一个名为Gerbil的类,在构建器中初始化一个int gerbilNumber(类似本章的Mouse例子)。为其写一个名为hop()的方法,用它打印出符合hop()条件的Gerbil的编号。建一个Vector,并为Vector添加一系列Gerbil对象。现在,用elementAt()方法在Vector中遍历,并为每个Gerbil都调用hop()。(2) 修改练习1,用Enumeration在调用hop()的同时遍历Vector。(3) 在AssocArray.java中,修改这个例子,令其使用一个Hashtable,而不是AssocArray。(4) 获取练习1用到的Gerbil类,改为把它置入一个Hashtable,然后将Gerbil的名称作为一个String(键)与置入表格的每个Gerbil(值)都关联起来。获得用于keys()的一个Enumeration,并用它在Hashtable里遍历,查找每个键的Gerbil,打印出键,然后将gerbil告诉给hop()。(5) 修改第7章的练习1,用一个Vector容纳Rodent(啮齿动物),并用Enumeration在Rodent序列中遍历。记住Vector只能容纳对象,所以在访问单独的Rodent时必须采用一个造型(如RTTI)。(6) 转到第7章的中间位置,找到那个GreenhouseControls.java(温室控制)例子,该例应该由三个文件构成。在Controller.java中,类EventSet仅是一个集合。修改它的代码,用一个Stack代替EventSet。当然,这时可能并不仅仅用Stack取代EventSet这样简单;也需要用一个Enumeration遍历事件集。可考虑在某些时候将集合当作Stack对待,另一些时候则当作Vector对待——这样或许能使事情变得更加简单。(7) (有一定挑战性)在与所有Java发行包配套提供的Java源码库中找出用于Vector的源码。复制这些代码,制作名为 intVector的一个特殊版本,只在其中包含int数据。思考是否能为所有基本数据类型都制作Vector的一个特殊版本。接下来,考虑假如制作一个链接列表类,令其能随同所有基本数据类型使用,那么会发生什么情况。若在Java中提供了参数化类型,利用它们便可自动完成这一工作(还有其他许多好处)。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:10378第9章 违例差错控制第9章 违例差错控制Java的基本原理就是“形式错误的代码不会运行”。与C++类似,捕获错误最理想的是在编译期间,最好在试图运行程序以前。然而,并非所有错误都能在编译期间侦测到。有些问题必须在运行期间解决,让错误的缔结者通过一些手续向接收者传递一些适当的信息,使其知道该如何正确地处理遇到的问题。在C++和其他早期语言中,可通过几种手续来达到这个目的。而且它们通常是作为一种规定建立起来的,而非作为程序设计语言的一部分。典型地,我们需要返回一个值或设置一个标志(位),接收者会检查这些值或标志,判断具体发生了什么事情。然而,随着时间的流逝,终于发现这种做法会助长那些使用一个库的程序员的麻痹情绪。他们往往会这样想:“是的,错误可能会在其他人的代码中出现,但不会在我的代码中”。这样的后果便是他们一般不检查是否出现了错误(有时出错条件确实显得太愚蠢,不值得检验;注释①)。另一方面,若每次调用一个方法时都进行全面、细致的错误检查,那么代码的可读性也可能大幅度降低。由于程序员可能仍然在用这些语言维护自己的系统,所以他们应该对此有着深刻的体会:若按这种方式控制错误,那么在创建大型、健壮、易于维护的程序时,肯定会遇到不小的阻挠。①:C程序员研究一下printf()的返回值便知端详。解决的方法是在错误控制中排除所有偶然性,强制格式的正确。这种方法实际已有很长的历史,因为早在60年代便在操作系统里采用了“违例控制”手段;甚至可以追溯到BASIC语言的onerror goto语句。但C++的违例控制建立在Ada的基础上,而Java又主要建立在C++的基础上(尽管它看起来更象Object Pascal)。“违例”(Exception)这个词表达的是一种“例外”情况,亦即正常情况之外的一种“异常”。在问题发生的时候,我们可能不知具体该如何解决,但肯定知道已不能不顾一切地继续下去。此时,必须坚决地停下来,并由某人、某地指出发生了什么事情,以及该采取何种对策。但为了真正解决问题,当地可能并没有足够多的信息。因此,我们需要将其移交给更级的负责人,令其作出正确的决定(类似一个命令链)。违例机制的另一项好处就是能够简化错误控制代码。我们再也不用检查一个特定的错误,然后在程序的多处地方对其进行控制。此外,也不需要在方法调用的时候检查错误(因为保证有人能捕获这里的错误)。我们只需要在一个地方处理问题:“违例控制模块”或者“违例控制器”。这样可有效减少代码量,并将那些用于描述具体操作的代码与专门纠正错误的代码分隔开。一般情况下,用于读取、写入以及调试的代码会变得更富有条理。由于违例控制是由Java编译器强行实施的,所以毋需深入学习违例控制,便可正确使用本书编写的大量例子。本章向大家介绍了用于正确控制违例所需的代码,以及在某个方法遇到麻烦的时候,该如何生成自己的违例。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:379第9章 违例差错控制2018-03-13 01:23:103809.1 基本违例9.1 基本违例“违例条件”表示在出现什么问题的时候应中止方法或作用域的继续。为了将违例条件与普通问题区分开,违例条件是非常重要的一个因素。在普通问题的情况下,我们在当地已拥有足够的信息,可在某种程度上解决碰到的问题。而在违例条件的情况下,却无法继续下去,因为当地没有提供解决问题所需的足够多的信息。此时,我们能做的唯一事情就是跳出当地环境,将那个问题委托给一个更高级的负责人。这便是出现违例时出现的情况。一个简单的例子是“除法”。如可能被零除,就有必要进行检查,确保程序不会冒进,并在那种情况下执行除法。但具体通过什么知道分母是零呢?在那个特定的方法里,在我们试图解决的那个问题的环境中,我们或许知道该如何对待一个零分母。但假如它是一个没有预料到的值,就不能对其进行处理,所以必须产生一个违例,而非不顾一切地继续执行下去。产生一个违例时,会发生几件事情。首先,按照与创建Java对象一样的方法创建违例对象:在内存“堆”里,使用new来创建。随后,停止当前执行路径(记住不可沿这条路径继续下去),然后从当前的环境中释放出违例对象的句柄。此时,违例控制机制会接管一切,并开始查找一个恰当的地方,用于继续程序的执行。这个恰当的地方便是“违例控制器”,它的职责是从问题中恢复,使程序要么尝试另一条执行路径,要么简单地继续。作为产生违例的一个简单示例,大家可思考一个名为t的对象句柄。有些时候,程序可能传递一个尚未初始化的句柄。所以在用那个对象句柄调用一个方法之前,最好进行一番检查。可将与错误有关的信息发送到一个更大的场景中,方法是创建一个特殊的对象,用它代表我们的信息,并将其“掷”(Throw)出我们当前的场景之外。这就叫作“产生一个违例”或者“掷出一个违例”。下面是它的大概形式:if(t == null)throw new NullPointerException();这样便“掷”出了一个违例。在当前场景中,它使我们能放弃进一步解决该问题的企图。该问题会被转移到其他更恰当的地方解决。准确地说,那个地方不久就会显露出来。9.1.1 违例自变量和Java的其他任何对象一样,需要用new在内存堆里创建违例,并需调用一个构建器。在所有标准违例中,存在着两个构建器:第一个是默认构建器,第二个则需使用一个字串自变量,使我们能在违例里置入相关信息:if(t == null)throw new NullPointerException("t = null");稍后,字串可用各种方法提取出来,就象稍后会展示的那样。3819.1 基本违例在这儿,关键字throw会象变戏法一样做出一系列不可思议的事情。它首先执行new表达式,创建一个不在程序常规执行范围之内的对象。而且理所当然,会为那个对象调用构建器。随后,对象实际会从方法中返回——尽管对象的类型通常并不是方法设计为返回的类型。为深入理解违例控制,可将其想象成另一种返回机制——但是不要在这个问题上深究,否则会遇到麻烦。通过“掷”出一个违例,亦可从原来的作用域中退出。但是会先返回一个值,再退出方法或作用域。但是,与普通方法返回的相似性到此便全部结束了,因为我们返回的地方与从普通方法调用中返回的地方是迥然有异的(我们结束于一个恰当的违例控制器,它距离违例“掷”出的地方可能相当遥远——在调用堆栈中要低上许多级)。此外,我们可根据需要掷出任何类型的“可掷”对象。典型情况下,我们要为每种不同类型的错误“掷”出一类不同的违例。我们的思路是在违例对象以及挑选的违例对象类型中保存信息,所以在更大场景中的某个人可知道如何对待我们的违例(通常,唯一的信息是违例对象的类型,而违例对象中保存的没什么意义)。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:103829.2 违例的捕获9.2 违例的捕获若某个方法产生一个违例,必须保证该违例能被捕获,并获得正确对待。对于Java的违例控制机制,它的一个好处就是允许我们在一个地方将精力集中在要解决的问题上,然后在另一个地方对待来自那个代码内部的错误。为理解违例是如何捕获的,首先必须掌握“警戒区”的概念。它代表一个特殊的代码区域,有可能产生违例,并在后面跟随用于控制那些违例的代码。9.2.1 try块若位于一个方法内部,并“掷”出一个违例(或在这个方法内部调用的另一个方法产生了违例),那个方法就会在违例产生过程中退出。若不想一个throw离开方法,可在那个方法内部设置一个特殊的代码块,用它捕获违例。这就叫作“try块”,因为要在这个地方“尝试”各种方法调用。try块属于一种普通的作用域,用一个try关键字开头:try {// 可能产生违例的代码}若用一种不支持违例控制的编程语言全面检查错误,必须用设置和错误检测代码将每个方法都包围起来——即便多次调用相同的方法。而在使用了违例控制技术后,可将所有东西都置入一个try块内,在同一地点捕获所有违例。这样便可极大简化我们的代码,并使其更易辨读,因为代码本身要达到的目标再也不会与繁复的错误检查混淆。9.2.2 违例控制器当然,生成的违例必须在某个地方中止。这个“地方”便是违例控制器或者违例控制模块。而且针对想捕获的每种违例类型,都必须有一个相应的违例控制器。违例控制器紧接在try块后面,且用catch(捕获)关键字标记。如下所示:try {// Code that might generate exceptions} catch(Type1 id1) {// Handle exceptions of Type1} catch(Type2 id2) {// Handle exceptions of Type2} catch(Type3 id3) {// Handle exceptions of Type3}// etc...3839.2 违例的捕获每个catch从句——即违例控制器——都类似一个小型方法,它需要采用一个(而且只有一个)特定类型的自变量。可在控制器内部使用标识符(id1,id2等等),就象一个普通的方法自变量那样。我们有时也根本不使用标识符,因为违例类型已提供了足够的信息,可有效处理违例。但即使不用,标识符也必须就位。控制器必须“紧接”在try块后面。若“掷”出一个违例,违例控制机制就会搜寻自变量与违例类型相符的第一个控制器。随后,它会进入那个catch从句,并认为违例已得到控制(一旦catch从句结束,对控制器的搜索也会停止)。只有相符的catch从句才会得到执行;它与switch语句不同,后者在每个case后都需要一个break命令,防止误执行其他语句。 在try块内部,请注意大量不同的方法调用可能生成相同的违例,但只需要一个控制器。1. 中断与恢复在违例控制理论中,共存在两种基本方法。在“中断”方法中(Java和C++提供了对这种方法的支持),我们假定错误非常关键,没有办法返回违例发生的地方。无论谁只要“掷”出一个违例,就表明没有办法补救错误,而且也不希望再回来。另一种方法叫作“恢复”。它意味着违例控制器有责任来纠正当前的状况,然后取得出错的方法,假定下一次会成功执行。若使用恢复,意味着在违例得到控制以后仍然想继续执行。在这种情况下,我们的违例更象一个方法调用——我们用它在Java中设置各种各样特殊的环境,产生类似于“恢复”的行为(换言之,此时不是“掷”出一个违例,而是调用一个用于解决问题的方法)。另外,也可以将自己的try块置入一个while循环里,用它不断进入try块,直到结果满意时为止。从历史的角度看,若程序员使用的操作系统支持可恢复的违例控制,最终都会用到类似于中断的代码,并跳过恢复进程。所以尽管“恢复”表面上十分不错,但在实际应用中却显得困难重重。其中决定性的原因可能是:我们的控制模块必须随时留意是否产生了违例,以及是否包含了由产生位置专用的代码。这便使代码很难编写和维护——大型系统尤其如此,因为违例可能在多个位置产生。9.2.3 违例规范在Java中,对那些要调用方法的客户程序员,我们要通知他们可能从自己的方法里“掷”出违例。这是一种有礼貌的做法,只有它才能使客户程序员准确地知道要编写什么代码来捕获所有潜在的违例。当然,若你同时提供了源码,客户程序员甚至能全盘检查代码,找出相应的throw语句。但尽管如此,通常并不随同源码提供库。为解决这个问题,Java提供了一种特殊的语法格式(并强迫我们采用),以便礼貌地告诉客户程序员该方法会“掷”出什么违例,令对方方便地加以控制。这便是我们在这里要讲述的“违例规范”,它属于方法声明的一部分,位于自变量(参数)列表的后面。违例规范采用了一个额外的关键字:throws;后面跟随全部潜在的违例类型。因此,我们的方法定义看起来应象下面这个样子:void f() throws tooBig, tooSmall, divZero { //...3849.2 违例的捕获若使用下述代码:void f() [ // ...它意味着不会从方法里“掷”出违例(除类型为RuntimeException的违例以外,它可能从任何地方掷出——稍后还会详细讲述)。 但不能完全依赖违例规范——假若方法造成了一个违例,但没有对其进行控制,编译器会侦测到这个情况,并告诉我们必须控制违例,或者指出应该从方法里“掷”出一个违例规范。通过坚持从顶部到底部排列违例规范,Java可在编译期保证违例的正确性(注释②)。②:这是在C++违例控制基础上一个显著的进步,后者除非到运行期,否则不会捕获不符合违例规范的错误。这使得C++的违例控制机制显得用处不大。我们在这个地方可采取欺骗手段:要求“掷”出一个并没有发生的违例。编译器能理解我们的要求,并强迫使用这个方法的用户当作真的产生了那个违例处理。在实际应用中,可将其作为那个违例的一个“占位符”使用。这样一来,以后可以方便地产生实际的违例,毋需修改现有的代码。9.2.4 捕获所有违例我们可创建一个控制器,令其捕获所有类型的违例。具体的做法是捕获基础类违例类型Exception(也存在其他类型的基础违例,但Exception是适用于几乎所有编程活动的基础)。如下所示:catch(Exception e) {System.out.println("caught an exception");}这段代码能捕获任何违例,所以在实际使用时最好将其置于控制器列表的末尾,防止跟随在后面的任何特殊违例控制器失效。 对于程序员常用的所有违例类来说,由于Exception类是它们的基础,所以我们不会获得关于违例太多的信息,但可调用来自它的基础类Throwable的方法:String getMessage()获得详细的消息。String toString()返回对Throwable的一段简要说明,其中包括详细的消息(如果有的话)。3859.2 违例的捕获void printStackTrace()void printStackTrace(PrintStream)打印出Throwable和Throwable的调用堆栈路径。调用堆栈显示出将我们带到违例发生地点的方法调用的顺序。第一个版本会打印出标准错误,第二个则打印出我们的选择流程。若在Windows下工作,就不能重定向标准错误。因此,我们一般愿意使用第二个版本,并将结果送给System.out;这样一来,输出就可重定向到我们希望的任何路径。除此以外,我们还可从Throwable的基础类Object(所有对象的基础类型)获得另外一些方法。对于违例控制来说,其中一个可能有用的是getClass(),它的作用是返回一个对象,用它代表这个对象的类。我们可依次用getName()或toString()查询这个Class类的名字。亦可对Class对象进行一些复杂的操作,尽管那些操作在违例控制中是不必要的。本章稍后还会详细讲述Class对象。下面是一个特殊的例子,它展示了Exception方法的使用(若执行该程序遇到困难,请参考第3章3.1.2小节“赋值”)://: ExceptionMethods.java// Demonstrating the Exception Methodspackage c09;public class ExceptionMethods {public static void main(String[] args) {try {throw new Exception("Here's my Exception");} catch(Exception e) {System.out.println("Caught Exception");System.out.println("e.getMessage(): " + e.getMessage());System.out.println("e.toString(): " + e.toString());System.out.println("e.printStackTrace():");e.printStackTrace();}}} ///:~该程序输出如下:3869.2 违例的捕获Caught Exceptione.getMessage(): Here's my Exceptione.toString(): java.lang.Exception: Here's my Exceptione.printStackTrace():java.lang.Exception: Here's my Exceptionat ExceptionMethods.main可以看到,该方法连续提供了大量信息——每类信息都是前一类信息的一个子集。9.2.5 重新“掷”出违例在某些情况下,我们想重新掷出刚才产生过的违例,特别是在用Exception捕获所有可能的违例时。由于我们已拥有当前违例的句柄,所以只需简单地重新掷出那个句柄即可。下面是一个例子:catch(Exception e) {System.out.println("一个违例已经产生");throw e;}重新“掷”出一个违例导致违例进入更高一级环境的违例控制器中。用于同一个try块的任何更进一步的catch从句仍然会被忽略。此外,与违例对象有关的所有东西都会得到保留,所以用于捕获特定违例类型的更高一级的控制器可以从那个对象里提取出所有信息。 若只是简单地重新掷出当前违例,我们打印出来的、与printStackTrace()内的那个违例有关的信息会与违例的起源地对应,而不是与重新掷出它的地点对应。若想安装新的堆栈跟踪信息,可调用fillInStackTrace(),它会返回一个特殊的违例对象。这个违例的创建过程如下:将当前堆栈的信息填充到原来的违例对象里。下面列出它的形式:3879.2 违例的捕获//: Rethrowing.java// Demonstrating fillInStackTrace()public class Rethrowing {public static void f() throws Exception {System.out.println("originating the exception in f()");throw new Exception("thrown from f()");}public static void g() throws Throwable {try {f();} catch(Exception e) {System.out.println("Inside g(), e.printStackTrace()");e.printStackTrace();throw e; // 17// throw e.fillInStackTrace(); // 18}}public static voidmain(String[] args) throws Throwable {try {g();} catch(Exception e) {System.out.println("Caught in main, e.printStackTrace()");e.printStackTrace();}}} ///:~其中最重要的行号在注释内标记出来。注意第17行没有设为注释行。它的输出结果如下:originating the exception in f()Inside g(), e.printStackTrace()java.lang.Exception: thrown from f()at Rethrowing.f(Rethrowing.java:8)at Rethrowing.g(Rethrowing.java:12)at Rethrowing.main(Rethrowing.java:24)Caught in main, e.printStackTrace()java.lang.Exception: thrown from f()at Rethrowing.f(Rethrowing.java:8)at Rethrowing.g(Rethrowing.java:12)at Rethrowing.main(Rethrowing.java:24)因此,违例堆栈路径无论如何都会记住它的真正起点,无论自己被重复“掷”了好几次。 若将第17行标注(变成注释行),而撤消对第18行的标注,就会换用fillInStackTrace(),结果如下:3889.2 违例的捕获originating the exception in f()Inside g(), e.printStackTrace()java.lang.Exception: thrown from f()at Rethrowing.f(Rethrowing.java:8)at Rethrowing.g(Rethrowing.java:12)at Rethrowing.main(Rethrowing.java:24)Caught in main, e.printStackTrace()java.lang.Exception: thrown from f()at Rethrowing.g(Rethrowing.java:18)at Rethrowing.main(Rethrowing.java:24)由于使用的是fillInStackTrace(),第18行成为违例的新起点。针对g()和main(),Throwable类必须在违例规格中出现,因为fillInStackTrace()会生成一个Throwable对象的句柄。由于Throwable是Exception的一个基础类,所以有可能获得一个能够“掷”出的对象(具有Throwable属性),但却并非一个Exception(违例)。因此,在main()中用于Exception的句柄可能丢失自己的目标。为保证所有东西均井然有序,编译器强制Throwable使用一个违例规范。举个例子来说,下述程序的违例便不会在main()中被捕获到://: ThrowOut.javapublic class ThrowOut {public static voidmain(String[] args) throws Throwable {try {throw new Throwable();} catch(Exception e) {System.out.println("Caught in main()");}}} ///:~也有可能从一个已经捕获的违例重新“掷”出一个不同的违例。但假如这样做,会得到与使用fillInStackTrace()类似的效果:与违例起源地有关的信息会全部丢失,我们留下的是与新的throw有关的信息。如下所示:3899.2 违例的捕获//: RethrowNew.java// Rethrow a different object from the one that// was caughtpublic class RethrowNew {public static void f() throws Exception {System.out.println("originating the exception in f()");throw new Exception("thrown from f()");}public static void main(String[] args) {try {f();} catch(Exception e) {System.out.println("Caught in main, e.printStackTrace()");e.printStackTrace();throw new NullPointerException("from main");}}} ///:~输出如下:originating the exception in f()Caught in main, e.printStackTrace()java.lang.Exception: thrown from f()at RethrowNew.f(RethrowNew.java:8)at RethrowNew.main(RethrowNew.java:13)java.lang.NullPointerException: from mainat RethrowNew.main(RethrowNew.java:18)最后一个违例只知道自己来自main(),而非来自f()。注意Throwable在任何违例规范中都不是必需的。永远不必关心如何清除前一个违例,或者与之有关的其他任何违例。它们都属于用new创建的、以内存堆为基础的对象,所以垃圾收集器会自动将其清除。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:103909.3 标准Java违例9.3 标准Java违例Java包含了一个名为Throwable的类,它对可以作为违例“掷”出的所有东西进行了描述。Throwable对象有两种常规类型(亦即“从Throwable继承”)。其中,Error代表编译期和系统错误,我们一般不必特意捕获它们(除在特殊情况以外)。Exception是可以从任何标准Java库的类方法中“掷”出的基本类型。此外,它们亦可从我们自己的方法以及运行期偶发事件中“掷”出。为获得违例的一个综合概念,最好的方法是阅读由http://java.sun.com提供的联机Java文档(当然,首先下载它们更好)。为了对各种违例有一个大概的印象,这个工作是相当有价值的。但大家不久就会发现,除名字外,一个违例和下一个违例之间并不存在任何特殊的地方。此外,Java提供的违例数量正在日益增多;从本质上说,把它们印到一本书里是没有意义的。大家从其他地方获得的任何新库可能也提供了它们自己的违例。我们最需要掌握的是基本概念,以及用这些违例能够做什么。java.lang.Exception这是程序能捕获的基本违例。其他违例都是从它衍生出去的。这里要注意的是违例的名字代表发生的问题,而且违例名通常都是精心挑选的,可以很清楚地说明到底发生了什么事情。违例并不全是在java.lang中定义的;有些是为了提供对其他库的支持,如util,net以及io等——我们可以从它们的完整类名中看出这一点,或者观察它们从什么继承。例如,所有IO违例都是从java.io.IOException继承的。9.3.1 RuntimeException的特殊情况本章的第一个例子是:if(t == null)throw new NullPointerException();看起来似乎在传递进入一个方法的每个句柄中都必须检查null(因为不知道调用者是否已传递了一个有效的句柄),这无疑是相当可怕的。但幸运的是,我们根本不必这样做——它属于Java进行的标准运行期检查的一部分。若对一个空句柄发出了调用,Java会自动产生一个NullPointerException违例。所以上述代码在任何情况下都是多余的。这个类别里含有一系列违例类型。它们全部由Java自动生成,毋需我们亲自动手把它们包含到自己的违例规范里。最方便的是,通过将它们置入单独一个名为RuntimeException的基础类下面,它们全部组合到一起。这是一个很好的继承例子:它建立了一系列具有某种共通性的类型,都具有某些共通的特征与行为。此外,我们没必要专门写一个违例规范,指出一个方法可能会“掷”出一个RuntimeException,因为已经假定可能出现那种情况。由于它们用于指3919.3 标准Java违例出编程中的错误,所以几乎永远不必专门捕获一个“运行期违例”——RuntimeException——它在默认情况下会自动得到处理。若必须检查RuntimeException,我们的代码就会变得相当繁复。在我们自己的包里,可选择“掷”出一部分RuntimeException。如果不捕获这些违例,又会出现什么情况呢?由于编译器并不强制违例规范捕获它们,所以假如不捕获的话,一个RuntimeException可能过滤掉我们到达main()方法的所有途径。为体会此时发生的事情,请试试下面这个例子://: NeverCaught.java// Ignoring RuntimeExceptionspublic class NeverCaught {static void f() {throw new RuntimeException("From f()");}static void g() {f();}public static void main(String[] args) {g();}} ///:~大家已经看到,一个RuntimeException(或者从它继承的任何东西)属于一种特殊情况,因为编译器不要求为这些类型指定违例规范。输出如下:java.lang.RuntimeException: From f()at NeverCaught.f(NeverCaught.java:9)at NeverCaught.g(NeverCaught.java:12)at NeverCaught.main(NeverCaught.java:15)所以答案就是:假若一个RuntimeException获得到达main()的所有途径,同时不被捕获,那么当程序退出时,会为那个违例调用printStackTrace()。注意也许能在自己的代码中仅忽略RuntimeException,因为编译器已正确实行了其他所有控制。因为RuntimeException在此时代表一个编程错误:(1) 一个我们不能捕获的错误(例如,由客户程序员接收传递给自己方法的一个空句柄)。(2) 作为一名程序员,一个应在自己的代码中检查的错误(如ArrayIndexOutOfBoundException,此时应注意数组的大小)。 可以看出,最好的做法是在这种情况下违例,因为它们有助于程序的调试。3929.3 标准Java违例另外一个有趣的地方是,我们不可将Java违例划分为单一用途的工具。的确,它们设计用于控制那些讨厌的运行期错误——由代码控制范围之外的其他力量产生。但是,它也特别有助于调试某些特殊类型的编程错误,那些是编译器侦测不到的。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:103939.4 创建自己的违例9.4 创建自己的违例并不一定非要使用Java违例。这一点必须掌握,因为经常都需要创建自己的违例,以便指出自己的库可能生成的一个特殊错误——但创建Java分级结构的时候,这个错误是无法预知的。为创建自己的违例类,必须从一个现有的违例类型继承——最好在含义上与新违例近似。继承一个违例相当简单://: Inheriting.java// Inheriting your own exceptionsclass MyException extends Exception {public MyException() {}public MyException(String msg) {super(msg);}}public class Inheriting {public static void f() throws MyException {System.out.println("Throwing MyException from f()");throw new MyException();}public static void g() throws MyException {System.out.println("Throwing MyException from g()");throw new MyException("Originated in g()");}public static void main(String[] args) {try {f();} catch(MyException e) {e.printStackTrace();}try {g();} catch(MyException e) {e.printStackTrace();}}} ///:~继承在创建新类时发生:3949.4 创建自己的违例class MyException extends Exception {public MyException() {}public MyException(String msg) {super(msg);}}这里的关键是“extends Exception”,它的意思是:除包括一个Exception的全部含义以外,还有更多的含义。增加的代码数量非常少——实际只添加了两个构建器,对MyException的创建方式进行了定义。请记住,假如我们不明确调用一个基础类构建器,编译器会自动调用基础类默认构建器。在第二个构建器中,通过使用super关键字,明确调用了带有一个String参数的基础类构建器。该程序输出结果如下:Throwing MyException from f()MyExceptionat Inheriting.f(Inheriting.java:16)at Inheriting.main(Inheriting.java:24)Throwing MyException from g()MyException: Originated in g()at Inheriting.g(Inheriting.java:20)at Inheriting.main(Inheriting.java:29)可以看到,在从f()“掷”出的MyException违例中,缺乏详细的消息。创建自己的违例时,还可以采取更多的操作。我们可添加额外的构建器及成员://: Inheriting2.java// Inheriting your own exceptionsclass MyException2 extends Exception {public MyException2() {}public MyException2(String msg) {super(msg);}public MyException2(String msg, int x) {super(msg);i = x;}public int val() { return i; }private int i;}public class Inheriting2 {public static void f() throws MyException2 {System.out.println("Throwing MyException2 from f()");3959.4 创建自己的违例throw new MyException2();}public static void g() throws MyException2 {System.out.println("Throwing MyException2 from g()");throw new MyException2("Originated in g()");}public static void h() throws MyException2 {System.out.println("Throwing MyException2 from h()");throw new MyException2("Originated in h()", 47);}public static void main(String[] args) {try {f();} catch(MyException2 e) {e.printStackTrace();}try {g();} catch(MyException2 e) {e.printStackTrace();}try {h();} catch(MyException2 e) {e.printStackTrace();System.out.println("e.val() = " + e.val());}}} ///:~此时添加了一个数据成员i;同时添加了一个特殊的方法,用它读取那个值;也添加了一个额外的构建器,用它设置那个值。输出结果如下:Throwing MyException2 from f()MyException2at Inheriting2.f(Inheriting2.java:22)at Inheriting2.main(Inheriting2.java:34)Throwing MyException2 from g()MyException2: Originated in g()at Inheriting2.g(Inheriting2.java:26)at Inheriting2.main(Inheriting2.java:39)Throwing MyException2 from h()MyException2: Originated in h()at Inheriting2.h(Inheriting2.java:30)at Inheriting2.main(Inheriting2.java:44)e.val() = 473969.4 创建自己的违例由于违例不过是另一种形式的对象,所以可以继续这个进程,进一步增强违例类的能力。但要注意,对使用自己这个包的客户程序员来说,他们可能错过所有这些增强。因为他们可能只是简单地寻找准备生成的违例,除此以外不做任何事情——这是大多数Java库违例的标准用法。若出现这种情况,有可能创建一个新违例类型,其中几乎不包含任何代码://: SimpleException.javaclass SimpleException extends Exception {} ///:~它要依赖编译器来创建默认构建器(会自动调用基础类的默认构建器)。当然,在这种情况下,我们不会得到一个SimpleException(String)构建器,但它实际上也不会经常用到。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:103979.5 违例的限制9.5 违例的限制覆盖一个方法时,只能产生已在方法的基础类版本中定义的违例。这是一个重要的限制,因为它意味着与基础类协同工作的代码也会自动应用于从基础类衍生的任何对象(当然,这属于基本的OOP概念),其中包括违例。 下面这个例子演示了强加在违例身上的限制类型(在编译期)://: StormyInning.java// Overridden methods may throw only the// exceptions specified in their base-class// versions, or exceptions derived from the// base-class exceptions.class BaseballException extends Exception {}class Foul extends BaseballException {}class Strike extends BaseballException {}abstract class Inning {Inning() throws BaseballException {}void event () throws BaseballException {// Doesn't actually have to throw anything}abstract void atBat() throws Strike, Foul;void walk() {} // Throws nothing}class StormException extends Exception {}class RainedOut extends StormException {}class PopFoul extends Foul {}interface Storm {void event() throws RainedOut;void rainHard() throws RainedOut;}public class StormyInning extends Inningimplements Storm {// OK to add new exceptions for constructors,// but you must deal with the base constructor// exceptions:StormyInning() throws RainedOut,BaseballException {}StormyInning(String s) throws Foul,BaseballException {}// Regular methods must conform to base class://! void walk() throws PopFoul {} //Compile error// Interface CANNOT add exceptions to existing// methods from the base class:3989.5 违例的限制//! public void event() throws RainedOut {}// If the method doesn't already exist in the// base class, the exception is OK:public void rainHard() throws RainedOut {}// You can choose to not throw any exceptions,// even if base version does:public void event() {}// Overridden methods can throw// inherited exceptions:void atBat() throws PopFoul {}public static void main(String[] args) {try {StormyInning si = new StormyInning();si.atBat();} catch(PopFoul e) {} catch(RainedOut e) {} catch(BaseballException e) {}// Strike not thrown in derived version.try {// What happens if you upcast?Inning i = new StormyInning();i.atBat();// You must catch the exceptions from the// base-class version of the method:} catch(Strike e) {} catch(Foul e) {} catch(RainedOut e) {} catch(BaseballException e) {}}} ///:~在Inning中,可以看到无论构建器还是event()方法都指出自己会“掷”出一个违例,但它们实际上没有那样做。这是合法的,因为它允许我们强迫用户捕获可能在覆盖过的event()版本里添加的任何违例。同样的道理也适用于abstract方法,就象在atBat()里展示的那样。“interface Storm”非常有趣,因为它包含了在Incoming中定义的一个方法——event(),以及不是在其中定义的一个方法。这两个方法都会“掷”出一个新的违例类型:RainedOut。当执行到“StormyInning extends”和“implements Storm”的时候,可以看到Storm中的event()方法不能改变Inning中的event()的违例接口。同样地,这种设计是十分合理的;否则的话,当我们操作基础类时,便根本无法知道自己捕获的是否正确的东西。当然,假如interface中定义的一个方法不在基础类里,比如rainHard(),它产生违例时就没什么问题。对违例的限制并不适用于构建器。在StormyInning中,我们可看到一个构建器能够“掷”出它希望的任何东西,无论基础类构建器“掷”出什么。然而,由于必须坚持按某种方式调用基础类构建器(在这里,会自动调用默认构建器),所以衍生类构建器必须在自己的违例规范中声明所有基础类构建器违例。3999.5 违例的限制StormyInning.walk()不会编译的原因是它“掷”出了一个违例,而Inning.walk()却不会“掷”出。若允许这种情况发生,就可让自己的代码调用Inning.walk(),而且它不必控制任何违例。但在以后替换从Inning衍生的一个类的对象时,违例就会“掷”出,造成代码执行的中断。通过强迫衍生类方法遵守基础类方法的违例规范,对象的替换可保持连贯性。覆盖过的event()方法向我们显示出一个方法的衍生类版本可以不产生任何违例——即便基础类版本要产生违例。同样地,这样做是必要的,因为它不会中断那些已假定基础类版本会产生违例的代码。差不多的道理亦适用于atBat(),它会“掷”出PopFoul——从Foul衍生出来的一个违例,而Foul违例是由atBat()的基础类版本产生的。这样一来,假如有人在自己的代码里操作Inning,同时调用了atBat(),就必须捕获Foul违例。由于PopFoul是从Foul衍生的,所以违例控制器(模块)也会捕获PopFoul。最后一个有趣的地方在main()内部。在这个地方,假如我们明确操作一个StormyInning对象,编译器就会强迫我们只捕获特定于那个类的违例。但假如我们上溯造型到基础类型,编译器就会强迫我们捕获针对基础类的违例。通过所有这些限制,违例控制代码的“健壮”程度获得了大幅度改善(注释③)。③:ANSI/ISO C++施加了类似的限制,要求衍生方法违例与基础类方法掷出的违例相同,或者从后者衍生。在这种情况下,C++实际上能够在编译期间检查违例规范。我们必须认识到这一点:尽管违例规范是由编译器在继承期间强行遵守的,但违例规范并不属于方法类型的一部分,后者仅包括了方法名以及自变量类型。因此,我们不可在违例规范的基础上覆盖方法。除此以外,尽管违例规范存在于一个方法的基础类版本中,但并不表示它必须在方法的衍生类版本中存在。这与方法的“继承”颇有不同(进行继承时,基础类中的方法也必须在衍生类中存在)。换言之,用于一个特定方法的“违例规范接口”可能在继承和覆盖时变得更“窄”,但它不会变得更“宽”——这与继承时的类接口规则是正好相反的。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:104009.6 用finally清除9.6 用finally清除无论一个违例是否在try块中发生,我们经常都想执行一些特定的代码。对一些特定的操作,经常都会遇到这种情况,但在恢复内存时一般都不需要(因为垃圾收集器会自动照料一切)。为达到这个目的,可在所有违例控制器的末尾使用一个finally从句(注释④)。所以完整的违例控制小节象下面这个样子:try {// 要保卫的区域:// 可能“掷”出A,B,或C的危险情况} catch (A a1) {// 控制器 A} catch (B b1) {// 控制器 B} catch (C c1) {// 控制器 C} finally {// 每次都会发生的情况}④:C++违例控制未提供finally从句,因为它依赖构建器来达到这种清除效果。为演示finally从句,请试验下面这个程序://: FinallyWorks.java// The finally clause is always executedpublic class FinallyWorks {static int count = 0;public static void main(String[] args) {while(true) {try {// post-increment is zero first time:if(count++ == 0)throw new Exception();System.out.println("No exception");} catch(Exception e) {System.out.println("Exception thrown");} finally {System.out.println("in finally clause");if(count == 2) break; // out of "while"}}}} ///:~4019.6 用finally清除通过该程序,我们亦可知道如何应付Java违例(类似C++的违例)不允许我们恢复至违例产生地方的这一事实。若将自己的try块置入一个循环内,就可建立一个条件,它必须在继续程序之前满足。亦可添加一个static计数器或者另一些设备,允许循环在放弃以前尝试数种不同的方法。这样一来,我们的程序可以变得更加“健壮”。输出如下:Exception thrownin finally clauseNo exceptionin finally clause无论是否“掷”出一个违例,finally从句都会执行。9.6.1 用finally做什么在没有“垃圾收集”以及“自动调用破坏器”机制的一种语言中(注释⑤),finally显得特别重要,因为程序员可用它担保内存的正确释放——无论在try块内部发生了什么状况。但Java提供了垃圾收集机制,所以内存的释放几乎绝对不会成为问题。另外,它也没有构建器可供调用。既然如此,Java里何时才会用到finally呢?⑤:“破坏器”(Destructor)是“构建器”(Constructor)的反义词。它代表一个特殊的函数,一旦某个对象失去用处,通常就会调用它。我们肯定知道在哪里以及何时调用破坏器。C++提供了自动的破坏器调用机制,但Delphi的Object Pascal版本1及2却不具备这一能力(在这种语言中,破坏器的含义与用法都发生了变化)。除将内存设回原始状态以外,若要设置另一些东西,finally就是必需的。例如,我们有时需要打开一个文件或者建立一个网络连接,或者在屏幕上画一些东西,甚至设置外部世界的一个开关,等等。如下例所示:4029.6 用finally清除//: OnOffSwitch.java// Why use finally?class Switch {boolean state = false;boolean read() { return state; }void on() { state = true; }void off() { state = false; }}public class OnOffSwitch {static Switch sw = new Switch();public static void main(String[] args) {try {sw.on();// Code that can throw exceptions...sw.off();} catch(NullPointerException e) {System.out.println("NullPointerException");sw.off();} catch(IllegalArgumentException e) {System.out.println("IOException");sw.off();}}} ///:~这里的目标是保证main()完成时开关处于关闭状态,所以将sw.off()置于try块以及每个违例控制器的末尾。但产生的一个违例有可能不是在这里捕获的,这便会错过sw.off()。然而,利用finally,我们可以将来自try块的关闭代码只置于一个地方:4039.6 用finally清除//: WithFinally.java// Finally Guarantees cleanupclass Switch2 {boolean state = false;boolean read() { return state; }void on() { state = true; }void off() { state = false; }}public class WithFinally {static Switch2 sw = new Switch2();public static void main(String[] args) {try {sw.on();// Code that can throw exceptions...} catch(NullPointerException e) {System.out.println("NullPointerException");} catch(IllegalArgumentException e) {System.out.println("IOException");} finally {sw.off();}}} ///:~在这儿,sw.off()已移至一个地方。无论发生什么事情,都肯定会运行它。即使违例不在当前的catch从句集里捕获,finally都会在违例控制机制转到更高级别搜索一个控制器之前得以执行。如下所示:4049.6 用finally清除//: AlwaysFinally.java// Finally is always executedclass Ex extends Exception {}public class AlwaysFinally {public static void main(String[] args) {System.out.println("Entering first try block");try {System.out.println("Entering second try block");try {throw new Ex();} finally {System.out.println("finally in 2nd try block");}} catch(Ex e) {System.out.println("Caught Ex in first try block");} finally {System.out.println("finally in 1st try block");}}} ///:~该程序的输出展示了具体发生的事情:Entering first try blockEntering second try blockfinally in 2nd try blockCaught Ex in first try blockfinally in 1st try block若调用了break和continue语句,finally语句也会得以执行。请注意,与作上标签的break和continue一道,finally排除了Java对goto跳转语句的需求。9.6.2 缺点:丢失的违例一般情况下,Java的违例实施方案都显得十分出色。不幸的是,它依然存在一个缺点。尽管违例指出程序里存在一个危机,而且绝不应忽略,但一个违例仍有可能简单地“丢失”。在采用finally从句的一种特殊配置下,便有可能发生这种情况:4059.6 用finally清除//: LostMessage.java// How an exception can be lostclass VeryImportantException extends Exception {public String toString() {return "A very important exception!";}}class HoHumException extends Exception {public String toString() {return "A trivial exception";}}public class LostMessage {void f() throws VeryImportantException {throw new VeryImportantException();}void dispose() throws HoHumException {throw new HoHumException();}public static void main(String[] args)throws Exception {LostMessage lm = new LostMessage();try {lm.f();} finally {lm.dispose();}}} ///:~输出如下:A trivial exceptionat LostMessage.dispose(LostMessage.java:21)at LostMessage.main(LostMessage.java:29)可以看到,这里不存在VeryImportantException(非常重要的违例)的迹象,它只是简单地被finally从句中的HoHumException代替了。这是一项相当严重的缺陷,因为它意味着一个违例可能完全丢失。而且就象前例演示的那样,这种丢失显得非常“自然”,很难被人查出蛛丝马迹。而与此相反,C++里如果第二个违例在第一个违例得到控制前产生,就会被当作一个严重的编程错误处理。或许Java以后的版本会纠正这个问题(上述结果是用Java 1.1生成的)。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:4069.6 用finally清除2018-03-13 01:23:104079.7 构建器9.7 构建器为违例编写代码时,我们经常要解决的一个问题是:“一旦产生违例,会正确地进行清除吗?”大多数时候都会非常安全,但在构建器中却是一个大问题。构建器将对象置于一个安全的起始状态,但它可能执行一些操作——如打开一个文件。除非用户完成对象的使用,并调用一个特殊的清除方法,否则那些操作不会得到正确的清除。若从一个构建器内部“掷”出一个违例,这些清除行为也可能不会正确地发生。所有这些都意味着在编写构建器时,我们必须特别加以留意。由于前面刚学了finally,所以大家可能认为它是一种合适的方案。但事情并没有这么简单,因为finally每次都会执行清除代码——即使我们在清除方法运行之前不想执行清除代码。因此,假如真的用finally进行清除,必须在构建器正常结束时设置某种形式的标志。而且只要设置了标志,就不要执行finally块内的任何东西。由于这种做法并不完美(需要将一个地方的代码同另一个地方的结合起来),所以除非特别需要,否则一般不要尝试在finally中进行这种形式的清除。在下面这个例子里,我们创建了一个名为InputFile的类。它的作用是打开一个文件,然后每次读取它的一行内容(转换为一个字串)。它利用了由Java标准IO库提供的FileReader以及BufferedReader类(将于第10章讨论)。这两个类都非常简单,大家现在可以毫无困难地掌握它们的基本用法://: Cleanup.java// Paying attention to exceptions// in constructorsimport java.io.*;class InputFile {private BufferedReader in;InputFile(String fname) throws Exception {try {in =new BufferedReader(new FileReader(fname));// Other code that might throw exceptions} catch(FileNotFoundException e) {System.out.println("Could not open " + fname);// Wasn't open, so don't close itthrow e;} catch(Exception e) {// All other exceptions must close ittry {in.close();} catch(IOException e2) {System.out.println(4089.7 构建器"in.close() unsuccessful");}throw e;} finally {// Don't close it here!!!}}String getLine() {String s;try {s = in.readLine();} catch(IOException e) {System.out.println("readLine() unsuccessful");s = "failed";}return s;}void cleanup() {try {in.close();} catch(IOException e2) {System.out.println("in.close() unsuccessful");}}}public class Cleanup {public static void main(String[] args) {try {InputFile in =new InputFile("Cleanup.java");String s;int i = 1;while((s = in.getLine()) != null)System.out.println(""+ i++ + ": " + s);in.cleanup();} catch(Exception e) {System.out.println("Caught in main, e.printStackTrace()");e.printStackTrace();}}} ///:~该例使用了Java 1.1 IO类。用于InputFile的构建器采用了一个String(字串)参数,它代表我们想打开的那个文件的名字。在一个try块内部,它用该文件名创建了一个FileReader。对FileReader来说,除非转移并用它创建一个能够实际与之“交谈”的BufferedReader,否则便没什么用处。注意InputFile的一4099.7 构建器个好处就是它同时合并了这两种行动。若FileReader构建器不成功,就会产生一个FileNotFoundException(文件未找到违例)。必须单独捕获这个违例——这属于我们不想关闭文件的一种特殊情况,因为文件尚未成功打开。其他任何捕获从句(catch)都必须关闭文件,因为文件已在进入那些捕获从句时打开(当然,如果多个方法都能产生一个FileNotFoundException违例,就需要稍微用一些技巧。此时,我们可将不同的情况分隔到数个try块内)。close()方法会掷出一个尝试过的违例。即使它在另一个catch从句的代码块内,该违例也会得以捕获——对Java编译器来说,那个catch从句不过是另一对花括号而已。执行完本地操作后,违例会被重新“掷”出。这样做是必要的,因为这个构建器的执行已经失败,我们不希望调用方法来假设对象已正确创建以及有效。在这个例子中,没有采用前述的标志技术,finally从句显然不是关闭文件的正确地方,因为这可能在每次构建器结束的时候关闭它。由于我们希望文件在InputFile对象处于活动状态时一直保持打开状态,所以这样做并不恰当。getLine()方法会返回一个字串,其中包含了文件中下一行的内容。它调用了readLine(),后者可能产生一个违例,但那个违例会被捕获,使getLine()不会再产生任何违例。对违例来说,一项特别的设计问题是决定在这一级完全控制一个违例,还是进行部分控制,并传递相同(或不同)的违例,或者只是简单地传递它。在适当的时候,简单地传递可极大简化我们的编码工作。getLine()方法会变成:String getLine() throws IOException {return in.readLine();}但是当然,调用者现在需要对可能产生的任何IOException进行控制。用户使用完毕InputFile对象后,必须调用cleanup()方法,以便释放由BufferedReader以及/或者FileReader占用的系统资源(如文件句柄)——注释⑥。除非InputFile对象使用完毕,而且到了需要弃之不用的时候,否则不应进行清除。大家可能想把这样的机制置入一个finalize()方法内,但正如第4章指出的那样,并非总能保证finalize()获得正确的调用(即便确定它会调用,也不知道何时开始)。这属于Java的一项缺陷——除内存清除之外的所有清除都不会自动进行,所以必须知会客户程序员,告诉他们有责任用finalize()保证清除工作的正确进行。⑥:在C++里,“破坏器”可帮我们控制这一局面。在Cleanup.java中,我们创建了一个InputFile,用它打开用于创建程序的相同的源文件。同时一次读取该文件的一行内容,而且添加相应的行号。所有违例都会在main()中被捕获——尽管我们可选择更大的可靠性。4109.7 构建器这个示例也向大家展示了为何在本书的这个地方引入违例的概念。违例与Java的编程具有很高的集成度,这主要是由于编译器会强制它们。只有知道了如何操作那些违例,才可更进一步地掌握编译器的知识。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:104119.8 违例匹配9.8 违例匹配“掷”出一个违例后,违例控制系统会按当初编写的顺序搜索“最接近”的控制器。一旦找到相符的控制器,就认为违例已得到控制,不再进行更多的搜索工作。在违例和它的控制器之间,并不需要非常精确的匹配。一个衍生类对象可与基础类的一个控制器相配,如下例所示://: Human.java// Catching Exception Hierarchiesclass Annoyance extends Exception {}class Sneeze extends Annoyance {}public class Human {public static void main(String[] args) {try {throw new Sneeze();} catch(Sneeze s) {System.out.println("Caught Sneeze");} catch(Annoyance a) {System.out.println("Caught Annoyance");}}} ///:~Sneeze违例会被相符的第一个catch从句捕获。当然,这只是第一个。然而,假如我们删除第一个catch从句:try {throw new Sneeze();} catch(Annoyance a) {System.out.println("Caught Annoyance");}那么剩下的catch从句依然能够工作,因为它捕获的是Sneeze的基础类。换言之,catch(Annoyance e)能捕获一个Annoyance以及从它衍生的任何类。这一点非常重要,因为一旦我们决定为一个方法添加更多的违例,而且它们都是从相同的基础类继承的,那么客户程序员的代码就不需要更改。至少能够假定它们捕获的是基础类。若将基础类捕获从句置于第一位,试图“屏蔽”衍生类违例,就象下面这样:4129.8 违例匹配try {throw new Sneeze();} catch(Annoyance a) {System.out.println("Caught Annoyance");} catch(Sneeze s) {System.out.println("Caught Sneeze");}则编译器会产生一条出错消息,因为它发现永远不可能抵达Sneeze捕获从句。9.8.1 违例准则用违例做下面这些事情:(1) 解决问题并再次调用造成违例的方法。(2) 平息事态的发展,并在不重新尝试方法的前提下继续。(3) 计算另一些结果,而不是希望方法产生的结果。(4) 在当前环境中尽可能解决问题,以及将相同的违例重新“掷”出一个更高级的环境。(5) 在当前环境中尽可能解决问题,以及将不同的违例重新“掷”出一个更高级的环境。(6) 中止程序执行。(7) 简化编码。若违例方案使事情变得更加复杂,那就会令人非常烦恼,不如不用。(8) 使自己的库和程序变得更加安全。这既是一种“短期投资”(便于调试),也是一种“长期投资”(改善应用程序的健壮性)Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:104139.9 总结9.9 总结通过先进的错误纠正与恢复机制,我们可以有效地增强代码的健壮程度。对我们编写的每个程序来说,错误恢复都属于一个基本的考虑目标。它在Java中显得尤为重要,因为该语言的一个目标就是创建不同的程序组件,以便其他用户(客户程序员)使用。为构建一套健壮的系统,每个组件都必须非常健壮。在Java里,违例控制的目的是使用尽可能精简的代码创建大型、可靠的应用程序,同时排除程序里那些不能控制的错误。违例的概念很难掌握。但只有很好地运用它,才可使自己的项目立即获得显著的收益。Java强迫遵守违例所有方面的问题,所以无论库设计者还是客户程序员,都能够连续一致地使用它。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:104149.10 练习9.10 练习(1) 用main()创建一个类,令其掷出try块内的Exception类的一个对象。为Exception的构建器赋予一个字串参数。在catch从句内捕获违例,并打印出字串参数。添加一个finally从句,并打印一条消息,证明自己真正到达那里。(2) 用extends关键字创建自己的违例类。为这个类写一个构建器,令其采用String参数,并随同String句柄把它保存到对象内。写一个方法,令其打印出保存下来的String。创建一个trycatch从句,练习实际操作新违例。(3) 写一个类,并令一个方法掷出在练习2中创建的类型的一个违例。试着在没有违例规范的前提下编译它,观察编译器会报告什么。接着添加适当的违例规范。在一个try-catch从句中尝试自己的类以及它的违例。(4) 在第5章,找到调用了Assert.java的两个程序,并修改它们,令其掷出自己的违例类型,而不是打印到System.err。该违例应是扩展了RuntimeException的一个内部类。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:10415第10章 Java IO系统第10章 Java IO系统“对语言设计人员来说,创建好的输入/输出系统是一项特别困难的任务。”由于存在大量不同的设计方案,所以该任务的困难性是很容易证明的。其中最大的挑战似乎是如何覆盖所有可能的因素。不仅有三种不同的种类的IO需要考虑(文件、控制台、网络连接),而且需要通过大量不同的方式与它们通信(顺序、随机访问、二进制、字符、按行、按字等等)。Java库的设计者通过创建大量类来攻克这个难题。事实上,Java的IO系统采用了如此多的类,以致刚开始会产生不知从何处入手的感觉(具有讽刺意味的是,Java的IO设计初衷实际要求避免过多的类)。从Java 1.0升级到Java 1.1后,IO库的设计也发生了显著的变化。此时并非简单地用新库替换旧库,Sun的设计人员对原来的库进行了大手笔的扩展,添加了大量新的内容。因此,我们有时不得不混合使用新库与旧库,产生令人无奈的复杂代码。本章将帮助大家理解标准Java库内的各种IO类,并学习如何使用它们。本章的第一部分将介绍“旧”的Java 1.0 IO流库,因为现在有大量代码仍在使用那个库。本章剩下的部分将为大家引入Java 1.1 IO库的一些新特性。注意若用Java 1.1编译器来编译本章第一部分介绍的部分代码,可能会得到一条“不建议使用该特性”(Deprecated feature)警告消息。代码仍然能够使用;编译器只是建议我们换用本章后面要讲述的一些新特性。但我们这样做是有价值的,因为可以更清楚地认识老方法与新方法之间的一些差异,从而加深我们的理解(并可顺利阅读为Java 1.0写的代码)。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:1041610.1 输入和输出10.1 输入和输出可将Java库的IO类分割为输入与输出两个部分,这一点在用Web浏览器阅读联机Java类文档时便可知道。通过继承,从InputStream(输入流)衍生的所有类都拥有名为read()的基本方法,用于读取单个字节或者字节数组。类似地,从OutputStream衍生的所有类都拥有基本方法write(),用于写入单个字节或者字节数组。然而,我们通常不会用到这些方法;它们之所以存在,是因为更复杂的类可以利用它们,以便提供一个更有用的接口。因此,我们很少用单个类创建自己的系统对象。一般情况下,我们都是将多个对象重叠在一起,提供自己期望的功能。我们之所以感到Java的流库(Stream Library)异常复杂,正是由于为了创建单独一个结果流,却需要创建多个对象的缘故。很有必要按照功能对类进行分类。库的设计者首先决定与输入有关的所有类都从InputStream继承,而与输出有关的所有类都从OutputStream继承。10.1.1 InputStream的类型InputStream的作用是标志那些从不同起源地产生输入的类。这些起源地包括(每个都有一个相关的InputStream子类):(1) 字节数组(2) String对象(3) 文件(4) “管道”,它的工作原理与现实生活中的管道类似:将一些东西置入一端,它们在另一端出来。 (5) 一系列其他流,以便我们将其统一收集到单独一个流内。(6) 其他起源地,如Internet连接等(将在本书后面的部分讲述)。除此以外,FilterInputStream也属于InputStream的一种类型,用它可为“破坏器”类提供一个基础类,以便将属性或者有用的接口同输入流连接到一起。这将在以后讨论。41710.1 输入和输出ClassFunctionConstructor ArgumentsHow to use itByteArray-InputStreamAllows a buffer in memory to be used as an InputStream.The buffer from which to extract the bytes.As a source of data. Connect it to a FilterInputStream object to provide a useful interface.StringBuffer-InputStreamConverts a String into an InputStream.A String. The underlying implementation actually uses a StringBuffer.As a source of data. Connect it to a FilterInputStream object to provide a useful interface.File-InputStreamFor reading information from a file.A String representing the file name, or a File or FileDescriptor object.As a source of data. Connect it to a FilterInputStream object to provide a useful interface.类 功能 构建器参数/如何使用ByteArrayInputStream 允许内存中的一个缓冲区作为InputStream使用 从中提取字节的缓冲区/作为一个数据源使用。通过将其同一个FilterInputStream对象连接,可提供一个有用的接口StringBufferInputStream 将一个String转换成InputStream 一个String(字串)。基础的实施方案实际采用一个StringBuffer(字串缓冲)/作为一个数据源使用。通过将其同一个FilterInputStream对象连接,可提供一个有用的接口FileInputStream 用于从文件读取信息 代表文件名的一个String,或者一个File或FileDescriptor对象/作为一个数据源使用。通过将其同一个FilterInputStream对象连接,可提供一个有用的接口41810.1 输入和输出Piped-InputStreamProduces the data that’s being written to the associated PipedOutput-Stream. Implements the “piping” concept.PipedOutputStreamAs a source of data in multithreading. Connect it to a FilterInputStream object to provide a useful interface.Sequence-InputStreamCoverts two or more InputStream objects into a single InputStream.Two InputStream objects or an Enumeration for a container of InputStream objects.As a source of data. Connect it to a FilterInputStream object to provide a useful interface.Filter-InputStreamAbstract class which is an interface for decorators that provide useful functionalityto the other InputStream classes. See Table 10-3.See Table 10-3.See Table 10-3.PipedInputString 产生为相关的PipedOutputStream写的数据。实现了“管道化”的概念PipedOutputStream/作为一个数据源使用。通过将其同一个FilterInputStream对象连接,可提供一个有用的接口SequenceInputStream 将两个或更多的InputStream对象转换成单个InputStream使用 两个InputStream对象或者一个Enumeration,用于InputStream对象的一个容器/作为一个数据源使用。通过将其同一个FilterInputStream对象连接,可提供一个有用的接口FilterInputStream 对作为破坏器接口使用的类进行抽象;那个破坏器为其他InputStream类提供了有用的功能。参见表10.3 参见表10.3/参见表10.310.1.2 OutputStream的类型这一类别包括的类决定了我们的输入往何处去:一个字节数组(但没有String;假定我们可用字节数组创建一个);一个文件;或者一个“管道”。除此以外,FilterOutputStream为“破坏器”类提供了一个基础类,它将属性或者有用的接口同输出流连接起来。这将在以后讨论。表10.2 OutputStream的类型41910.1 输入和输出ClassFunctionConstructor ArgumentsHow to use itByteArray-OutputStreamCreates a buffer in memory. All the data that you send to the stream is placed in thisbuffer.Optional initial size of the buffer.To designate the destination of your data. Connect it to a FilterOutputStream object to provide a useful interface.File-OutputStreamFor sending information to a file.A String representing the file name, or a File or FileDescriptor object.To designate the destination of your data. Connect it to a FilterOutputStream object to provide a useful interface.Piped-OutputStreamAny information you write to this automatically ends up as input for the associated PipedInput-Stream. Implements the “piping” concept.PipedInputStreamTo designate the destination of your data for multithreading. Connect it to a FilterOutputStream object to provide a useful interface.Filter-OutputStreamAbstract class which is an interface for decorators that provide useful functionalityto the other OutputStream classes. See Table10-4.See Table 10-4.See Table 10-4.类 功能 构建器参数/如何使用42010.1 输入和输出ByteArrayOutputStream 在内存中创建一个缓冲区。我们发送给流的所有数据都会置入这个缓冲区。 可选缓冲区的初始大小/ 用于指出数据的目的地。若将其同FilterOutputStream对象连接到一起,可提供一个有用的接口FileOutputStream 将信息发给一个文件 用一个String代表文件名,或选用一个File或FileDescriptor对象/用于指出数据的目的地。若将其同FilterOutputStream对象连接到一起,可提供一个有用的接口PipedOutputStream 我们写给它的任何信息都会自动成为相关的PipedInputStream的输出。实现了“管道化”的概念 PipedInputStream/为多线程处理指出自己数据的目的地/将其同FilterOutputStream对象连接到一起,便可提供一个有用的接口FilterOutputStream 对作为破坏器接口使用的类进行抽象处理;那个破坏器为其他OutputStream类提供了有用的功能。参见表10.4 参见表10.4/参见表10.4Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:1042110.2 增添属性和有用的接口10.2 增添属性和有用的接口利用层次化对象动态和透明地添加单个对象的能力的做法叫作“装饰器”(Decorator)方案——“方案”属于本书第16章的主题(注释①)。装饰器方案规定封装于初始化对象中的所有对象都拥有相同的接口,以便利用装饰器的“透明”性质——我们将相同的消息发给一个对象,无论它是否已被“装饰”。这正是在Java IO库里存在“过滤器”(Filter)类的原因:抽象的“过滤器”类是所有装饰器的基础类(装饰器必须拥有与它装饰的那个对象相同的接口,但装饰器亦可对接口作出扩展,这种情况见诸于几个特殊的“过滤器”类中)。子类处理要求大量子类对每种可能的组合提供支持时,便经常会用到装饰器——由于组合形式太多,造成子类处理变得不切实际。Java IO库要求许多不同的特性组合方案,这正是装饰器方案显得特别有用的原因。但是,装饰器方案也有自己的一个缺点。在我们写一个程序的时候,装饰器为我们提供了大得多的灵活性(因为可以方便地混合与匹配属性),但它们也使自己的代码变得更加复杂。原因在于Java IO库操作不便,我们必须创建许多类——“核心”IO类型加上所有装饰器——才能得到自己希望的单个IO对象。FilterInputStream和FilterOutputStream(这两个名字不十分直观)提供了相应的装饰器接口,用于控制一个特定的输入流(InputStream)或者输出流(OutputStream)。它们分别是从InputStream和OutputStream衍生出来的。此外,它们都属于抽象类,在理论上为我们与一个流的不同通信手段都提供了一个通用的接口。事实上,FilterInputStream和FilterOutputStream只是简单地模仿了自己的基础类,它们是一个装饰器的基本要求。10.2.1 通过FilterInputStream从InputStream里读入数据FilterInputStream类要完成两件全然不同的事情。其中,DataInputStream允许我们读取不同的基本类型数据以及String对象(所有方法都以“read”开头,比如readByte(),readFloat()等等)。伴随对应的DataOutputStream,我们可通过数据“流”将基本类型的数据从一个地方搬到另一个地方。这些“地方”是由表10.1总结的那些类决定的。若读取块内的数据,并自己进行解析,就不需要用到DataInputStream。但在其他许多情况下,我们一般都想用它对自己读入的数据进行自动格式化。 剩下的类用于修改InputStream的内部行为方式:是否进行缓冲,是否跟踪自己读入的数据行,以及是否能够推回一个字符等等。后两种类看起来特别象提供对构建一个编译器的支持(换言之,添加它们为了支持Java编译器的构建),所以在常规编程中一般都用不着它们。也许几乎每次都要缓冲自己的输入,无论连接的是哪个IO设备。所以IO库最明智的做法就是将未缓冲输入作为一种特殊情况处理,同时将缓冲输入接纳为标准做法。表10.3 FilterInputStream的类型ClassFunction42210.2 增添属性和有用的接口Constructor ArgumentsHow to use itData-InputStreamUsed in concert with DataOutputStream, so you can read primitives (int, char, long, etc.)from a stream in a portable fashion.InputStreamContains a full interface to allow you to read primitive types.Buffered-InputStreamUse this to prevent a physical read every time you want more data. You’re saying “Use abuffer.”InputStream, with optional buffer size.This doesn’t provide an interface per se, just a requirement that a buffer be used. Attach aninterface object.LineNumber-InputStreamKeeps track of line numbers in the input stream; you can call getLineNumber( ) andsetLineNumber(int).InputStreamThis just adds line numbering, so you’ll probably attach an interface object.Pushback-InputStreamHas a one byte push-back buffer so that you can push back the last character read.InputStreamGenerally used in the scanner for a compiler and probably included because the Javacompiler needed it. You probably won’t use this.类 功能 构建器参数/如何使用DataInputStream 与DataOutputStream联合使用,使自己能以机动方式读取一个流中的基本数据类型(int,char,long等等) InputStream/包含了一个完整的接口,以便读取基本数据类型BufferedInputStream 避免每次想要更多数据时都进行物理性的读取,告诉它“请先在缓冲区里找” InputStream,没有可选的缓冲区大小/本身并不能提供一个接口,只是发出使用缓冲区的要求。要求同一个接口对象连接到一起42310.2 增添属性和有用的接口LineNumberInputStream 跟踪输入流中的行号;可调用getLineNumber()以及setLineNumber(int) 只是添加对数据行编号的能力,所以可能需要同一个真正的接口对象连接PushbackInputStream 有一个字节的后推缓冲区,以便后推读入的上一个字符 InputStream/通常由编译器在扫描器中使用,因为Java编译器需要它。一般不在自己的代码中使用10.2.2 通过FilterOutputStream向OutputStream里写入数据与DataInputStream对应的是DataOutputStream,后者对各个基本数据类型以及String对象进行格式化,并将其置入一个数据“流”中,以便任何机器上的DataInputStream都能正常地读取它们。所有方法都以“wirte”开头,例如writeByte(),writeFloat()等等。若想进行一些真正的格式化输出,比如输出到控制台,请使用PrintStream。利用它可以打印出所有基本数据类型以及String对象,并可采用一种易于查看的格式。这与DataOutputStream正好相反,后者的目标是将那些数据置入一个数据流中,以便DataInputStream能够方便地重新构造它们。System.out静态对象是一个PrintStream。PrintStream内两个重要的方法是print()和println()。它们已进行了覆盖处理,可打印出所有数据类型。print()和println()之间的差异是后者在操作完毕后会自动添加一个新行。BufferedOutputStream属于一种“修改器”,用于指示数据流使用缓冲技术,使自己不必每次都向流内物理性地写入数据。通常都应将它应用于文件处理和控制器IO。 表10.4FilterOutputStream的类型ClassFunctionConstructor ArgumentsHow to use itData-OutputStreamUsed in concert with DataInputStream so you can write primitives (int, char, long, etc.) to astream in a portable fashion.OutputStreamContains full interface to allow you to write primitive types.PrintStreamFor producing formatted output. While DataOutputStream handles the storage of data,PrintStream handles display.OutputStream, with optional boolean indicating that the buffer is flushed with every newline.Should be the “final” wrapping for your OutputStream object. You’ll probably use this a lot.42410.2 增添属性和有用的接口Buffered-OutputStreamUse this to prevent a physical write every time you send a piece of data. You’re saying “Usea buffer.” You can call flush( ) to flush the buffer.OutputStream, with optional buffer size.This doesn’t provide an interface per se, just a requirement that a buffer is used. Attach aninterface object.类 功能 构建器参数/如何使用DataOutputStream 与DataInputStream配合使用,以便采用方便的形式将基本数据类型(int,char,long等)写入一个数据流 OutputStream/包含了完整接口,以便我们写入基本数据类型PrintStream 用于产生格式化输出。DataOutputStream控制的是数据的“存储”,而PrintStream控制的是“显示”OutputStream,可选一个布尔参数,指示缓冲区是否与每个新行一同刷新/对于自己的OutputStream对象,应该用“final”将其封闭在内。可能经常都要用到它BufferedOutputStream 用它避免每次发出数据的时候都要进行物理性的写入,要求它“请先在缓冲区里找”。可调用flush(),对缓冲区进行刷新 OutputStream,可选缓冲区大小/本身并不能提供一个接口,只是发出使用缓冲区的要求。需要同一个接口对象连接到一起Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:1042510.3 本身的缺陷:RandomAccessFile10.3 本身的缺陷:RandomAccessFileRandomAccessFile用于包含了已知长度记录的文件,以便我们能用seek()从一条记录移至另一条;然后读取或修改那些记录。各记录的长度并不一定相同;只要知道它们有多大以及置于文件何处即可。首先,我们有点难以相信RandomAccessFile不属于InputStream或者OutputStream分层结构的一部分。除了恰巧实现了DataInput以及DataOutput(这两者亦由DataInputStream和DataOutputStream实现)接口之外,它们与那些分层结构并无什么关系。它甚至没有用到现有InputStream或OutputStream类的功能——采用的是一个完全不相干的类。该类属于全新的设计,含有自己的全部(大多数为固有)方法。之所以要这样做,是因为RandomAccessFile拥有与其他IO类型完全不同的行为,因为我们可在一个文件里向前或向后移动。不管在哪种情况下,它都是独立运作的,作为Object的一个“直接继承人”使用。从根本上说,RandomAccessFile类似DataInputStream和DataOutputStream的联合使用。其中,getFilePointer()用于了解当前在文件的什么地方,seek()用于移至文件内的一个新地点,而length()用于判断文件的最大长度。此外,构建器要求使用另一个自变量(与C的fopen()完全一样),指出自己只是随机读("r"),还是读写兼施("rw")。这里没有提供对“只写文件”的支持。也就是说,假如是从DataInputStream继承的,那么RandomAccessFile也有可能能很好地工作。还有更难对付的。很容易想象我们有时要在其他类型的数据流中搜索,比如一个ByteArrayInputStream,但搜索方法只有RandomAccessFile才会提供。而后者只能针对文件才能操作,不能针对数据流操作。此时,BufferedInputStream确实允许我们标记一个位置(使用mark(),它的值容纳于单个内部变量中),并用reset()重设那个位置。但这些做法都存在限制,并不是特别有用。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:1042610.4 File类10.4 File类File类有一个欺骗性的名字——通常会认为它对付的是一个文件,但实情并非如此。它既代表一个特定文件的名字,也代表目录内一系列文件的名字。若代表一个文件集,便可用list()方法查询这个集,返回的是一个字串数组。之所以要返回一个数组,而非某个灵活的集合类,是因为元素的数量是固定的。而且若想得到一个不同的目录列表,只需创建一个不同的File对象即可。事实上,“FilePath”(文件路径)似乎是一个更好的名字。本节将向大家完整地例示如何使用这个类,其中包括相关的FilenameFilter(文件名过滤器)接口。10.4.1 目录列表器现在假设我们想观看一个目录列表。可用两种方式列出File对象。若在不含自变量(参数)的情况下调用list(),会获得File对象包含的一个完整列表。然而,若想对这个列表进行某些限制,就需要使用一个“目录过滤器”,该类的作用是指出应如何选择File对象来完成显示。下面是用于这个例子的代码(或在执行该程序时遇到困难,请参考第3章3.1.2小节“赋值”):42710.4 File类//: DirList.java// Displays directory listingpackage c10;import java.io.*;public class DirList {public static void main(String[] args) {try {File path = new File(".");String[] list;if(args.length == 0)list = path.list();elselist = path.list(new DirFilter(args[0]));for(int i = 0; i < list.length; i++)System.out.println(list[i]);} catch(Exception e) {e.printStackTrace();}}}class DirFilter implements FilenameFilter {String afn;DirFilter(String afn) { this.afn = afn; }public boolean accept(File dir, String name) {// Strip path information:String f = new File(name).getName();return f.indexOf(afn) != -1;}} ///:~DirFilter类“实现”了interface FilenameFilter(关于接口的问题,已在第7章进行了详述)。下面让我们看看FilenameFilter接口有多么简单:public interface FilenameFilter {boolean accept(文件目录, 字串名);}它指出这种类型的所有对象都提供了一个名为accept()的方法。之所以要创建这样的一个类,背后的全部原因就是把accept()方法提供给list()方法,使list()能够“回调”accept(),从而判断应将哪些文件名包括到列表中。因此,通常将这种技术称为“回调”,有时也称为“算子”(也就是说,DirFilter是一个算子,因为它唯一的作用就是容纳一个方法)。由于list()采用一个FilenameFilter对象作为自己的自变量使用,所以我们能传递实现了FilenameFilter的任何类的一个对象,用它决定(甚至在运行期)list()方法的行为方式。回调的目的是在代码的行为上提供更大的灵活性。42810.4 File类通过DirFilter,我们看出尽管一个“接口”只包含了一系列方法,但并不局限于只能写那些方法(但是,至少必须提供一个接口内所有方法的定义。在这种情况下,DirFilter构建器也会创建)。accept()方法必须接纳一个File对象,用它指示用于寻找一个特定文件的目录;并接纳一个String,其中包含了要寻找之文件的名字。可决定使用或忽略这两个参数之一,但有时至少要使用文件名。记住list()方法准备为目录对象中的每个文件名调用accept(),核实哪个应包含在内——具体由accept()返回的“布尔”结果决定。 为确定我们操作的只是文件名,其中没有包含路径信息,必须采用String对象,并在它的外部创建一个File对象。然后调用getName(),它的作用是去除所有路径信息(采用与平台无关的方式)。随后,accept()用String类的indexOf()方法检查文件名内部是否存在搜索字串"afn"。若在字串内找到afn,那么返回值就是afn的起点索引;但假如没有找到,返回值就是-1。注意这只是一个简单的字串搜索例子,未使用常见的表达式“通配符”方案,比如"fo?.b?r*";这种方案更难实现。list()方法返回的是一个数组。可查询这个数组的长度,然后在其中遍历,选定数组元素。与C和C++的类似行为相比,这种于方法内外方便游历数组的行为无疑是一个显著的进步。1. 匿名内部类下例用一个匿名内部类(已在第7章讲述)来重写显得非常理想。首先创建了一个filter()方法,它返回指向FilenameFilter的一个句柄:42910.4 File类//: DirList2.java// Uses Java 1.1 anonymous inner classesimport java.io.*;public class DirList2 {public static FilenameFilterfilter(final String afn) {// Creation of anonymous inner class:return new FilenameFilter() {String fn = afn;public boolean accept(File dir, String n) {// Strip path information:String f = new File(n).getName();return f.indexOf(fn) != -1;}}; // End of anonymous inner class}public static void main(String[] args) {try {File path = new File(".");String[] list;if(args.length == 0)list = path.list();elselist = path.list(filter(args[0]));for(int i = 0; i < list.length; i++)System.out.println(list[i]);} catch(Exception e) {e.printStackTrace();}}} ///:~注意filter()的自变量必须是final。这一点是匿名内部类要求的,使其能使用来自本身作用域以外的一个对象。之所以认为这样做更好,是由于FilenameFilter类现在同DirList2紧密地结合在一起。然而,我们可采取进一步的操作,将匿名内部类定义成list()的一个参数,使其显得更加精简。如下所示:43010.4 File类//: DirList3.java// Building the anonymous inner class "in-place"import java.io.*;public class DirList3 {public static void main(final String[] args) {try {File path = new File(".");String[] list;if(args.length == 0)list = path.list();elselist = path.list(new FilenameFilter() {public booleanaccept(File dir, String n) {String f = new File(n).getName();return f.indexOf(args[0]) != -1;}});for(int i = 0; i < list.length; i++)System.out.println(list[i]);} catch(Exception e) {e.printStackTrace();}}} ///:~main()现在的自变量是final,因为匿名内部类直接使用args[0]。这展示了如何利用匿名内部类快速创建精简的类,以便解决一些复杂的问题。由于Java中的所有东西都与类有关,所以它无疑是一种相当有用的编码技术。它的一个好处是将特定的问题隔离在一个地方统一解决。但在另一方面,这样生成的代码不是十分容易阅读,所以使用时必须慎重。1. 顺序目录列表经常都需要文件名以排好序的方式提供。由于Java 1.0和Java 1.1都没有提供对排序的支持(从Java 1.2开始提供),所以必须用第8章创建的SortVector将这一能力直接加入自己的程序。就象下面这样:43110.4 File类//: SortedDirList.java// Displays sorted directory listingimport java.io.*;import c08.*;public class SortedDirList {private File path;private String[] list;public SortedDirList(final String afn) {path = new File(".");if(afn == null)list = path.list();elselist = path.list(new FilenameFilter() {public booleanaccept(File dir, String n) {String f = new File(n).getName();return f.indexOf(afn) != -1;}});sort();}void print() {for(int i = 0; i < list.length; i++)System.out.println(list[i]);}private void sort() {StrSortVector sv = new StrSortVector();for(int i = 0; i < list.length; i++)sv.addElement(list[i]);// The first time an element is pulled from// the StrSortVector the list is sorted:for(int i = 0; i < list.length; i++)list[i] = sv.elementAt(i);}// Test it:public static void main(String[] args) {SortedDirList sd;if(args.length == 0)sd = new SortedDirList(null);elsesd = new SortedDirList(args[0]);sd.print();}} ///:~这里进行了另外少许改进。不再是将path(路径)和list(列表)创建为main()的本地变量,它们变成了类的成员,使它们的值能在对象“生存”期间方便地访问。事实上,main()现在只是对类进行测试的一种方式。大家可以看到,一旦列表创建完毕,类的构建器就会自动开始对43210.4 File类列表进行排序。这种排序不要求区分大小写,所以最终不会得到一组全部单词都以大写字母开头的列表,跟着是全部以小写字母开头的列表。然而,我们注意到在以相同字母开头的一组文件名中,大写字母是排在前面的——这对标准的排序来说仍是一种不合格的行为。Java 1.2已成功解决了这个问题。10.4.2 检查与创建目录File类并不仅仅是对现有目录路径、文件或者文件组的一个表示。亦可用一个File对象新建一个目录,甚至创建一个完整的目录路径——假如它尚不存在的话。亦可用它了解文件的属性(长度、上一次修改日期、读/写属性等),检查一个File对象到底代表一个文件还是一个目录,以及删除一个文件等等。下列程序完整展示了如何运用File类剩下的这些方法://: MakeDirectories.java// Demonstrates the use of the File class to// create directories and manipulate files.import java.io.*;public class MakeDirectories {private final static String usage ="Usage:MakeDirectories path1 ...\n" +"Creates each path\n" +"Usage:MakeDirectories -d path1 ...\n" +"Deletes each path\n" +"Usage:MakeDirectories -r path1 path2\n" +"Renames from path1 to path2\n";private static void usage() {System.err.println(usage);System.exit(1);}private static void fileData(File f) {System.out.println("Absolute path: " + f.getAbsolutePath() +"\n Can read: " + f.canRead() +"\n Can write: " + f.canWrite() +"\n getName: " + f.getName() +"\n getParent: " + f.getParent() +"\n getPath: " + f.getPath() +"\n length: " + f.length() +"\n lastModified: " + f.lastModified());if(f.isFile())System.out.println("it's a file");else if(f.isDirectory())System.out.println("it's a directory");}public static void main(String[] args) {if(args.length < 1) usage();if(args[0].equals("-r")) {if(args.length != 3) usage();43310.4 File类Fileold = new File(args[1]),rname = new File(args[2]);old.renameTo(rname);fileData(old);fileData(rname);return; // Exit main}int count = 0;boolean del = false;if(args[0].equals("-d")) {count++;del = true;}for( ; count < args.length; count++) {File f = new File(args[count]);if(f.exists()) {System.out.println(f + " exists");if(del) {System.out.println("deleting..." + f);f.delete();}}else { // Doesn't existif(!del) {f.mkdirs();System.out.println("created " + f);}}fileData(f);}}} ///:~在fileData()中,可看到应用了各种文件调查方法来显示与文件或目录路径有关的信息。main()应用的第一个方法是renameTo(),利用它可以重命名(或移动)一个文件至一个全新的路径(该路径由参数决定),它属于另一个File对象。这也适用于任何长度的目录。若试验上述程序,就可发现自己能制作任意复杂程度的一个目录路径,因为mkdirs()会帮我们完成所有工作。在Java 1.0中,-d标志报告目录虽然已被删除,但它依然存在;但在Java 1.1中,目录会被实际删除。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:1043410.5 IO流的典型应用10.5 IO流的典型应用尽管库内存在大量IO流类,可通过多种不同的方式组合到一起,但实际上只有几种方式才会经常用到。然而,必须小心在意才能得到正确的组合。下面这个相当长的例子展示了典型IO配置的创建与使用,可在写自己的代码时将其作为一个参考使用。注意每个配置都以一个注释形式的编号起头,并提供了适当的解释信息。//: IOStreamDemo.java// Typical IO Stream Configurationsimport java.io.*;import com.bruceeckel.tools.*;public class IOStreamDemo {public static void main(String[] args) {try {// 1. Buffered input fileDataInputStream in =new DataInputStream(new BufferedInputStream(new FileInputStream(args[0])));String s, s2 = new String();while((s = in.readLine())!= null)s2 += s + "\n";in.close();// 2. Input from memoryStringBufferInputStream in2 =new StringBufferInputStream(s2);int c;while((c = in2.read()) != -1)System.out.print((char)c);// 3. Formatted memory inputtry {DataInputStream in3 =new DataInputStream(new StringBufferInputStream(s2));while(true)System.out.print((char)in3.readByte());} catch(EOFException e) {System.out.println("End of stream encountered");}// 4. Line numbering & file outputtry {LineNumberInputStream li =new LineNumberInputStream(43510.5 IO流的典型应用new StringBufferInputStream(s2));DataInputStream in4 =new DataInputStream(li);PrintStream out1 =new PrintStream(new BufferedOutputStream(new FileOutputStream("IODemo.out")));while((s = in4.readLine()) != null )out1.println("Line " + li.getLineNumber() + s);out1.close(); // finalize() not reliable!} catch(EOFException e) {System.out.println("End of stream encountered");}// 5. Storing & recovering datatry {DataOutputStream out2 =new DataOutputStream(new BufferedOutputStream(new FileOutputStream("Data.txt")));out2.writeBytes("Here's the value of pi: \n");out2.writeDouble(3.14159);out2.close();DataInputStream in5 =new DataInputStream(new BufferedInputStream(new FileInputStream("Data.txt")));System.out.println(in5.readLine());System.out.println(in5.readDouble());} catch(EOFException e) {System.out.println("End of stream encountered");}// 6. Reading/writing random access filesRandomAccessFile rf =new RandomAccessFile("rtest.dat", "rw");for(int i = 0; i < 10; i++)rf.writeDouble(i*1.414);rf.close();rf =new RandomAccessFile("rtest.dat", "rw");rf.seek(5*8);rf.writeDouble(47.0001);rf.close();rf =new RandomAccessFile("rtest.dat", "r");43610.5 IO流的典型应用for(int i = 0; i > " + s);boolean sad = false;st = new StringTokenizer(s);while (st.hasMoreTokens()) {String token = next();// Look until you find one of the// two starting tokens:if(!token.equals("I") &&!token.equals("Are"))continue; // Top of while loopif(token.equals("I")) {String tk2 = next();if(!tk2.equals("am")) // Must be after Ibreak; // Out of while loopelse {String tk3 = next();if(tk3.equals("sad")) {sad = true;44710.6 StreamTokenizerbreak; // Out of while loop}if (tk3.equals("not")) {String tk4 = next();if(tk4.equals("sad"))break; // Leave sad falseif(tk4.equals("happy")) {sad = true;break;}}}}if(token.equals("Are")) {String tk2 = next();if(!tk2.equals("you"))break; // Must be after AreString tk3 = next();if(tk3.equals("sad"))sad = true;break; // Out of while loop}}if(sad) prt("Sad detected");}static String next() {if(st.hasMoreTokens()) {String s = st.nextToken();prt(s);return s;}elsereturn "";}static void prt(String s) {System.out.println(s);}} ///:~对于准备分析的每个字串,我们进入一个while循环,并将记号从那个字串中取出。请注意第一个if语句,假如记号既不是“I”,也不是“Are”,就会执行continue(返回循环起点,再一次开始)。这意味着除非发现一个“I”或者“Are”,才会真正得到记号。大家可能想用==代替equals()方法,但那样做会出现不正常的表现,因为==比较的是句柄值,而equals()比较的是内容。analyze()方法剩余部分的逻辑是搜索“I am sad”(我很忧伤、“I am nothappy”(我不快乐)或者“Are you sad?”(你悲伤吗?)这样的句法格式。若没有break语句,这方面的代码甚至可能更加散乱。大家应注意对一个典型的解析器来说,通常都有这些记号的一个表格,并能在读取新记号的时候用一小段代码在表格内移动。44810.6 StreamTokenizer无论如何,只应将StringTokenizer看作StreamTokenizer一种简单而且特殊的简化形式。然而,如果有一个字串需要进行记号处理,而且StringTokenizer的功能实在有限,那么应该做的全部事情就是用StringBufferInputStream将其转换到一个数据流里,再用它创建一个功能更强大的StreamTokenizer。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:1044910.7 Java 1.1的IO流10.7 Java 1.1的IO流到这个时候,大家或许会陷入一种困境之中,怀疑是否存在IO流的另一种设计方案,并可能要求更大的代码量。还有人能提出一种更古怪的设计吗?事实上,Java 1.1对IO流库进行了一些重大的改进。看到Reader和Writer类时,大多数人的第一个印象(就象我一样)就是它们用来替换原来的InputStream和OutputStream类。但实情并非如此。尽管不建议使用原始数据流库的某些功能(如使用它们,会从编译器收到一条警告消息),但原来的数据流依然得到了保留,以便维持向后兼容,而且:(1) 在老式层次结构里加入了新类,所以Sun公司明显不会放弃老式数据流。(2) 在许多情况下,我们需要与新结构中的类联合使用老结构中的类。为达到这个目的,需要使用一些“桥”类:InputStreamReader将一个InputStream转换成Reader,OutputStreamWriter将一个OutputStream转换成Writer。 所以与原来的IO流库相比,经常都要对新IO流进行层次更多的封装。同样地,这也属于装饰器方案的一个缺点——需要为额外的灵活性付出代价。之所以在Java 1.1里添加了Reader和Writer层次,最重要的原因便是国际化的需求。老式IO流层次结构只支持8位字节流,不能很好地控制16位Unicode字符。由于Unicode主要面向的是国际化支持(Java内含的char是16位的Unicode),所以添加了Reader和Writer层次,以提供对所有IO操作中的Unicode的支持。除此之外,新库也对速度进行了优化,可比旧库更快地运行。 与本书其他地方一样,我会试着提供对类的一个概述,但假定你会利用联机文档搞定所有的细节,比如方法的详尽列表等。10.7.1 数据的发起与接收Java 1.0的几乎所有IO流类都有对应的Java 1.1类,用于提供内建的Unicode管理。似乎最容易的事情就是“全部使用新类,再也不要用旧的”,但实际情况并没有这么简单。有些时候,由于受到库设计的一些限制,我们不得不使用Java 1.0的IO流类。特别要指出的是,在旧流库的基础上新加了java.util.zip库,它们依赖旧的流组件。所以最明智的做法是“尝试性”地使用Reader和Writer类。若代码不能通过编译,便知道必须换回老式库。下面这张表格分旧库与新库分别总结了信息发起与接收之间的对应关系。45010.7 Java 1.1的IO流Sources & Sinks:Java 1.0 classCorresponding Java 1.1 classInputStreamReaderconverter: InputStreamReaderOutputStreamWriterconverter: OutputStreamWriterFileInputStreamFileReaderFileOutputStreamFileWriterStringBufferInputStreamStringReader(no corresponding class)StringWriterByteArrayInputStreamCharArrayReaderByteArrayOutputStreamCharArrayWriterPipedInputStreamPipedReaderPipedOutputStreamPipedWriter我们发现即使不完全一致,但旧库组件中的接口与新接口通常也是类似的。10.7.2 修改数据流的行为45110.7 Java 1.1的IO流在Java 1.0中,数据流通过FilterInputStream和FilterOutputStream的“装饰器”(Decorator)子类适应特定的需求。Java 1.1的IO流沿用了这一思想,但没有继续采用所有装饰器都从相同“filter”(过滤器)基础类中衍生这一做法。若通过观察类的层次结构来理解它,这可能令人出现少许的困惑。在下面这张表格中,对应关系比上一张表要粗糙一些。之所以会出现这个差别,是由类的组织造成的:尽管BufferedOutputStream是FilterOutputStream的一个子类,但是BufferedWriter并不是FilterWriter的子类(对后者来说,尽管它是一个抽象类,但没有自己的子类或者近似子类的东西,也没有一个“占位符”可用,所以不必费心地寻找)。然而,两个类的接口是非常相似的,而且不管在什么情况下,显然应该尽可能地使用新版本,而不应考虑旧版本(也就是说,除非在一些类中必须生成一个Stream,不可生成Reader或者Writer)。45210.7 Java 1.1的IO流Filters:Java 1.0 classCorresponding Java 1.1 classFilterInputStreamFilterReaderFilterOutputStreamFilterWriter (abstract class with no subclasses)BufferedInputStreamBufferedReader(also has readLine( ))BufferedOutputStreamBufferedWriterDataInputStreamuse DataInputStream(Except when you need to use readLine( ), when you should use a BufferedReader)PrintStreamPrintWriterLineNumberInputStreamLineNumberReaderStreamTokenizerStreamTokenizer(use constructor that takes a Reader instead)PushBackInputStreamPushBackReader过滤器:Java 1.0类 对应的Java 1.1类45310.7 Java 1.1的IO流FilterInputStream FilterReaderFilterOutputStream FilterWriter(没有子类的抽象类)BufferedInputStream BufferedReader(也有readLine())BufferedOutputStream BufferedWriterDataInputStream 使用DataInputStream(除非要使用readLine(),那时需要使用一个BufferedReader)PrintStream PrintWriterLineNumberInputStream LineNumberReaderStreamTokenizer StreamTokenizer(用构建器取代Reader)PushBackInputStream PushBackReader有一条规律是显然的:若想使用readLine(),就不要再用一个DataInputStream来实现(否则会在编译期得到一条出错消息),而应使用一个BufferedReader。但除这种情况以外,DataInputStream仍是Java 1.1 IO库的“首选”成员。为了将向PrintWriter的过渡变得更加自然,它提供了能采用任何OutputStream对象的构建器。PrintWriter提供的格式化支持没有PrintStream那么多;但接口几乎是相同的。10.7.3 未改变的类显然,Java库的设计人员觉得以前的一些类毫无问题,所以没有对它们作任何修改,可象以前那样继续使用它们:没有对应Java 1.1类的Java 1.0类DataOutputStreamFileRandomAccessFileSequenceInputStream特别未加改动的是DataOutputStream,所以为了用一种可转移的格式保存和获取数据,必须沿用InputStream和OutputStream层次结构。10.7.4 一个例子为体验新类的效果,下面让我们看看如何修改IOStreamDemo.java示例的相应区域,以便使用Reader和Writer类://: NewIODemo.java// Java 1.1 IO typical usageimport java.io.*;public class NewIODemo {public static void main(String[] args) {try {// 1. Reading input by lines:BufferedReader in =new BufferedReader(new FileReader(args[0]));45410.7 Java 1.1的IO流String s, s2 = new String();while((s = in.readLine())!= null)s2 += s + "\n";in.close();// 1b. Reading standard input:BufferedReader stdin =new BufferedReader(new InputStreamReader(System.in));System.out.print("Enter a line:");System.out.println(stdin.readLine());// 2. Input from memoryStringReader in2 = new StringReader(s2);int c;while((c = in2.read()) != -1)System.out.print((char)c);// 3. Formatted memory inputtry {DataInputStream in3 =new DataInputStream(// Oops: must use deprecated class:new StringBufferInputStream(s2));while(true)System.out.print((char)in3.readByte());} catch(EOFException e) {System.out.println("End of stream");}// 4. Line numbering & file outputtry {LineNumberReader li =new LineNumberReader(new StringReader(s2));BufferedReader in4 =new BufferedReader(li);PrintWriter out1 =new PrintWriter(new BufferedWriter(new FileWriter("IODemo.out")));while((s = in4.readLine()) != null )out1.println("Line " + li.getLineNumber() + s);out1.close();} catch(EOFException e) {System.out.println("End of stream");}// 5. Storing & recovering datatry {DataOutputStream out2 =new DataOutputStream(45510.7 Java 1.1的IO流new BufferedOutputStream(new FileOutputStream("Data.txt")));out2.writeDouble(3.14159);out2.writeBytes("That was pi");out2.close();DataInputStream in5 =new DataInputStream(new BufferedInputStream(new FileInputStream("Data.txt")));BufferedReader in5br =new BufferedReader(new InputStreamReader(in5));// Must use DataInputStream for data:System.out.println(in5.readDouble());// Can now use the "proper" readLine():System.out.println(in5br.readLine());} catch(EOFException e) {System.out.println("End of stream");}// 6. Reading and writing random access// files is the same as before.// (not repeated here)} catch(FileNotFoundException e) {System.out.println("File Not Found:" + args[1]);} catch(IOException e) {System.out.println("IO Exception");}}} ///:~大家一般看见的是转换过程非常直观,代码看起来也颇相似。但这些都不是重要的区别。最重要的是,由于随机访问文件已经改变,所以第6节未再重复。第1节收缩了一点儿,因为假如要做的全部事情就是读取行输入,那么只需要将一个FileReader封装到BufferedReader之内即可。第1b节展示了封装System.in,以便读取控制台输入的新方法。这里的代码量增多了一些,因为System.in是一个DataInputStream,而且BufferedReader需要一个Reader参数,所以要用InputStreamReader来进行转换。在2节,可以看到如果有一个字串,而且想从中读取数据,只需用一个StringReader替换StringBufferInputStream,剩下的代码是完全相同的。45610.7 Java 1.1的IO流第3节揭示了新IO流库设计中的一个错误。如果有一个字串,而且想从中读取数据,那么不能再以任何形式使用StringBufferInputStream。若编译一个涉及StringBufferInputStream的代码,会得到一条“反对”消息,告诉我们不要用它。此时最好换用一个StringReader。但是,假如要象第3节这样进行格式化的内存输入,就必须使用DataInputStream——没有什么“DataReader”可以代替它——而DataInputStream很不幸地要求用到一个InputStream参数。所以我们没有选择的余地,只好使用编译器不赞成的StringBufferInputStream类。编译器同样会发出反对信息,但我们对此束手无策(注释②)。StringReader替换StringBufferInputStream,剩下的代码是完全相同的。②:到你现在正式使用的时候,这个错误可能已经修正。第4节明显是从老式数据流到新数据流的一个直接转换,没有需要特别指出的。在第5节中,我们被强迫使用所有的老式数据流,因为DataOutputStream和DataInputStream要求用到它们,而且没有可供替换的东西。然而,编译期间不会产生任何“反对”信息。若不赞成一种数据流,通常是由于它的构建器产生了一条反对消息,禁止我们使用整个类。但在DataInputStream的情况下,只有readLine()是不赞成使用的,因为我们最好为readLine()使用一个BufferedReader(但为其他所有格式化输入都使用一个DataInputStream)。若比较第5节和IOStreamDemo.java中的那一小节,会注意到在这个版本中,数据是在文本之前写入的。那是由于Java 1.1本身存在一个错误,如下述代码所示://: IOBug.java // Java 1.1 (and higher?) IO Bug import java.io.*;public class IOBug { public static void main(String[] args) throws Exception {DataOutputStream out = new DataOutputStream( new BufferedOutputStream( newFileOutputStream("Data.txt"))); out.writeDouble(3.14159); out.writeBytes("That was thevalue of pi\n"); out.writeBytes("This is pi/2:\n"); out.writeDouble(3.14159/2); out.close();DataInputStream in =new DataInputStream(new BufferedInputStream(new FileInputStream("Data.txt")));BufferedReader inbr =new BufferedReader(new InputStreamReader(in));// The doubles written BEFORE the line of text// read back correctly:System.out.println(in.readDouble());// Read the lines of text:System.out.println(inbr.readLine());System.out.println(inbr.readLine());// Trying to read the doubles after the line// produces an end-of-file exception:System.out.println(in.readDouble());} } ///:~45710.7 Java 1.1的IO流看起来,我们在对一个writeBytes()的调用之后写入的任何东西都不是能够恢复的。这是一个十分有限的错误,希望在你读到本书的时候已获得改正。为检测是否改正,请运行上述程序。若没有得到一个违例,而且值都能正确打印出来,就表明已经改正。10.7.5 重导向标准IOJava 1.1在System类中添加了特殊的方法,允许我们重新定向标准输入、输出以及错误IO流。此时要用到下述简单的静态方法调用:setIn(InputStream) setOut(PrintStream) setErr(PrintStream)如果突然要在屏幕上生成大量输出,而且滚动的速度快于人们的阅读速度,输出的重定向就显得特别有用。在一个命令行程序中,如果想重复测试一个特定的用户输入序列,输入的重定向也显得特别有价值。下面这个简单的例子展示了这些方法的使用://: Redirecting.java // Demonstrates the use of redirection for // standard IO in Java 1.1import java.io.*;class Redirecting { public static void main(String[] args) { try { BufferedInputStream in = newBufferedInputStream( new FileInputStream( "Redirecting.java")); // Produces deprecationmessage: PrintStream out = new PrintStream( new BufferedOutputStream( newFileOutputStream("test.out"))); System.setIn(in); System.setOut(out); System.setErr(out);BufferedReader br =new BufferedReader(new InputStreamReader(System.in));String s;while((s = br.readLine()) != null)System.out.println(s);out.close(); // Remember this!} catch(IOException e) {e.printStackTrace();}} } ///:~```这个程序的作用是将标准输入同一个文件连接起来,并将标准输出和错误重定向至另一个文件。 这是不可避免会遇到“反对”消息的另一个例子。用-deprecation标志编译时得到的消息如下:Note:The constructor java.io.PrintStream(java.io.OutputStream) has been deprecated.注意:不推荐使用构建器java.io.PrintStream(java.io.OutputStream)。45810.7 Java 1.1的IO流然而,无论System.setOut()还是System.setErr()都要求用一个PrintStream作为参数使用,所以必须调用PrintStream构建器。所以大家可能会觉得奇怪,既然Java 1.1通过反对构建器而反对了整个PrintStream,为什么库的设计人员在添加这个反对的同时,依然为System添加了新方法,且指明要求用PrintStream,而不是用PrintWriter呢?毕竟,后者是一个崭新和首选的替换措施呀?这真令人费解。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:1045910.8 压缩10.8 压缩Java 1.1也添加一个类,用以支持对压缩格式的数据流的读写。它们封装到现成的IO类中,以提供压缩功能。此时Java 1.1的一个问题显得非常突出:它们不是从新的Reader和Writer类衍生出来的,而是属于InputStream和OutputStream层次结构的一部分。所以有时不得不混合使用两种类型的数据流(注意可用InputStreamReader和OutputStreamWriter在不同的类型间方便地进行转换)。Java 1.1压缩类 功能CheckedInputStream GetCheckSum()为任何InputStream产生校验和(不仅是解压)CheckedOutputStream GetCheckSum()为任何OutputStream产生校验和(不仅是解压)DeflaterOutputStream 用于压缩类的基础类ZipOutputStream 一个DeflaterOutputStream,将数据压缩成Zip文件格式GZIPOutputStream 一个DeflaterOutputStream,将数据压缩成GZIP文件格式InflaterInputStream 用于解压类的基础类ZipInputStream 一个DeflaterInputStream,解压用Zip文件格式保存的数据GZIPInputStream 一个DeflaterInputStream,解压用GZIP文件格式保存的数据尽管存在许多种压缩算法,但是Zip和GZIP可能最常用的。所以能够很方便地用多种现成的工具来读写这些格式的压缩数据。10.8.1 用GZIP进行简单压缩GZIP接口非常简单,所以如果只有单个数据流需要压缩(而不是一系列不同的数据),那么它就可能是最适当选择。下面是对单个文件进行压缩的例子:46010.8 压缩//: GZIPcompress.java// Uses Java 1.1 GZIP compression to compress// a file whose name is passed on the command// line.import java.io.*;import java.util.zip.*;public class GZIPcompress {public static void main(String[] args) {try {BufferedReader in =new BufferedReader(new FileReader(args[0]));BufferedOutputStream out =new BufferedOutputStream(new GZIPOutputStream(new FileOutputStream("test.gz")));System.out.println("Writing file");int c;while((c = in.read()) != -1)out.write(c);in.close();out.close();System.out.println("Reading file");BufferedReader in2 =new BufferedReader(new InputStreamReader(new GZIPInputStream(new FileInputStream("test.gz"))));String s;while((s = in2.readLine()) != null)System.out.println(s);} catch(Exception e) {e.printStackTrace();}}} ///:~压缩类的用法非常直观——只需将输出流封装到一个GZIPOutputStream或者ZipOutputStream内,并将输入流封装到GZIPInputStream或者ZipInputStream内即可。剩余的全部操作就是标准的IO读写。然而,这是一个很典型的例子,我们不得不混合使用新旧IO流:数据的输入使用Reader类,而GZIPOutputStream的构建器只能接收一个OutputStream对象,不能接收Writer对象。10.8.2 用Zip进行多文件保存提供了Zip支持的Java 1.1库显得更加全面。利用它可以方便地保存多个文件。甚至有一个独立的类来简化对Zip文件的读操作。这个库采采用的是标准Zip格式,所以能与当前因特网上使用的大量压缩、解压工具很好地协作。下面这个例子采取了与前例相同的形式,但能根据我46110.8 压缩们需要控制任意数量的命令行参数。除此之外,它展示了如何用Checksum类来计算和校验文件的“校验和”(Checksum)。可选用两种类型的Checksum:Adler32(速度要快一些)和CRC32(慢一些,但更准确)。//: ZipCompress.java// Uses Java 1.1 Zip compression to compress// any number of files whose names are passed// on the command line.import java.io.*;import java.util.*;import java.util.zip.*;public class ZipCompress {public static void main(String[] args) {try {FileOutputStream f =new FileOutputStream("test.zip");CheckedOutputStream csum =new CheckedOutputStream(f, new Adler32());ZipOutputStream out =new ZipOutputStream(new BufferedOutputStream(csum));out.setComment("A test of Java Zipping");// Can't read the above comment, thoughfor(int i = 0; i 0)next = new Worm(i, (char)(x + 1));}Worm() {System.out.println("Default constructor");}public String toString() {String s = ":" + c + "(";for(int i = 0; i < d.length; i++)s += d[i].toString();s += ")";if(next != null)s += next.toString();return s;}public static void main(String[] args) {Worm w = new Worm(6, 'a');System.out.println("w = " + w);try {ObjectOutputStream out =new ObjectOutputStream(new FileOutputStream("worm.out"));46710.9 对象序列化out.writeObject("Worm storage");out.writeObject(w);out.close(); // Also flushes outputObjectInputStream in =new ObjectInputStream(new FileInputStream("worm.out"));String s = (String)in.readObject();Worm w2 = (Worm)in.readObject();System.out.println(s + ", w2 = " + w2);} catch(Exception e) {e.printStackTrace();}try {ByteArrayOutputStream bout =new ByteArrayOutputStream();ObjectOutputStream out =new ObjectOutputStream(bout);out.writeObject("Worm storage");out.writeObject(w);out.flush();ObjectInputStream in =new ObjectInputStream(new ByteArrayInputStream(bout.toByteArray()));String s = (String)in.readObject();Worm w3 = (Worm)in.readObject();System.out.println(s + ", w3 = " + w3);} catch(Exception e) {e.printStackTrace();}}} ///:~更有趣的是,Worm内的Data对象数组是用随机数字初始化的(这样便不用怀疑编译器保留了某种原始信息)。每个Worm段都用一个Char标记。这个Char是在重复生成链接的Worm列表时自动产生的。创建一个Worm时,需告诉构建器希望它有多长。为产生下一个句柄(next),它总是用减去1的长度来调用Worm构建器。最后一个next句柄则保持为null(空),表示已抵达Worm的尾部。 上面的所有操作都是为了加深事情的复杂程度,加大对象序列化的难度。然而,真正的序列化过程却是非常简单的。一旦从另外某个流里创建了ObjectOutputStream,writeObject()就会序列化对象。注意也可以为一个String调用writeObject()。亦可使用与DataOutputStream相同的方法写入所有基本数据类型(它们有相同的接口)。有两个单独的try块看起来是类似的。第一个读写的是文件,而另一个读写的是一个ByteArray(字节数组)。可利用对任何DataInputStream或者DataOutputStream的序列化来读写特定的对象;正如在关于连网的那一章会讲到的那样,这些对象甚至包括网络。一次循环后的输出结果如下:46810.9 对象序列化Worm constructor: 6Worm constructor: 5Worm constructor: 4Worm constructor: 3Worm constructor: 2Worm constructor: 1w = :a(262):b(100):c(396):d(480):e(316):f(398)Worm storage, w2 = :a(262):b(100):c(396):d(480):e(316):f(398)Worm storage, w3 = :a(262):b(100):c(396):d(480):e(316):f(398)可以看出,装配回原状的对象确实包含了原来那个对象里包含的所有链接。注意在对一个Serializable(可序列化)对象进行重新装配的过程中,不会调用任何构建器(甚至默认构建器)。整个对象都是通过从InputStream中取得数据恢复的。作为Java 1.1特性的一种,我们注意到对象的序列化并不属于新的Reader和Writer层次结构的一部分,而是沿用老式的InputStream和OutputStream结构。所以在一些特殊的场合下,不得不混合使用两种类型的层次结构。10.9.1 寻找类读者或许会奇怪为什么需要一个对象从它的序列化状态中恢复。举个例子来说,假定我们序列化一个对象,并通过网络将其作为文件传送给另一台机器。此时,位于另一台机器的程序可以只用文件目录来重新构造这个对象吗? 回答这个问题的最好方法就是做一个实验。下面这个文件位于本章的子目录下://: Alien.java// A serializable classimport java.io.*;public class Alien implements Serializable {} ///:~用于创建和序列化一个Alien对象的文件位于相同的目录下:46910.9 对象序列化//: FreezeAlien.java// Create a serialized output fileimport java.io.*;public class FreezeAlien {public static void main(String[] args)throws Exception {ObjectOutput out =new ObjectOutputStream(new FileOutputStream("file.x"));Alien zorcon = new Alien();out.writeObject(zorcon);}} ///:~该程序并不是捕获和控制违例,而是将违例简单、直接地传递到main()外部,这样便能在命令行报告它们。 程序编译并运行后,将结果产生的file.x复制到名为xfiles的子目录,代码如下://: ThawAlien.java// Try to recover a serialized file without the// class of object that's stored in that file.package c10.xfiles;import java.io.*;public class ThawAlien {public static void main(String[] args)throws Exception {ObjectInputStream in =new ObjectInputStream(new FileInputStream("file.x"));Object mystery = in.readObject();System.out.println(mystery.getClass().toString());}} ///:~该程序能打开文件,并成功读取mystery对象中的内容。然而,一旦尝试查找与对象有关的任何资料——这要求Alien的Class对象——Java虚拟机(JVM)便找不到Alien.class(除非它正好在类路径内,而本例理应相反)。这样就会得到一个名叫ClassNotFoundException的违例(同样地,若非能够校验Alien存在的证据,否则它等于消失)。恢复了一个序列化的对象后,如果想对其做更多的事情,必须保证JVM能在本地类路径或者因特网的其他什么地方找到相关的.class文件。10.9.2 序列化的控制47010.9 对象序列化正如大家看到的那样,默认的序列化机制并不难操纵。然而,假若有特殊要求又该怎么办呢?我们可能有特殊的安全问题,不希望对象的某一部分序列化;或者某一个子对象完全不必序列化,因为对象恢复以后,那一部分需要重新创建。此时,通过实现Externalizable接口,用它代替Serializable接口,便可控制序列化的具体过程。这个Externalizable接口扩展了Serializable,并增添了两个方法:writeExternal()和readExternal()。在序列化和重新装配的过程中,会自动调用这两个方法,以便我们执行一些特殊操作。下面这个例子展示了Externalizable接口方法的简单应用。注意Blip1和Blip2几乎完全一致,除了极微小的差别(自己研究一下代码,看看是否能发现)://: Blips.java// Simple use of Externalizable & a pitfallimport java.io.*;import java.util.*;class Blip1 implements Externalizable {public Blip1() {System.out.println("Blip1 Constructor");}public void writeExternal(ObjectOutput out)throws IOException {System.out.println("Blip1.writeExternal");}public void readExternal(ObjectInput in)throws IOException, ClassNotFoundException {System.out.println("Blip1.readExternal");}}class Blip2 implements Externalizable {Blip2() {System.out.println("Blip2 Constructor");}public void writeExternal(ObjectOutput out)throws IOException {System.out.println("Blip2.writeExternal");}public void readExternal(ObjectInput in)throws IOException, ClassNotFoundException {System.out.println("Blip2.readExternal");}}public class Blips {public static void main(String[] args) {System.out.println("Constructing objects:");Blip1 b1 = new Blip1();Blip2 b2 = new Blip2();47110.9 对象序列化try {ObjectOutputStream o =new ObjectOutputStream(new FileOutputStream("Blips.out"));System.out.println("Saving objects:");o.writeObject(b1);o.writeObject(b2);o.close();// Now get them back:ObjectInputStream in =new ObjectInputStream(new FileInputStream("Blips.out"));System.out.println("Recovering b1:");b1 = (Blip1)in.readObject();// OOPS! Throws an exception://!System.out.println("Recovering b2:");//!b2 = (Blip2)in.readObject();} catch(Exception e) {e.printStackTrace();}}} ///:~该程序输出如下:Constructing objects:Blip1 ConstructorBlip2 ConstructorSaving objects:Blip1.writeExternalBlip2.writeExternalRecovering b1:Blip1 ConstructorBlip1.readExternal未恢复Blip2对象的原因是那样做会导致一个违例。你找出了Blip1和Blip2之间的区别吗?Blip1的构建器是“公共的”(public),Blip2的构建器则不然,这样便会在恢复时造成违例。试试将Blip2的构建器属性变成“public”,然后删除//!注释标记,看看是否能得到正确的结果。恢复b1后,会调用Blip1默认构建器。这与恢复一个Serializable(可序列化)对象不同。在后者的情况下,对象完全以它保存下来的二进制位为基础恢复,不存在构建器调用。而对一个Externalizable对象,所有普通的默认构建行为都会发生(包括在字段定义时的初始化),而且会调用readExternal()。必须注意这一事实——特别注意所有默认的构建行为都会进行——否则很难在自己的Externalizable对象中产生正确的行为。下面这个例子揭示了保存和恢复一个Externalizable对象必须做的全部事情://: Blip3.java47210.9 对象序列化// Reconstructing an externalizable objectimport java.io.*;import java.util.*;class Blip3 implements Externalizable {int i;String s; // No initializationpublic Blip3() {System.out.println("Blip3 Constructor");// s, i not initialized}public Blip3(String x, int a) {System.out.println("Blip3(String x, int a)");s = x;i = a;// s & i initialized only in non-default// constructor.}public String toString() { return s + i; }public void writeExternal(ObjectOutput out)throws IOException {System.out.println("Blip3.writeExternal");// You must do this:out.writeObject(s); out.writeInt(i);}public void readExternal(ObjectInput in)throws IOException, ClassNotFoundException {System.out.println("Blip3.readExternal");// You must do this:s = (String)in.readObject();i =in.readInt();}public static void main(String[] args) {System.out.println("Constructing objects:");Blip3 b3 = new Blip3("A String ", 47);System.out.println(b3.toString());try {ObjectOutputStream o =new ObjectOutputStream(new FileOutputStream("Blip3.out"));System.out.println("Saving object:");o.writeObject(b3);o.close();// Now get it back:ObjectInputStream in =new ObjectInputStream(new FileInputStream("Blip3.out"));System.out.println("Recovering b3:");b3 = (Blip3)in.readObject();System.out.println(b3.toString());} catch(Exception e) {e.printStackTrace();}47310.9 对象序列化}} ///:~其中,字段s和i只在第二个构建器中初始化,不关默认构建器的事。这意味着假如不在readExternal中初始化s和i,它们就会成为null(因为在对象创建的第一步中已将对象的存储空间清除为1)。若注释掉跟随于“You must do this”后面的两行代码,并运行程序,就会发现当对象恢复以后,s是null,而i是零。若从一个Externalizable对象继承,通常需要调用writeExternal()和readExternal()的基础类版本,以便正确地保存和恢复基础类组件。所以为了让一切正常运作起来,千万不可仅在writeExternal()方法执行期间写入对象的重要数据(没有默认的行为可用来为一个Externalizable对象写入所有成员对象)的,而是必须在readExternal()方法中也恢复那些数据。初次操作时可能会有些不习惯,因为Externalizable对象的默认构建行为使其看起来似乎正在进行某种存储与恢复操作。但实情并非如此。1. transient(临时)关键字控制序列化过程时,可能有一个特定的子对象不愿让Java的序列化机制自动保存与恢复。一般地,若那个子对象包含了不想序列化的敏感信息(如密码),就会面临这种情况。即使那种信息在对象中具有“private”(私有)属性,但一旦经序列化处理,人们就可以通过读取一个文件,或者拦截网络传输得到它。为防止对象的敏感部分被序列化,一个办法是将自己的类实现为Externalizable,就象前面展示的那样。这样一来,没有任何东西可以自动序列化,只能在writeExternal()明确序列化那些需要的部分。然而,若操作的是一个Serializable对象,所有序列化操作都会自动进行。为解决这个问题,可以用transient(临时)逐个字段地关闭序列化,它的意思是“不要麻烦你(指自动机制)保存或恢复它了——我会自己处理的”。例如,假设一个Login对象包含了与一个特定的登录会话有关的信息。校验登录的合法性时,一般都想将数据保存下来,但不包括密码。为做到这一点,最简单的办法是实现Serializable,并将password字段设为transient。下面是具体的代码:47410.9 对象序列化//: Logon.java// Demonstrates the "transient" keywordimport java.io.*;import java.util.*;class Logon implements Serializable {private Date date = new Date();private String username;private transient String password;Logon(String name, String pwd) {username = name;password = pwd;}public String toString() {String pwd =(password == null) ? "(n/a)" : password;return "logon info: \n" +"username: " + username +"\ndate: " + date.toString() +"\npassword: " + pwd;}public static void main(String[] args) {Logon a = new Logon("Hulk", "myLittlePony");System.out.println( "logon a = " + a);try {ObjectOutputStream o =new ObjectOutputStream(new FileOutputStream("Logon.out"));o.writeObject(a);o.close();// Delay:int seconds = 5;long t = System.currentTimeMillis()+ seconds * 1000;while(System.currentTimeMillis() < t);// Now get them back:ObjectInputStream in =new ObjectInputStream(new FileInputStream("Logon.out"));System.out.println("Recovering object at " + new Date());a = (Logon)in.readObject();System.out.println( "logon a = " + a);} catch(Exception e) {e.printStackTrace();}}} ///:~47510.9 对象序列化可以看到,其中的date和username字段保持原始状态(未设成transient),所以会自动序列化。然而,password被设为transient,所以不会自动保存到磁盘;另外,自动序列化机制也不会作恢复它的尝试。输出如下:logon a = logon info:username: Hulkdate: Sun Mar 23 18:25:53 PST 1997password: myLittlePonyRecovering object at Sun Mar 23 18:25:59 PST 1997logon a = logon info:username: Hulkdate: Sun Mar 23 18:25:53 PST 1997password: (n/a)一旦对象恢复成原来的样子,password字段就会变成null。注意必须用toString()检查password是否为null,因为若用过载的“+”运算符来装配一个String对象,而且那个运算符遇到一个null句柄,就会造成一个名为NullPointerException的违例(新版Java可能会提供避免这个问题的代码)。我们也发现date字段被保存到磁盘,并从磁盘恢复,没有重新生成。由于Externalizable对象默认时不保存它的任何字段,所以transient关键字只能伴随Serializable使用。1. Externalizable的替代方法若不是特别在意要实现Externalizable接口,还有另一种方法可供选用。我们可以实现Serializable接口,并添加(注意是“添加”,而非“覆盖”或者“实现”)名为writeObject()和readObject()的方法。一旦对象被序列化或者重新装配,就会分别调用那两个方法。也就是说,只要提供了这两个方法,就会优先使用它们,而不考虑默认的序列化机制。 这些方法必须含有下列准确的签名:private voidwriteObject(ObjectOutputStream stream)throws IOException;private voidreadObject(ObjectInputStream stream)throws IOException, ClassNotFoundException从设计的角度出发,情况变得有些扑朔迷离。首先,大家可能认为这些方法不属于基础类或者Serializable接口的一部分,它们应该在自己的接口中得到定义。但请注意它们被定义成“private”,这意味着它们只能由这个类的其他成员调用。然而,我们实际并不从这个类的其他成员中调用它们,而是由ObjectOutputStream和ObjectInputStream的writeObject()及readObject()方法来调用我们对象的writeObject()和readObject()方法(注意我在这里用了很大47610.9 对象序列化的抑制力来避免使用相同的方法名——因为怕混淆)。大家可能奇怪ObjectOutputStream和ObjectInputStream如何有权访问我们的类的private方法——只能认为这是序列化机制玩的一个把戏。在任何情况下,接口中的定义的任何东西都会自动具有public属性,所以假若writeObject()和readObject()必须为private,那么它们不能成为接口(interface)的一部分。但由于我们准确地加上了签名,所以最终的效果实际与实现一个接口是相同的。看起来似乎我们调用ObjectOutputStream.writeObject()的时候,我们传递给它的Serializable对象似乎会被检查是否实现了自己的writeObject()。若答案是肯定的是,便会跳过常规的序列化过程,并调用writeObject()。readObject()也会遇到同样的情况。还存在另一个问题。在我们的writeObject()内部,可以调用defaultWriteObject(),从而决定采取默认的writeObject()行动。类似地,在readObject()内部,可以调用defaultReadObject()。下面这个简单的例子演示了如何对一个Serializable对象的存储与恢复进行控制:47710.9 对象序列化//: SerialCtl.java// Controlling serialization by adding your own// writeObject() and readObject() methods.import java.io.*;public class SerialCtl implements Serializable {String a;transient String b;public SerialCtl(String aa, String bb) {a = "Not Transient: " + aa;b = "Transient: " + bb;}public String toString() {return a + "\n" + b;}private voidwriteObject(ObjectOutputStream stream)throws IOException {stream.defaultWriteObject();stream.writeObject(b);}private voidreadObject(ObjectInputStream stream)throws IOException, ClassNotFoundException {stream.defaultReadObject();b = (String)stream.readObject();}public static void main(String[] args) {SerialCtl sc =new SerialCtl("Test1", "Test2");System.out.println("Before:\n" + sc);ByteArrayOutputStream buf =new ByteArrayOutputStream();try {ObjectOutputStream o =new ObjectOutputStream(buf);o.writeObject(sc);// Now get it back:ObjectInputStream in =new ObjectInputStream(new ByteArrayInputStream(buf.toByteArray()));SerialCtl sc2 = (SerialCtl)in.readObject();System.out.println("After:\n" + sc2);} catch(Exception e) {e.printStackTrace();}}} ///:~47810.9 对象序列化在这个例子中,一个String保持原始状态,其他设为transient(临时),以便证明非临时字段会被defaultWriteObject()方法自动保存,而transient字段必须在程序中明确保存和恢复。字段是在构建器内部初始化的,而不是在定义的时候,这证明了它们不会在重新装配的时候被某些自动化机制初始化。若准备通过默认机制写入对象的非transient部分,那么必须调用defaultWriteObject(),令其作为writeObject()中的第一个操作;并调用defaultReadObject(),令其作为readObject()的第一个操作。这些都是不常见的调用方法。举个例子来说,当我们为一个ObjectOutputStream调用defaultWriteObject()的时候,而且没有为其传递参数,就需要采取这种操作,使其知道对象的句柄以及如何写入所有非transient的部分。这种做法非常不便。transient对象的存储与恢复采用了我们更熟悉的代码。现在考虑一下会发生一些什么事情。在main()中会创建一个SerialCtl对象,随后会序列化到一个ObjectOutputStream里(注意这种情况下使用的是一个缓冲区,而非文件——与ObjectOutputStream完全一致)。正式的序列化操作是在下面这行代码里发生的:o.writeObject(sc);其中,writeObject()方法必须核查sc,判断它是否有自己的writeObject()方法(不是检查它的接口——它根本就没有,也不是检查类的类型,而是利用反射方法实际搜索方法)。若答案是肯定的,就使用那个方法。类似的情况也会在readObject()上发生。或许这是解决问题唯一实际的方法,但确实显得有些古怪。1. 版本问题有时候可能想改变一个可序列化的类的版本(比如原始类的对象可能保存在数据库中)。尽管这种做法得到了支持,但一般只应在非常特殊的情况下才用它。此外,它要求操作者对背后的原理有一个比较深的认识,而我们在这里还不想达到这种深度。JDK 1.1的HTML文档对这一主题进行了非常全面的论述(可从Sun公司下载,但可能也成了Java开发包联机文档的一部分)。10.9.3 利用“持久性”一个比较诱人的想法是用序列化技术保存程序的一些状态信息,从而将程序方便地恢复到以前的状态。但在具体实现以前,有些问题是必须解决的。如果两个对象都有指向第三个对象的句柄,该如何对这两个对象序列化呢?如果从两个对象序列化后的状态恢复它们,第三个对象的句柄只会出现在一个对象身上吗?如果将这两个对象序列化成独立的文件,然后在代码的不同部分重新装配它们,又会得到什么结果呢?下面这个例子对上述问题进行了很好的说明://: MyWorld.javaimport java.io.*;import java.util.*;47910.9 对象序列化class House implements Serializable {}class Animal implements Serializable {String name;House preferredHouse;Animal(String nm, House h) {name = nm;preferredHouse = h;}public String toString() {return name + "[" + super.toString() +"], " + preferredHouse + "\n";}}public class MyWorld {public static void main(String[] args) {House house = new House();Vectoranimals = new Vector();animals.addElement(new Animal("Bosco the dog", house));animals.addElement(new Animal("Ralph the hamster", house));animals.addElement(new Animal("Fronk the cat", house));System.out.println("animals: " + animals);try {ByteArrayOutputStream buf1 =new ByteArrayOutputStream();ObjectOutputStream o1 =new ObjectOutputStream(buf1);o1.writeObject(animals);o1.writeObject(animals); // Write a 2nd set// Write to a different stream:ByteArrayOutputStream buf2 =new ByteArrayOutputStream();ObjectOutputStream o2 =new ObjectOutputStream(buf2);o2.writeObject(animals);// Now get them back:ObjectInputStream in1 =new ObjectInputStream(new ByteArrayInputStream(buf1.toByteArray()));ObjectInputStream in2 =new ObjectInputStream(new ByteArrayInputStream(buf2.toByteArray()));Vector animals1 = (Vector)in1.readObject();Vector animals2 = (Vector)in1.readObject();Vector animals3 = (Vector)in2.readObject();48010.9 对象序列化System.out.println("animals1: " + animals1);System.out.println("animals2: " + animals2);System.out.println("animals3: " + animals3);} catch(Exception e) {e.printStackTrace();}}} ///:~这里一件有趣的事情是也许是能针对一个字节数组应用对象的序列化,从而实现对任何Serializable(可序列化)对象的一个“全面复制”(全面复制意味着复制的是整个对象网,而不仅是基本对象和它的句柄)。复制问题将在第12章进行全面讲述。Animal对象包含了类型为House的字段。在main()中,会创建这些Animal的一个Vector,并对其序列化两次,分别送入两个不同的数据流内。这些数据重新装配并打印出来后,可看到下面这样的结果(对象在每次运行时都会处在不同的内存位置,所以每次运行的结果有区别):animals: [Bosco the dog[Animal@1cc76c], House@1cc769, Ralph the hamster[Animal@1cc76d], House@1cc769, Fronk the cat[Animal@1cc76e], House@1cc769]animals1: [Bosco the dog[Animal@1cca0c], House@1cca16, Ralph the hamster[Animal@1cca17], House@1cca16, Fronk the cat[Animal@1cca1b], House@1cca16]animals2: [Bosco the dog[Animal@1cca0c], House@1cca16, Ralph the hamster[Animal@1cca17], House@1cca16, Fronk the cat[Animal@1cca1b], House@1cca16]animals3: [Bosco the dog[Animal@1cca52], House@1cca5c, Ralph the hamster[Animal@1cca5d], House@1cca5c, Fronk the cat[Animal@1cca61], House@1cca5c]当然,我们希望装配好的对象有与原来不同的地址。但注意在animals1和animals2中出现了相同的地址,其中包括共享的、对House对象的引用。在另一方面,当animals3恢复以后,系统没有办法知道另一个流内的对象是第一个流内对象的化身,所以会产生一个完全不同的对象网。只要将所有东西都序列化到单独一个数据流里,就能恢复获得与以前写入时完全一样的对象网,不会不慎造成对象的重复。当然,在写第一个和最后一个对象的时间之间,可改变对象的状态,但那必须由我们明确采取操作——序列化时,对象会采用它们当时的任何状态(包括它们与其他对象的连接关系)写入。48110.9 对象序列化若想保存系统状态,最安全的做法是当作一种“微观”操作序列化。如果序列化了某些东西,再去做其他一些工作,再来序列化更多的东西,以此类推,那么最终将无法安全地保存系统状态。相反,应将构成系统状态的所有对象都置入单个集合内,并在一次操作里完成那个集合的写入。这样一来,同样只需一次方法调用,即可成功恢复之。下面这个例子是一套假想的计算机辅助设计(CAD)系统,对这一方法进行了很好的演示。此外,它还为我们引入了static字段的问题——如留意联机文档,就会发现Class是“Serializable”(可序列化)的,所以只需简单地序列化Class对象,就能实现static字段的保存。这无论如何都是一种明智的做法。//: CADState.java// Saving and restoring the state of a// pretend CAD system.import java.io.*;import java.util.*;abstract class Shape implements Serializable {public static final intRED = 1, BLUE = 2, GREEN = 3;private int xPos, yPos, dimension;private static Random r = new Random();private static int counter = 0;abstract public void setColor(int newColor);abstract public int getColor();public Shape(int xVal, int yVal, int dim) {xPos = xVal;yPos = yVal;dimension = dim;}public String toString() {return getClass().toString() +" color[" + getColor() +"] xPos[" + xPos +"] yPos[" + yPos +"] dim[" + dimension + "]\n";}public static Shape randomFactory() {int xVal = r.nextInt() % 100;int yVal = r.nextInt() % 100;int dim = r.nextInt() % 100;switch(counter++ % 3) {default:case 0: return new Circle(xVal, yVal, dim);case 1: return new Square(xVal, yVal, dim);case 2: return new Line(xVal, yVal, dim);}}}class Circle extends Shape {48210.9 对象序列化private static int color = RED;public Circle(int xVal, int yVal, int dim) {super(xVal, yVal, dim);}public void setColor(int newColor) {color = newColor;}public int getColor() {return color;}}class Square extends Shape {private static int color;public Square(int xVal, int yVal, int dim) {super(xVal, yVal, dim);color = RED;}public void setColor(int newColor) {color = newColor;}public int getColor() {return color;}}class Line extends Shape {private static int color = RED;public static voidserializeStaticState(ObjectOutputStream os)throws IOException {os.writeInt(color);}public static voiddeserializeStaticState(ObjectInputStream os)throws IOException {color = os.readInt();}public Line(int xVal, int yVal, int dim) {super(xVal, yVal, dim);}public void setColor(int newColor) {color = newColor;}public int getColor() {return color;}}public class CADState {public static void main(String[] args)throws Exception {Vector shapeTypes, shapes;48310.9 对象序列化if(args.length == 0) {shapeTypes = new Vector();shapes = new Vector();// Add handles to the class objects:shapeTypes.addElement(Circle.class);shapeTypes.addElement(Square.class);shapeTypes.addElement(Line.class);// Make some shapes:for(int i = 0; i < 10; i++)shapes.addElement(Shape.randomFactory());// Set all the static colors to GREEN:for(int i = 0; i java CADState[class Circle color[3] xPos[-51] yPos[-99] dim[38], class Square color[3] xPos[2] yPos[61] dim[-46], class Line color[3] xPos[51] yPos[73] dim[64], class Circle color[3] xPos[-70] yPos[1] dim[16], class Square color[3] xPos[3] yPos[94] dim[-36], class Line color[3] xPos[-84] yPos[-21] dim[-35], class Circle color[3] xPos[-75] yPos[-43] dim[22], class Square color[3] xPos[81] yPos[30] dim[-45], class Line color[3] xPos[-29] yPos[92] dim[17], class Circle color[3] xPos[17] yPos[90] dim[-76]]>java CADState CADState.out[class Circle color[1] xPos[-51] yPos[-99] dim[38], class Square color[0] xPos[2] yPos[61] dim[-46], class Line color[3] xPos[51] yPos[73] dim[64], class Circle color[1] xPos[-70] yPos[1] dim[16], class Square color[0] xPos[3] yPos[94] dim[-36], class Line color[3] xPos[-84] yPos[-21] dim[-35], class Circle color[1] xPos[-75] yPos[-43] dim[22], class Square color[0] xPos[81] yPos[30] dim[-45], class Line color[3] xPos[-29] yPos[92] dim[17], class Circle color[1] xPos[17] yPos[90] dim[-76]]从中可以看出,xPos,yPos以及dim的值都已成功保存和恢复出来。但在获取static信息时却出现了问题。所有“3”都已进入,但没有正常地出来。Circle有一个1值(定义为RED),而Square有一个0值(记住,它们是在构建器里初始化的)。看上去似乎static根本没有得到初始化!实情正是如此——尽管类Class是“可以序列化的”,但却不能按我们希望的工作。所以假如想序列化static值,必须亲自动手。这正是Line中的serializeStaticState()和deserializeStaticState()两个static方法的用途。可以看到,这两个方法都是作为存储和恢复进程的一部分明确调用的(注意写入序列化文件和从中读回的顺序不能改变)。所以为了使CADState.java正确运行起来,必须采用下述三种方法之一:(1) 为几何形状添加一个serializeStaticState()和deserializeStaticState()。(2) 删除Vector shapeTypes以及与之有关的所有代码(3) 在几何形状内添加对新序列化和撤消序列化静态方法的调用48510.9 对象序列化要注意的另一个问题是安全,因为序列化处理也会将private数据保存下来。若有需要保密的字段,应将其标记成transient。但在这之后,必须设计一种安全的信息保存方法。这样一来,一旦需要恢复,就可以重设那些private变量。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:1048610.10 总结10.10 总结Java IO流库能满足我们的许多基本要求:可以通过控制台、文件、内存块甚至因特网(参见第15章)进行读写。可以创建新的输入和输出对象类型(通过从InputStream和OutputStream继承)。向一个本来预期为收到字串的方法传递一个对象时,由于Java已限制了“自动类型转换”,所以会自动调用toString()方法。而我们可以重新定义这个toString(),扩展一个数据流能接纳的对象种类。在IO数据流库的联机文档和设计过程中,仍有些问题没有解决。比如当我们打开一个文件以便输出时,完全可以指定一旦有人试图覆盖该文件就“掷”出一个违例——有的编程系统允许我们自行指定想打开一个输出文件,但唯一的前提是它尚不存在。但在Java中,似乎必须用一个File对象来判断某个文件是否存在,因为假如将其作为FileOutputStream或者FileWriter打开,那么肯定会被覆盖。若同时指定文件和目录路径,File类设计上的一个缺陷就会暴露出来,因为它会说“不要试图在单个类里做太多的事情”! IO流库易使我们混淆一些概念。它确实能做许多事情,而且也可以移植。但假如假如事先没有吃透装饰器方案的概念,那么所有的设计都多少带有一点盲目性质。所以不管学它还是教它,都要特别花一些功夫才行。而且它并不完整:没有提供对输出格式化的支持,而其他几乎所有语言的IO包都提供了这方面的支持(这一点没有在Java 1.1里得以纠正,它完全错失了改变库设计方案的机会,反而增添了更特殊的一些情况,使复杂程度进一步提高)。Java 1.1转到那些尚未替换的IO库,而不是增加新库。而且库的设计人员似乎没有很好地指出哪些特性是不赞成的,哪些是首选的,造成库设计中经常都会出现一些令人恼火的反对消息。然而,一旦掌握了装饰器方案,并开始在一些较为灵活的环境使用库,就会认识到这种设计的好处。到那个时候,为此多付出的代码行应该不至于使你觉得太生气。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:1048710.11 练习10.11 练习(1) 打开一个文本文件,每次读取一行内容。将每行作为一个String读入,并将那个String对象置入一个Vector里。按相反的顺序打印出Vector中的所有行。(2) 修改练习1,使读取那个文件的名字作为一个命令行参数提供。(3) 修改练习2,又打开一个文本文件,以便将文字写入其中。将Vector中的行随同行号一起写入文件。(4) 修改练习2,强迫Vector中的所有行都变成大写形式,将结果发给System.out。(5) 修改练习2,在文件中查找指定的单词。打印出包含了欲找单词的所有文本行。(6) 在Blips.java中复制文件,将其重命名为BlipCheck.java。然后将类Blip2重命名为BlipCheck(在进程中将其标记为public)。删除文件中的//!记号,并执行程序。接下来,将BlipCheck的默认构建器变成注释信息。运行它,并解释为什么仍然能够工作。(7) 在Blip3.java中,将接在“You must do this:”字样后的两行变成注释,然后运行程序。解释得到的结果为什么会与执行了那两行代码不同。(8) 转换SortedWordCount.java程序,以便使用Java 1.1 IO流。(9) 根据本章正文的说明修改程序CADState.java。(10) 在第7章(中间部分)找到GreenhouseControls.java示例,它应该由三个文件构成。在GreenhouseControls.java中,Restart()内部类有一个硬编码的事件集。请修改这个程序,使其能从一个文本文件里动态读取事件以及它们的相关时间。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:10488第11章 运行期类型鉴定第11章 运行期类型鉴定运行期类型鉴定(RTTI)的概念初看非常简单——手上只有基础类型的一个句柄时,利用它判断一个对象的正确类型。 然而,对RTTI的需要暴露出了面向对象设计许多有趣(而且经常是令人困惑的)的问题,并把程序的构造问题正式摆上了桌面。 本章将讨论如何利用Java在运行期间查找对象和类信息。这主要采取两种形式:一种是“传统”RTTI,它假定我们已在编译和运行期拥有所有类型;另一种是Java1.1特有的“反射”机制,利用它可在运行期独立查找类信息。首先讨论“传统”的RTTI,再讨论反射问题。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:1048911.1 对RTTI的需要11.1 对RTTI的需要请考虑下面这个熟悉的类结构例子,它利用了多形性。常规类型是Shape类,而特别衍生出来的类型是Circle,Square和Triangle。这是一个典型的类结构示意图,基础类位于顶部,衍生类向下延展。面向对象编程的基本目标是用大量代码控制基础类型(这里是Shape)的句柄,所以假如决定添加一个新类(比如Rhomboid,从Shape衍生),从而对程序进行扩展,那么不会影响到原来的代码。在这个例子中,Shape接口中的动态绑定方法是draw(),所以客户程序员要做的是通过一个普通Shape句柄调用draw()。draw()在所有衍生类里都会被覆盖。而且由于它是一个动态绑定方法,所以即使通过一个普通的Shape句柄调用它,也有表现出正确的行为。这正是多形性的作用。所以,我们一般创建一个特定的对象(Circle,Square,或者Triangle),把它上溯造型到一个Shape(忽略对象的特殊类型),以后便在程序的剩余部分使用匿名Shape句柄。作为对多形性和上溯造型的一个简要回顾,可以象下面这样为上述例子编码(若执行这个程序时出现困难,请参考第3章3.1.2小节“赋值”):49011.1 对RTTI的需要//: Shapes.javapackage c11;import java.util.*;interface Shape {void draw();}class Circle implements Shape {public void draw() {System.out.println("Circle.draw()");}}class Square implements Shape {public void draw() {System.out.println("Square.draw()");}}class Triangle implements Shape {public void draw() {System.out.println("Triangle.draw()");}}public class Shapes {public static void main(String[] args) {Vector s = new Vector();s.addElement(new Circle());s.addElement(new Square());s.addElement(new Triangle());Enumeration e = s.elements();while(e.hasMoreElements())((Shape)e.nextElement()).draw();}} ///:~基础类可编码成一个interface(接口)、一个abstract(抽象)类或者一个普通类。由于Shape没有真正的成员(亦即有定义的成员),而且并不在意我们创建了一个纯粹的Shape对象,所以最适合和最灵活的表达方式便是用一个接口。而且由于不必设置所有那些abstract关键字,所以整个代码也显得更为清爽。每个衍生类都覆盖了基础类draw方法,所以具有不同的行为。在main()中创建了特定类型的Shape,然后将其添加到一个Vector。这里正是上溯造型发生的地方,因为Vector只容纳了对象。由于Java中的所有东西(除基本数据类型外)都是对象,所以Vector也能容纳Shape对象。但在上溯造型至Object的过程中,任何特殊的信息都会丢失,其中甚至包括对象是几何形状这一事实。对Vector来说,它们只是Object。49111.1 对RTTI的需要用nextElement()将一个元素从Vector提取出来的时候,情况变得稍微有些复杂。由于Vector只容纳Object,所以nextElement()会自然地产生一个Object句柄。但我们知道它实际是个Shape句柄,而且希望将Shape消息发给那个对象。所以需要用传统的"(Shape)"方式造型成一个Shape。这是RTTI最基本的形式,因为在Java中,所有造型都会在运行期间得到检查,以确保其正确性。那正是RTTI的意义所在:在运行期,对象的类型会得到鉴定。在目前这种情况下,RTTI造型只实现了一部分:Object造型成Shape,而不是造型成Circle,Square或者Triangle。那是由于我们目前能够肯定的唯一事实就是Vector里充斥着几何形状,而不知它们的具体类别。在编译期间,我们肯定的依据是我们自己的规则;而在编译期间,却是通过造型来肯定这一点。现在的局面会由多形性控制,而且会为Shape调用适当的方法,以便判断句柄到底是提供Circle,Square,还是提供给Triangle。而且在一般情况下,必须保证采用多形性方案。因为我们希望自己的代码尽可能少知道一些与对象的具体类型有关的情况,只将注意力放在某一类对象(这里是Shape)的常规信息上。只有这样,我们的代码才更易实现、理解以及修改。所以说多形性是面向对象程序设计的一个常规目标。然而,若碰到一个特殊的程序设计问题,只有在知道常规句柄的确切类型后,才能最容易地解决这个问题,这个时候又该怎么办呢?举个例子来说,我们有时候想让自己的用户将某一具体类型的几何形状(如三角形)全都变成紫色,以便突出显示它们,并快速找出这一类型的所有形状。此时便要用到RTTI技术,用它查询某个Shape句柄引用的准确类型是什么。11.1.1 Class对象为理解RTTI在Java里如何工作,首先必须了解类型信息在运行期是如何表示的。这时要用到一个名为“Class对象”的特殊形式的对象,其中包含了与类有关的信息(有时也把它叫作“元类”)。事实上,我们要用Class对象创建属于某个类的全部“常规”或“普通”对象。对于作为程序一部分的每个类,它们都有一个Class对象。换言之,每次写一个新类时,同时也会创建一个Class对象(更恰当地说,是保存在一个完全同名的.class文件中)。在运行期,一旦我们想生成那个类的一个对象,用于执行程序的Java虚拟机(JVM)首先就会检查那个类型的Class对象是否已经载入。若尚未载入,JVM就会查找同名的.class文件,并将其载入。所以Java程序启动时并不是完全载入的,这一点与许多传统语言都不同。一旦那个类型的Class对象进入内存,就用它创建那一类型的所有对象。若这种说法多少让你产生了一点儿迷惑,或者并没有真正理解它,下面这个示范程序或许能提供进一步的帮助:49211.1 对RTTI的需要//: SweetShop.java// Examination of the way the class loader worksclass Candy {static {System.out.println("Loading Candy");}}class Gum {static {System.out.println("Loading Gum");}}class Cookie {static {System.out.println("Loading Cookie");}}public class SweetShop {public static void main(String[] args) {System.out.println("inside main");new Candy();System.out.println("After creating Candy");try {Class.forName("Gum");} catch(ClassNotFoundException e) {e.printStackTrace();}System.out.println("After Class.forName(\"Gum\")");new Cookie();System.out.println("After creating Cookie");}} ///:~对每个类来说(Candy,Gum和Cookie),它们都有一个static从句,用于在类首次载入时执行。相应的信息会打印出来,告诉我们载入是什么时候进行的。在main()中,对象的创建代码位于打印语句之间,以便侦测载入时间。 特别有趣的一行是:Class.forName("Gum");该方法是Class(即全部Class所从属的)的一个static成员。而Class对象和其他任何对象都是类似的,所以能够获取和控制它的一个句柄(装载模块就是干这件事的)。为获得Class的一个句柄,一个办法是使用forName()。它的作用是取得包含了目标类文本名字的一个String(注意拼写和大小写)。最后返回的是一个Class句柄。49311.1 对RTTI的需要该程序在某个JVM中的输出如下:inside mainLoading CandyAfter creating CandyLoading GumAfter Class.forName("Gum")Loading CookieAfter creating Cookie可以看到,每个Class只有在它需要的时候才会载入,而static初始化工作是在类载入时执行的。 非常有趣的是,另一个JVM的输出变成了另一个样子:Loading CandyLoading Cookieinside mainAfter creating CandyLoading GumAfter Class.forName("Gum")After creating Cookie看来JVM通过检查main()中的代码,已经预测到了对Candy和Cookie的需要,但却看不到Gum,因为它是通过对forName()的一个调用创建的,而不是通过更典型的new调用。尽管这个JVM也达到了我们希望的效果,因为确实会在我们需要之前载入那些类,但却不能肯定这儿展示的行为百分之百正确。1. 类标记在Java 1.1中,可以采用第二种方式来产生Class对象的句柄:使用“类标记”。对上述程序来说,看起来就象下面这样: Gum.class;这样做不仅更加简单,而且更安全,因为它会在编译期间得到检查。由于它取消了对方法调用的需要,所以执行的效率也会更高。 类标记不仅可以应用于普通类,也可以应用于接口、数组以及基本数据类型。除此以外,针对每种基本数据类型的封装器类,它还存在一个名为TYPE的标准字段。TYPE字段的作用是为相关的基本数据类型产生Class对象的一个句柄,如下所示:……等价于……49411.1 对RTTI的需要... is equivalent to ...boolean.classBoolean.TYPEchar.classCharacter.TYPEbyte.classByte.TYPEshort.classShort.TYPEint.classInteger.TYPElong.classLong.TYPEfloat.classFloat.TYPEdouble.classDouble.TYPEvoid.classVoid.TYPE11.1.2 造型前的检查迄今为止,我们已知的RTTI形式包括:(1) 经典造型,如"(Shape)",它用RTTI确保造型的正确性,并在遇到一个失败的造型后产生一个ClassCastException违例。(2) 代表对象类型的Class对象。可查询Class对象,获取有用的运行期资料。在C++中,经典的"(Shape)"造型并不执行RTTI。它只是简单地告诉编译器将对象当作新类型处理。而Java要执行类型检查,这通常叫作“类型安全”的下溯造型。之所以叫“下溯造型”,是由于类分层结构的历史排列方式造成的。若将一个Circle(圆)造型到一个Shape(几何形状),就叫做上溯造型,因为圆只是几何形状的一个子集。反之,若将Shape造型至Circle,49511.1 对RTTI的需要就叫做下溯造型。然而,尽管我们明确知道Circle也是一个Shape,所以编译器能够自动上溯造型,但却不能保证一个Shape肯定是一个Circle。因此,编译器不允许自动下溯造型,除非明确指定一次这样的造型。RTTI在Java中存在三种形式。关键字instanceof告诉我们对象是不是一个特定类型的实例(Instance即“实例”)。它会返回一个布尔值,以便以问题的形式使用,就象下面这样:if(x instanceof Dog)((Dog)x).bark();将x造型至一个Dog前,上面的if语句会检查对象x是否从属于Dog类。进行造型前,如果没有其他信息可以告诉自己对象的类型,那么instanceof的使用是非常重要的——否则会得到一个ClassCastException违例。我们最一般的做法是查找一种类型(比如要变成紫色的三角形),但下面这个程序却演示了如何用instanceof标记出所有对象。//: PetCount.java// Using instanceofpackage c11.petcount;import java.util.*;class Pet {}class Dog extends Pet {}class Pug extends Dog {}class Cat extends Pet {}class Rodent extends Pet {}class Gerbil extends Rodent {}class Hamster extends Rodent {}class Counter { int i; }public class PetCount {static String[] typenames = {"Pet", "Dog", "Pug", "Cat","Rodent", "Gerbil", "Hamster",};public static void main(String[] args) {Vector pets = new Vector();try {Class[] petTypes = {Class.forName("c11.petcount.Dog"),Class.forName("c11.petcount.Pug"),Class.forName("c11.petcount.Cat"),Class.forName("c11.petcount.Rodent"),Class.forName("c11.petcount.Gerbil"),Class.forName("c11.petcount.Hamster"),};for(int i = 0; i < 15; i++)49611.1 对RTTI的需要pets.addElement(petTypes[(int)(Math.random()*petTypes.length)].newInstance());} catch(InstantiationException e) {}catch(IllegalAccessException e) {}catch(ClassNotFoundException e) {}Hashtable h = new Hashtable();for(int i = 0; i < typenames.length; i++)h.put(typenames[i], new Counter());for(int i = 0; i < pets.size(); i++) {Object o = pets.elementAt(i);if(o instanceof Pet)((Counter)h.get("Pet")).i++;if(o instanceof Dog)((Counter)h.get("Dog")).i++;if(o instanceof Pug)((Counter)h.get("Pug")).i++;if(o instanceof Cat)((Counter)h.get("Cat")).i++;if(o instanceof Rodent)((Counter)h.get("Rodent")).i++;if(o instanceof Gerbil)((Counter)h.get("Gerbil")).i++;if(o instanceof Hamster)((Counter)h.get("Hamster")).i++;}for(int i = 0; i < pets.size(); i++)System.out.println(pets.elementAt(i).getClass().toString());for(int i = 0; i < typenames.length; i++)System.out.println(typenames[i] + " quantity: " +((Counter)h.get(typenames[i])).i);}} ///:~在Java 1.0中,对instanceof有一个比较小的限制:只可将其与一个已命名的类型比较,不能同Class对象作对比。在上述例子中,大家可能觉得将所有那些instanceof表达式写出来是件很麻烦的事情。实际情况正是这样。但在Java 1.0中,没有办法让这一工作自动进行——不能创建Class的一个Vector,再将其与之比较。大家最终会意识到,如编写了数量众多的instanceof表达式,整个设计都可能出现问题。当然,这个例子只是一个构想——最好在每个类型里添加一个static数据成员,然后在构建器中令其增值,以便跟踪计数。编写程序时,大家可能想象自己拥有类的源码控制权,能够自由改动它。但由于实际情况并非总是这样,所以RTTI显得特别方便。1. 使用类标记PetCount.java示例可用Java 1.1的类标记重写一遍。得到的结果显得更加明确易懂:49711.1 对RTTI的需要//: PetCount2.java// Using Java 1.1 class literalspackage c11.petcount2;import java.util.*;class Pet {}class Dog extends Pet {}class Pug extends Dog {}class Cat extends Pet {}class Rodent extends Pet {}class Gerbil extends Rodent {}class Hamster extends Rodent {}class Counter { int i; }public class PetCount2 {public static void main(String[] args) {Vector pets = new Vector();Class[] petTypes = {// Class literals work in Java 1.1+ only:Pet.class,Dog.class,Pug.class,Cat.class,Rodent.class,Gerbil.class,Hamster.class,};try {for(int i = 0; i < 15; i++) {// Offset by one to eliminate Pet.class:int rnd = 1 + (int)(Math.random() * (petTypes.length - 1));pets.addElement(petTypes[rnd].newInstance());}} catch(InstantiationException e) {}catch(IllegalAccessException e) {}Hashtable h = new Hashtable();for(int i = 0; i < petTypes.length; i++)h.put(petTypes[i].toString(),new Counter());for(int i = 0; i < pets.size(); i++) {Object o = pets.elementAt(i);if(o instanceof Pet)((Counter)h.get("class c11.petcount2.Pet")).i++;if(o instanceof Dog)((Counter)h.get("class c11.petcount2.Dog")).i++;if(o instanceof Pug)((Counter)h.get(49811.1 对RTTI的需要"class c11.petcount2.Pug")).i++;if(o instanceof Cat)((Counter)h.get("class c11.petcount2.Cat")).i++;if(o instanceof Rodent)((Counter)h.get("class c11.petcount2.Rodent")).i++;if(o instanceof Gerbil)((Counter)h.get("class c11.petcount2.Gerbil")).i++;if(o instanceof Hamster)((Counter)h.get("class c11.petcount2.Hamster")).i++;}for(int i = 0; i < pets.size(); i++)System.out.println(pets.elementAt(i).getClass().toString());Enumeration keys = h.keys();while(keys.hasMoreElements()) {String nm = (String)keys.nextElement();Counter cnt = (Counter)h.get(nm);System.out.println(nm.substring(nm.lastIndexOf('.') + 1) +" quantity: " + cnt.i);}}} ///:~在这里,typenames(类型名)数组已被删除,改为从Class对象里获取类型名称。注意为此而额外做的工作:例如,类名不是Getbil,而是c11.petcount2.Getbil,其中已包含了包的名字。也要注意系统是能够区分类和接口的。也可以看到,petTypes的创建模块不需要用一个try块包围起来,因为它会在编译期得到检查,不会象Class.forName()那样“掷”出任何违例。Pet动态创建好以后,可以看到随机数字已得到了限制,位于1和petTypes.length之间,而且不包括零。那是由于零代表的是Pet.class,而且一个普通的Pet对象可能不会有人感兴趣。然而,由于Pet.class是petTypes的一部分,所以所有Pet(宠物)都会算入计数中。1. 动态的instanceofJava 1.1为Class类添加了isInstance方法。利用它可以动态调用instanceof运算符。而在Java1.0中,只能静态地调用它(就象前面指出的那样)。因此,所有那些烦人的instanceof语句都可以从PetCount例子中删去了。如下所示://: PetCount3.java// Using Java 1.1 isInstance()package c11.petcount3;import java.util.*;49911.1 对RTTI的需要class Pet {}class Dog extends Pet {}class Pug extends Dog {}class Cat extends Pet {}class Rodent extends Pet {}class Gerbil extends Rodent {}class Hamster extends Rodent {}class Counter { int i; }public class PetCount3 {public static void main(String[] args) {Vector pets = new Vector();Class[] petTypes = {Pet.class,Dog.class,Pug.class,Cat.class,Rodent.class,Gerbil.class,Hamster.class,};try {for(int i = 0; i < 15; i++) {// Offset by one to eliminate Pet.class:int rnd = 1 + (int)(Math.random() * (petTypes.length - 1));pets.addElement(petTypes[rnd].newInstance());}} catch(InstantiationException e) {}catch(IllegalAccessException e) {}Hashtable h = new Hashtable();for(int i = 0; i < petTypes.length; i++)h.put(petTypes[i].toString(),new Counter());for(int i = 0; i < pets.size(); i++) {Object o = pets.elementAt(i);// Using isInstance to eliminate individual// instanceof expressions:for (int j = 0; j < petTypes.length; ++j)if (petTypes[j].isInstance(o)) {String key = petTypes[j].toString();((Counter)h.get(key)).i++;}}for(int i = 0; i < pets.size(); i++)System.out.println(pets.elementAt(i).getClass().toString());Enumeration keys = h.keys();while(keys.hasMoreElements()) {String nm = (String)keys.nextElement();50011.1 对RTTI的需要Counter cnt = (Counter)h.get(nm);System.out.println(nm.substring(nm.lastIndexOf('.') + 1) +" quantity: " + cnt.i);}}} ///:~可以看到,Java 1.1的isInstance()方法已取消了对instanceof表达式的需要。此外,这也意味着一旦要求添加新类型宠物,只需简单地改变petTypes数组即可;毋需改动程序剩余的部分(但在使用instanceof时却是必需的)。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:1050111.2 RTTI语法11.2 RTTI语法Java用Class对象实现自己的RTTI功能——即便我们要做的只是象造型那样的一些工作。Class类也提供了其他大量方式,以方便我们使用RTTI。首先必须获得指向适当Class对象的的一个句柄。就象前例演示的那样,一个办法是用一个字串以及Class.forName()方法。这是非常方便的,因为不需要那种类型的一个对象来获取Class句柄。然而,对于自己感兴趣的类型,如果已有了它的一个对象,那么为了取得Class句柄,可调用属于Object根类一部分的一个方法:getClass()。它的作用是返回一个特定的Class句柄,用来表示对象的实际类型。Class提供了几个有趣且较为有用的方法,从下例即可看出:50211.2 RTTI语法//: ToyTest.java// Testing class Classinterface HasBatteries {}interface Waterproof {}interface ShootsThings {}class Toy {// Comment out the following default// constructor to see// NoSuchMethodError from (*1*)Toy() {}Toy(int i) {}}class FancyToy extends Toyimplements HasBatteries,Waterproof, ShootsThings {FancyToy() { super(1); }}public class ToyTest {public static void main(String[] args) {Class c = null;try {c = Class.forName("FancyToy");} catch(ClassNotFoundException e) {}printInfo(c);Class[] faces = c.getInterfaces();for(int i = 0; i < faces.length; i++)printInfo(faces[i]);Class cy = c.getSuperclass();Object o = null;try {// Requires default constructor:o = cy.newInstance(); // (*1*)} catch(InstantiationException e) {}catch(IllegalAccessException e) {}printInfo(o.getClass());}static void printInfo(Class cc) {System.out.println("Class name: " + cc.getName() +" is interface? [" +cc.isInterface() + "]");}} ///:~从中可以看出,class FancyToy相当复杂,因为它从Toy中继承,并实现了HasBatteries,Waterproof以及ShootsThings的接口。在main()中创建了一个Class句柄,并用位于相应try块内的forName()初始化成FancyToy。50311.2 RTTI语法Class.getInterfaces方法会返回Class对象的一个数组,用于表示包含在Class对象内的接口。若有一个Class对象,也可以用getSuperclass()查询该对象的直接基础类是什么。当然,这种做会返回一个Class句柄,可用它作进一步的查询。这意味着在运行期的时候,完全有机会调查到对象的完整层次结构。若从表面看,Class的newInstance()方法似乎是克隆(clone())一个对象的另一种手段。但两者是有区别的。利用newInstance(),我们可在没有现成对象供“克隆”的情况下新建一个对象。就象上面的程序演示的那样,当时没有Toy对象,只有cy——即y的Class对象的一个句柄。利用它可以实现“虚拟构建器”。换言之,我们表达:“尽管我不知道你的准确类型是什么,但请你无论如何都正确地创建自己。”在上述例子中,cy只是一个Class句柄,编译期间并不知道进一步的类型信息。一旦新建了一个实例后,可以得到Object句柄。但那个句柄指向一个Toy对象。当然,如果要将除Object能够接收的其他任何消息发出去,首先必须进行一些调查研究,再进行造型。除此以外,用newInstance()创建的类必须有一个默认构建器。没有办法用newInstance()创建拥有非默认构建器的对象,所以在Java 1.0中可能存在一些限制。然而,Java 1.1的“反射”API(下一节讨论)却允许我们动态地使用类里的任何构建器。程序中的最后一个方法是printInfo(),它取得一个Class句柄,通过getName()获得它的名字,并用interface()调查它是不是一个接口。该程序的输出如下:Class name: FancyToy is interface? [false]Class name: HasBatteries is interface? [true]Class name: Waterproof is interface? [true]Class name: ShootsThings is interface? [true]Class name: Toy is interface? [false]所以利用Class对象,我们几乎能将一个对象的祖宗十八代都调查出来。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:1050411.3 反射:运行期类信息11.3 反射:运行期类信息如果不知道一个对象的准确类型,RTTI会帮助我们调查。但却有一个限制:类型必须是在编译期间已知的,否则就不能用RTTI调查它,进而无法展开下一步的工作。换言之,编译器必须明确知道RTTI要处理的所有类。从表面看,这似乎并不是一个很大的限制,但假若得到的是一个不在自己程序空间内的对象的句柄,这时又会怎样呢?事实上,对象的类即使在编译期间也不可由我们的程序使用。例如,假设我们从磁盘或者网络获得一系列字节,而且被告知那些字节代表一个类。由于编译器在编译代码时并不知道那个类的情况,所以怎样才能顺利地使用这个类呢?在传统的程序设计环境中,出现这种情况的概率或许很小。但当我们转移到一个规模更大的编程世界中,却必须对这个问题加以高度重视。第一个要注意的是基于组件的程序设计。在这种环境下,我们用“快速应用开发”(RAD)模型来构建程序项目。RAD一般是在应用程序构建工具中内建的。这是编制程序的一种可视途径(在屏幕上以窗体的形式出现)。可将代表不同组件的图标拖曳到窗体中。随后,通过设定这些组件的属性或者值,进行正确的配置。设计期间的配置要求任何组件都是可以“例示”的(即可以自由获得它们的实例)。这些组件也要揭示出自己的一部分内容,允许程序员读取和设置各种值。此外,用于控制GUI事件的组件必须揭示出与相应的方法有关的信息,以便RAD环境帮助程序员用自己的代码覆盖这些由事件驱动的方法。“反射”提供了一种特殊的机制,可以侦测可用的方法,并产生方法名。通过Java Beans(第13章将详细介绍),Java 1.1为这种基于组件的程序设计提供了一个基础结构。在运行期查询类信息的另一个原动力是通过网络创建与执行位于远程系统上的对象。这就叫作“远程方法调用”(RMI),它允许Java程序(版本1.1以上)使用由多台机器发布或分布的对象。这种对象的分布可能是由多方面的原因引起的:可能要做一件计算密集型的工作,想对它进行分割,让处于空闲状态的其他机器分担部分工作,从而加快处理进度。某些情况下,可能需要将用于控制特定类型任务(比如多层客户/服务器架构中的“运作规则”)的代码放置在一台特殊的机器上,使这台机器成为对那些行动进行描述的一个通用储藏所。而且可以方便地修改这个场所,使其对系统内的所有方面产生影响(这是一种特别有用的设计思路,因为机器是独立存在的,所以能轻易修改软件!)。分布式计算也能更充分地发挥某些专用硬件的作用,它们特别擅长执行一些特定的任务——例如矩阵逆转——但对常规编程来说却显得太夸张或者太昂贵了。在Java 1.1中,Class类(本章前面已有详细论述)得到了扩展,可以支持“反射”的概念。针对Field,Method以及Constructor类(每个都实现了Memberinterface——成员接口),它们都新增了一个库:java.lang.reflect。这些类型的对象都是JVM在运行期创建的,用于代表未知类里对应的成员。这样便可用构建器创建新对象,用get()和set()方法读取和修改与Field对象关联的字段,以及用invoke()方法调用与Method对象关联的方法。此外,我们可调用方法getFields(),getMethods(),getConstructors(),分别返回用于表示字段、方法以及构建器的50511.3 反射:运行期类信息对象数组(在联机文档中,还可找到与Class类有关的更多的资料)。因此,匿名对象的类信息可在运行期被完整的揭露出来,而在编译期间不需要知道任何东西。 大家要认识的很重要的一点是“反射”并没有什么神奇的地方。通过“反射”同一个未知类型的对象打交道时,JVM只是简单地检查那个对象,并调查它从属于哪个特定的类(就象以前的RTTI那样)。但在这之后,在我们做其他任何事情之前,Class对象必须载入。因此,用于那种特定类型的.class文件必须能由JVM调用(要么在本地机器内,要么可以通过网络取得)。所以RTTI和“反射”之间唯一的区别就是对RTTI来说,编译器会在编译期打开和检查.class文件。换句话说,我们可以用“普通”方式调用一个对象的所有方法;但对“反射”来说,.class文件在编译期间是不可使用的,而是由运行期环境打开和检查。11.3.1 一个类方法提取器很少需要直接使用反射工具;之所以在语言中提供它们,仅仅是为了支持其他Java特性,比如对象序列化(第10章介绍)、Java Beans以及RMI(本章后面介绍)。但是,我们许多时候仍然需要动态提取与一个类有关的资料。其中特别有用的工具便是一个类方法提取器。正如前面指出的那样,若检视类定义源码或者联机文档,只能看到在那个类定义中被定义或覆盖的方法,基础类那里还有大量资料拿不到。幸运的是,“反射”做到了这一点,可用它写一个简单的工具,令其自动展示整个接口。下面便是具体的程序:50611.3 反射:运行期类信息//: ShowMethods.java// Using Java 1.1 reflection to show all the// methods of a class, even if the methods are// defined in the base class.import java.lang.reflect.*;public class ShowMethods {static final 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'";public static void main(String[] args) {if(args.length < 1) {System.out.println(usage);System.exit(0);}try {Class c = Class.forName(args[0]);Method[] m = c.getMethods();Constructor[] ctor = c.getConstructors();if(args.length == 1) {for (int i = 0; i < m.length; i++)System.out.println(m[i].toString());for (int i = 0; i < ctor.length; i++)System.out.println(ctor[i].toString());}else {for (int i = 0; i < m.length; i++)if(m[i].toString().indexOf(args[1])!= -1)System.out.println(m[i].toString());for (int i = 0; i < ctor.length; i++)if(ctor[i].toString().indexOf(args[1])!= -1)System.out.println(ctor[i].toString());}} catch (ClassNotFoundException e) {System.out.println("No such class: " + e);}}} ///:~Class方法getMethods()和getConstructors()可以分别返回Method和Constructor的一个数组。每个类都提供了进一步的方法,可解析出它们所代表的方法的名字、参数以及返回值。但也可以象这样一样只使用toString(),生成一个含有完整方法签名的字串。代码剩余的部分只是用于提取命令行信息,判断特定的签名是否与我们的目标字串相符(使用indexOf()),并打印出结果。50711.3 反射:运行期类信息这里便用到了“反射”技术,因为由Class.forName()产生的结果不能在编译期间获知,所以所有方法签名信息都会在运行期间提取。若研究一下联机文档中关于“反射”(Reflection)的那部分文字,就会发现它已提供了足够多的支持,可对一个编译期完全未知的对象进行实际的设置以及发出方法调用。同样地,这也属于几乎完全不用我们操心的一个步骤——Java自己会利用这种支持,所以程序设计环境能够控制Java Beans——但它无论如何都是非常有趣的。一个有趣的试验是运行java ShowMehods ShowMethods。这样做可得到一个列表,其中包括一个public默认构建器,尽管我们在代码中看见并没有定义一个构建器。我们看到的是由编译器自动合成的那一个构建器。如果随之将ShowMethods设为一个非public类(即换成“友好”类),合成的默认构建器便不会在输出结果中出现。合成的默认构建器会自动获得与类一样的访问权限。 ShowMethods的输出仍然有些“不爽”。例如,下面是通过调用javaShowMethods java.lang.String得到的输出结果的一部分:public booleanjava.lang.String.startsWith(java.lang.String,int)public booleanjava.lang.String.startsWith(java.lang.String)public booleanjava.lang.String.endsWith(java.lang.String)若能去掉象java.lang这样的限定词,结果显然会更令人满意。有鉴于此,可引入上一章介绍的StreamTokenizer类,解决这个问题://: ShowMethodsClean.java// ShowMethods with the qualifiers stripped// to make the results easier to readimport java.lang.reflect.*;import java.io.*;public class ShowMethodsClean {static final String usage ="usage: \n" +"ShowMethodsClean qualified.class.name\n" +"To show all methods in class or: \n" +"ShowMethodsClean qualif.class.name word\n" +"To search for methods involving 'word'";public static void main(String[] args) {if(args.length < 1) {System.out.println(usage);System.exit(0);}try {Class c = Class.forName(args[0]);Method[] m = c.getMethods();Constructor[] ctor = c.getConstructors();// Convert to an array of cleaned Strings:50811.3 反射:运行期类信息String[] n =new String[m.length + ctor.length];for(int i = 0; i < m.length; i++) {String s = m[i].toString();n[i] = StripQualifiers.strip(s);}for(int i = 0; i < ctor.length; i++) {String s = ctor[i].toString();n[i + m.length] =StripQualifiers.strip(s);}if(args.length == 1)for (int i = 0; i < n.length; i++)System.out.println(n[i]);elsefor (int i = 0; i < n.length; i++)if(n[i].indexOf(args[1])!= -1)System.out.println(n[i]);} catch (ClassNotFoundException e) {System.out.println("No such class: " + e);}}}class StripQualifiers {private StreamTokenizer st;public StripQualifiers(String qualified) {st = new StreamTokenizer(new StringReader(qualified));st.ordinaryChar(' '); // Keep the spaces}public String getNext() {String s = null;try {if(st.nextToken() !=StreamTokenizer.TT_EOF) {switch(st.ttype) {case StreamTokenizer.TT_EOL:s = null;break;case StreamTokenizer.TT_NUMBER:s = Double.toString(st.nval);break;case StreamTokenizer.TT_WORD:s = new String(st.sval);break;default: // single character in ttypes = String.valueOf((char)st.ttype);}}} catch(IOException e) {System.out.println(e);}50911.3 反射:运行期类信息return s;}public static String strip(String qualified) {StripQualifiers sq =new StripQualifiers(qualified);String s = "", si;while((si = sq.getNext()) != null) {int lastDot = si.lastIndexOf('.');if(lastDot != -1)si = si.substring(lastDot + 1);s += si;}return s;}} ///:~ShowMethodsClean方法非常接近前一个ShowMethods,只是它取得了Method和Constructor数组,并将它们转换成单个String数组。随后,每个这样的String对象都在StripQualifiers.Strip()里“过”一遍,删除所有方法限定词。正如大家看到的那样,此时用到了StreamTokenizer和String来完成这个工作。假如记不得一个类是否有一个特定的方法,而且不想在联机文档里逐步检查类结构,或者不知道那个类是否能对某个对象(如Color对象)做某件事情,该工具便可节省大量编程时间。第17章提供了这个程序的一个GUI版本,可在自己写代码的时候运行它,以便快速查找需要的东西。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:1051011.4 总结11.4 总结利用RTTI可根据一个匿名的基础类句柄调查出类型信息。但正是由于这个原因,新手们极易误用它,因为有些时候多形性方法便足够了。对那些以前习惯程序化编程的人来说,极易将他们的程序组织成一系列switch语句。他们可能用RTTI做到这一点,从而在代码开发和维护中损失多形性技术的重要价值。Java的要求是让我们尽可能地采用多形性,只有在极特别的情况下才使用RTTI。 但为了利用多形性,要求我们拥有对基础类定义的控制权,因为有些时候在程序范围之内,可能发现基础类并未包括我们想要的方法。若基础类来自一个库,或者由别的什么东西控制着,RTTI便是一种很好的解决方案:可继承一个新类型,然后添加自己的额外方法。在代码的其他地方,可以侦测自己的特定类型,并调用那个特殊的方法。这样做不会破坏多形性以及程序的扩展能力,因为新类型的添加不要求查找程序中的switch语句。但在需要新特性的主体中添加新代码时,就必须用RTTI侦测自己特定的类型。从某个特定类的利益的角度出发,在基础类里加入一个特性后,可能意味着从那个基础类衍生的其他所有类都必须获得一些无意义的“鸡肋”。这使得接口变得含义模糊。若有人从那个基础类继承,且必须覆盖抽象方法,这一现象便会使他们陷入困扰。比如现在用一个类结构来表示乐器(Instrument)。假定我们想清洁管弦乐队中所有适当乐器的通气音栓(SpitValve),此时的一个办法是在基础类Instrument中置入一个ClearSpitValve()方法。但这样做会造成一个误区,因为它暗示着打击乐器和电子乐器中也有音栓。针对这种情况,RTTI提供了一个更合理的解决方案,可将方法置入特定的类中(此时是Wind,即“通气口”)——这样做是可行的。但事实上一种更合理的方案是将prepareInstrument()置入基础类中。初学者刚开始时往往看不到这一点,一般会认定自己必须使用RTTI。最后,RTTI有时能解决效率问题。若代码大量运用了多形性,但其中的一个对象在执行效率上很有问题,便可用RTTI找出那个类型,然后写一段适当的代码,改进其效率。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:1051111.5 练习11.5 练习(1) 写一个方法,向它传递一个对象,循环打印出对象层次结构中的所有类。(2) 在ToyTest.java中,将Toy的默认构建器标记成注释信息,解释随之发生的事情。(3) 新建一种类型的集合,令其使用一个Vector。捕获置入其中的第一个对象的类型,然后从那时起只允许用户插入那种类型的对 象。(4) 写一个程序,判断一个Char数组属于基本数据类型,还是一个真正的对象。(5) 根据本章的说明,实现clearSpitValve()。(6) 实现本章介绍的rotate(Shape)方法,令其检查是否已经旋转了一个圆(若已旋转,就不再执行旋转操作)。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:10512第12章 传递和返回对象第12章 传递和返回对象到目前为止,读者应对对象的“传递”有了一个较为深刻的认识,记住实际传递的只是一个句柄。在许多程序设计语言中,我们可用语言的“普通”方式到处传递对象,而且大多数时候都不会遇到问题。但有些时候却不得不采取一些非常做法,使得情况突然变得稍微复杂起来(在C++中则是变得非常复杂)。Java亦不例外,我们十分有必要准确认识在对象传递和赋值时所发生的一切。这正是本章的宗旨。若读者是从某些特殊的程序设计环境中转移过来的,那么一般都会问到:“Java有指针吗?”有些人认为指针的操作很困难,而且十分危险,所以一厢情愿地认为它没有好处。同时由于Java有如此好的口碑,所以应该很轻易地免除自己以前编程中的麻烦,其中不可能夹带有指针这样的“危险品”。然而准确地说,Java是有指针的!事实上,Java中每个对象(除基本数据类型以外)的标识符都属于指针的一种。但它们的使用受到了严格的限制和防范,不仅编译器对它们有“戒心”,运行期系统也不例外。或者换从另一个角度说,Java有指针,但没有传统指针的麻烦。我曾一度将这种指针叫做“句柄”,但你可以把它想像成“安全指针”。和预备学校为学生提供的安全剪刀类似——除非特别有意,否则不会伤着自己,只不过有时要慢慢来,要习惯一些沉闷的工作。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:1051312.1 传递句柄12.1 传递句柄12.1 传递句柄 将句柄传递进入一个方法时,指向的仍然是相同的对象。一个简单的实验可以证明这一点(若执行这个程序时有麻烦,请参考第3章3.1.2小节“赋值”): //:PassHandles.java // Passing handles around package c12;public class PassHandles { static void f(PassHandles h) { System.out.println("h inside f(): " +h); } public static void main(String[] args) { PassHandles p = new PassHandles();System.out.println("p inside main(): " + p); f(p); } } ///:~toString方法会在打印语句里自动调用,而PassHandles直接从Object继承,没有toString的重新定义。因此,这里会采用toString的Object版本,打印出对象的类,接着是那个对象所在的位置(不是句柄,而是对象的实际存储位置)。输出结果如下: p inside main():PassHandles@1653748 h inside f() : PassHandles@1653748 可以看到,无论p还是h引用的都是同一个对象。这比复制一个新的PassHandles对象有效多了,使我们能将一个参数发给一个方法。但这样做也带来了另一个重要的问题。12.1.1 别名问题 “别名”意味着多个句柄都试图指向同一个对象,就象前面的例子展示的那样。若有人向那个对象里写入一点什么东西,就会产生别名问题。若其他句柄的所有者不希望那个对象改变,恐怕就要失望了。这可用下面这个简单的例子说明: //: Alias1.java //Aliasing two handles to one objectpublic class Alias1 { int i; Alias1(int ii) { i = ii; } public static void main(String[] args) { Alias1 x= new Alias1(7); Alias1 y = x; // Assign the handle System.out.println("x: " + x.i);System.out.println("y: " + y.i); System.out.println("Incrementing x"); x.i++;System.out.println("x: " + x.i); System.out.println("y: " + y.i); } } ///:~对下面这行: Alias1 y = x; // Assign the handle 它会新建一个Alias1句柄,但不是把它分配给由new创建的一个新鲜对象,而是分配给一个现有的句柄。所以句柄x的内容——即对象x指向的地址——被分配给y,所以无论x还是y都与相同的对象连接起来。这样一来,一旦x的i在下述语句中增值: x.i++; y的i值也必然受到影响。从最终的输出就可以看出: x: 7 y: 7Incrementing x x: 8 y: 8此时最直接的一个解决办法就是干脆不这样做:不要有意将多个句柄指向同一个作用域内的同一个对象。这样做可使代码更易理解和调试。然而,一旦准备将句柄作为一个自变量或参数传递——这是Java设想的正常方法——别名问题就会自动出现,因为创建的本地句柄可能修改“外部对象”(在方法作用域之外创建的对象)。下面是一个例子: //: Alias2.java //Method calls implicitly alias their // arguments.51412.1 传递句柄public class Alias2 { int i; Alias2(int ii) { i = ii; } static void f(Alias2 handle) { handle.i++; }public static void main(String[] args) { Alias2 x = new Alias2(7); System.out.println("x: " + x.i);System.out.println("Calling f(x)"); f(x); System.out.println("x: " + x.i); } } ///:~输出如下: x: 7 Calling f(x) x: 8方法改变了自己的参数——外部对象。一旦遇到这种情况,必须判断它是否合理,用户是否愿意这样,以及是不是会造成问题。 通常,我们调用一个方法是为了产生返回值,或者用它改变为其调用方法的那个对象的状态(方法其实就是我们向那个对象“发一条消息”的方式)。很少需要调用一个方法来处理它的参数;这叫作利用方法的“副作用”(Side Effect)。所以倘若创建一个会修改自己参数的方法,必须向用户明确地指出这一情况,并警告使用那个方法可能会有的后果以及它的潜在威胁。由于存在这些混淆和缺陷,所以应该尽量避免改变参数。 若需在一个方法调用期间修改一个参数,且不打算修改外部参数,就应在自己的方法内部制作一个副本,从而保护那个参数。本章的大多数内容都是围绕这个问题展开的。Copyright © quanke.name 2016 all right reserved,powered by Gitbook该文件修订时间:2018-03-13 01:23:1051512.2 制作本地副本12.2 制作本地副本12.2 制作本地副本 稍微总结一下:Java中的所有自变量或参数传递都是通过传递句柄进行的。也就是说,当我们传递“一个对象”时,实际传递的只是指向位于方法外部的那个对象的“一个句柄”。所以一旦要对那个句柄进行任何修改,便相当于修改外部对象。此外: ■参数传递过程中会自动产生别名问题 ■不存在本地对象,只有本地句柄 ■句柄有自己的作用域,而对象没有 ■对象的“存在时间”在Java里不是个问题 ■没有语言上的支持(如常量)可防止对象被修改(以避免别名的副作用) 若只是从对象中读取信息,而不修改它,传递句柄便是自变量传递中最有效的一种形式。这种做非常恰当;默认的方法一般也是最有效的方法。然而,有时仍需将对象当作“本地的”对待,使我们作出的改变只影响一个本地副本,不会对外面的对象造成影响。许多程序设计语言都支持在方法内自动生成外部对象的一个本地副本(注释①)。尽管Java不具备这种能力,但允许我们达到同样的效果。①:在C语言中,通常控制的是少量数据位,默认操作是按值传递。C++也必须遵照这一形式,但按值传递对象并非肯定是一种有效的方式。此外,在C++中用于支持按值传递的代码也较难编写,是件让人头痛的事情。12.2.1 按值传递 首先要解决术语的问题,最适合“按值传递”的看起来是自变量。“按值传递”以及它的含义取决于如何理解程序的运行方式。最常见的意思是获得要传递的任何东西的一个本地副本,但这里真正的问题是如何看待自己准备传递的东西。对于“按值传递”的含义,目前存在两种存在明显区别的见解: (1) Java按值传递任何东西。若将基本数据类型传递进入一个方法,会明确得到基本数据类型的一个副本。但若将一个句柄传递进入方法,得到的是句柄的副本。所以人们认为“一切”都按值传递。当然,这种说法也有一个前提:句柄肯定也会被传递。但Java的设计方案似乎有些超前,允许我们忽略(大多数时候)自己处理的是一个句柄。也就是说,它允许我们将句柄假想成“对象”,因为在发出方法调用时,系统会自动照管两者间的差异。 (2) Java主要按值传递(无自变量),但对象却是按引用传递的。得到这个结论的前提是句柄只是对象的一个“别名”,所以不考虑传递句柄的问题,而是直接指出“我准备传递对象”。由于将其传递进入一个方法时没有获得对象的一个本地副本,所以对象显然不是按值传递的。Sun公司似乎在某种程度上支持这一见解,因为它“保留但未实现”的关键字之一便是byvalue(按值)。但没人知道那个关键字什么时候可以发挥作用。 尽管存在两种不同的见解,但其间的分歧归根到底是由于对“句柄”的不同解释造成的。我打算在本书剩下的部分里回避这个问题。大家不久就会知道,这个问题争论下去其实是没有意义的——最重要的是理解一个句柄的传递会使调用者的对象发生意外的改变。12.2.2 克隆对象 若需修改一个对象,同时不想改变调用者的对象,就要制作该对象的一个本地副本。这也是本地副本最常见的一种用途。若决定制作一个本地副本,只需简单地使用clone()方法即可。Clone是“克隆”的意思,即制作完全一模一样的副本。这个方法在基础类Object中定义成“protected”(受保护)模式。但在希望克隆的任何衍生类中,必须将其覆盖51612.2 制作本地副本为“public”模式。例如,标准库类Vector覆盖了clone(),所以能为Vector调用clone(),如下所示: //: Cloning.java // The clone() operation works for only a few // items in the standardJava library. import java.util.*;class Int { private int i; public Int(int ii) { i = ii; } public void increment() { i++; } public StringtoString() { return Integer.toString(i); } }public class Cloning { public static void main(String[] args) { Vector v = new Vector(); for(int i= 0; i 0) next = new Snake(i, (char)(x +1)); } void increment() { c++; if(next != null) next.increment(); } public String toString() { Strings = ":" + c; if(next != null) s += next.toString(); return s; } public Object clone() { Object o =null; try { o = super.clone(); } catch (CloneNotSupportedException e) {} return o; } publicstatic void main(String[] args) { Snake s = new Snake(5, 'a'); System.out.println("s = " + s);Snake s2 = (Snake)s.clone(); System.out.println("s2 = " + s2); s.increment();System.out.println( "after s.increment, s2 = " + s2); } } ///:~一条Snake(蛇)由数段构成,每一段的类型都是Snake。所以,这是一个一段段链接起来的列表。所有段都是以循环方式创建的,每做好一段,都会使第一个构建器参数的值递减,直至最终为零。而为给每段赋予一个独一无二的标记,第二个参数(一个Char)的值在每次循环构建器调用时都会递增。 increment()方法的作用是循环递增每个标记,使我们能看到发生的变化;而toString则循环打印出每个标记。输出如下: s = :a:b:c:d:e s2 = :a:b:c:d:e afters.increment, s2 = :a:c:d:e:f这意味着只有第一段才是由Object.clone()复制的,所以此时进行的是一种“浅层复制”。若希望复制整条蛇——即进行“深层复制”——必须在被覆盖的clone()里采取附加的操作。 通常可在从一个能克隆的类里调用super.clone(),以确保所有基础类行动(包括Object.clone())能够进行。随着是为对象内每个句柄都明确调用一个clone();否则那些句柄会别名变成原始对象的句柄。构建器的调用也大致相同——首先构造基础类,然后是下一个衍生的构建器……以此类推,直到位于最深层的衍生构建器。区别在于clone()并不是个构建器,所以没有办法实现自动克隆。为了克隆,必须由自己明确进行。12.2.6 克隆合成对象 试图深层复制合成对象时会遇到一个问题。必须假定成员对象中的clone()方法也能依次对自己的句柄进行深层复制,以此类推。这使我们的操作变得复杂。为了能正常实现深层复制,必须对所有类中的代码进行控制,或者至少全面掌握深层复制中需要涉及的类,确保它们自己的深层复制能正确进行。 下面这个例子总结了面对一个合成对象进行深层复制时需要做哪些事情: //: DeepCopy.java // Cloning a composed objectclass DepthReading implements Cloneable { private double depth; publicDepthReading(double depth) { this.depth = depth; } public Object clone() { Object o = null; try{ o = super.clone(); } catch (CloneNotSupportedException e) { e.printStackTrace(); } return o;}}class TemperatureReading implements Cloneable { private long time; private doubletemperature; public TemperatureReading(double temperature) { time =System.currentTimeMillis(); this.temperature = temperature; } public Object clone() { Objecto = null; try { o = super.clone(); } catch (CloneNotSupportedException e) {e.printStackTrace(); } return o; } }52012.2 制作本地副本class OceanReading implements Cloneable { private DepthReading depth; privateTemperatureReading temperature; public OceanReading(double tdata, double ddata){temperature = new TemperatureReading(tdata); depth = new DepthReading(ddata); } publicObject clone() { OceanReading o = null; try { o = (OceanReading)super.clone(); } catch(CloneNotSupportedException e) { e.printStackTrace(); } // Must clone handles: o.depth =(DepthReading)o.depth.clone(); o.temperature =(TemperatureReading)o.temperature.clone(); return o; // Upcasts back to Object } }public class DeepCopy { public static void main(String[] args) { OceanReading reading =new OceanReading(33.9, 100.5); // Now clone it: OceanReading r =(OceanReading)reading.clone(); } } ///:~DepthReading和TemperatureReading非常相似;它们都只包含了基本数据类型。所以clone()方法能够非常简单:调用super.clone()并返回结果即可。注意两个类使用的clone()代码是完全一致的。 OceanReading是由DepthReading和TemperatureReading对象合并而成的。为了对其进行深层复制,clone()必须同时克隆OceanReading内的句柄。为达到这个目标,super.clone()的结果必须造型成一个OceanReading对象(以便访问depth和temperature句柄)。12.2.7 用Vector进行深层复制 下面让我们复习一下本章早些时候提出的Vector例子。这一次Int2类是可以克隆的,所以能对Vector进行深层复制: //: AddingClone.java // You must gothrough a few gyrations to // add cloning to your own class. import java.util.*;class Int2 implements Cloneable { private int i; public Int2(int ii) { i = ii; } public voidincrement() { i++; } public String toString() { return Integer.toString(i); } public Object clone() {Object o = null; try { o = super.clone(); } catch (CloneNotSupportedException e) {System.out.println("Int2 can't clone"); } return o; } }// Once it's cloneable, inheritance // doesn't remove cloneability: class Int3 extends Int2 {private int j; // Automatically duplicated public Int3(int i) { super(i); } }public class AddingClone { public static void main(String[] args) { Int2 x = new Int2(10); Int2x2 = (Int2)x.clone(); x2.increment(); System.out.println( "x = " + x + ", x2 = " + x2); // Anythinginherited is also cloneable: Int3 x3 = new Int3(7); x3 = (Int3)x3.clone();52112.2 制作本地副本Vector v = new Vector();for(int i = 0; i < 10; i++ )v.addElement(new Int2(i));System.out.println("v: " + v);Vector v2 = (Vector)v.clone();// Now clone each element:for(int i = 0; i < v.size(); i++)v2.setElementAt(((Int2)v2.elementAt(i)).clone(), i);// Increment all v2's elements:for(Enumeration e = v2.elements();e.hasMoreElements(); )((Int2)e.nextElement()).increment();// See if it changed v's elements:System.out.println("v: " + v);System.out.println("v2: " + v2);} } ///:~Int3自Int2继承而来,并添加了一个新的基本类型成员int j。大家也许认为自己需要再次覆盖clone(),以确保j得到复制,但实情并非如此。将Int2的clone()当作Int3的clone()调用时,它会调用Object.clone(),判断出当前操作的是Int3,并复制Int3内的所有二进制位。只要没有新增需要克隆的句柄,对Object.clone()的一个调用就能完成所有必要的复制——无论clone()是在层次结构多深的一级定义的。 至此,大家可以总结出对Vector进行深层复制的先决条件:在克隆了Vector后,必须在其中遍历,并克隆由Vector指向的每个对象。为了对Hashtable(散列表)进行深层复制,也必须采取类似的处理。 这个例子剩余的部分显示出克隆已实际进行——证据就是在克隆了对象以后,可以自由改变它,而原来那个对象不受任何影响。12.2.8 通过序列化进行深层复制 若研究一下第10章介绍的那个Java 1.1对象序列化示例,可能发现若在一个对象序列化以后再撤消对它的序列化,或者说进行装配,那么实际经历的正是一个“克隆”的过程。 那么为什么不用序列化进行深层复制呢?下面这个例子通过计算执行时间对比了这两种方法: //: Compete.java import java.io.*;class Thing1 implements Serializable {} class Thing2 implements Serializable { Thing1 o1 =new Thing1(); }class Thing3 implements Cloneable { public Object clone() { Object o = null; try { o =super.clone(); } catch (CloneNotSupportedException e) { System.out.println("Thing3 can'tclone"); } return o; } }class Thing4 implements Cloneable { Thing3 o3 = new Thing3(); public Object clone() {Thing4 o = null; try { o = (Thing4)super.clone(); } catch (CloneNotSupportedException e) {System.out.println("Thing4 can't clone"); } // Clone the field, too: o.o3 = (Thing3)o3.clone();return o; } }52212.2 制作本地副本public class Compete { static final int SIZE = 5000; public static void main(String[] args) {Thing2[] a = new Thing2[SIZE]; for(int i = 0; i < a.length; i++) a[i] = new Thing2(); Thing4[] b= new Thing4[SIZE]; for(int i = 0; i < b.length; i++) b[i] = new Thing4(); try { long t1 =System.currentTimeMillis(); ByteArrayOutputStream buf = new ByteArrayOutputStream();ObjectOutputStream o = new ObjectOutputStream(buf); for(int i = 0; i < a.length; i++)o.writeObject(a[i]); // Now get copies: ObjectInputStream in = new ObjectInputStream( newByteArrayInputStream( buf.toByteArray())); Thing2[] c = new Thing2[SIZE]; for(int i = 0; i

1.11.21.31.41.4.11.4.21.4.31.4.41.4.51.4.61.4.71.4.81.4.91.4
1.6.11.6.21.6.31.6.41.71.7.11.7.21.7.31.7.41.7.51.7.61.7.71.
1.10.31.10.41.10.51.10.61.10.71.10.81.10.91.10.101.111.11.11
1.13.41.13.51.13.61.13.71.13.81.13.91.13.101.13.111.141.14.1
还剩 883页未读,点此继续全文在线阅读

免费下载Thinking in Java (Java 编程思想)到电脑,使用更方便!

本文推荐: Thinking in Java (Java 编程思想).pdf全文阅读下载  关键词: java  
学文库温馨提示:文档由用户自行上传分享,文档预览可能有差异,下载后仅供学习交流,未经上传用户书面授权,请勿作他用。 文档下载资源交流QQ群:317981604

Thinking in Java (Java 编程思想)pdf目录

其他相关文档

文档相关搜索

< / 887>

QQ|小黑屋|网站声明|网站地图|学文库 ( 冀ICP备06006432号 )

GMT+8, 2020-7-16 02:40 , Processed in 1.175394 second(s), 5 queries , Gzip On, Redis On.

Powered by 学文库 1.0

Copyright © 2019-2020, 学文库

返回顶部