一、找一款java游戏,2.5D的欧美风格动作冒险游戏

1、勇者斗恶龙11

这是一款由Square Enix制作并发执行的动作冒险游戏。游戏中男主角在一座小村庄Ishi长大，16岁后村庄为他举办了传统的成人仪式，在仪式上他得知自己正是传说中拯救全球的“勇者”转生，而他也将背负着重大的使命。为了了解有关勇者的一切，主角离开家乡踏上了冒险之旅。

游戏特别好玩啊，剧情也很棒。而且战斗场面有两个选项，壹个就是在地图瞎跑，另壹个就是跟dq8战斗风格一样可以自动切换镜头(但不能走动)。唯一有点坑的就是支线任务，尤其在城里绕了大半圈都没找到人的。

2、仙剑奇侠传4

仙剑系列推出到现在已故事了10余个年头，无数玩家受其中凄美的爱情感召而落泪。4代的剧情风格会异于三代和三代外传，除了将更加突显中国文化，也将更创造和复古兼备地呈现仙剑文化。在武侠神怪全球观的基础上，发挥以情动人、咏物关情，融合剑仙、江湖、修道等要素，绘制出一幅旷世情缠的柔情悲剧之画卷。

故事的起点始于黄山青鸾峰之巅，驰骋于神州大地、往来于天地之间，东临渤海、南抵巴蜀、北至传说中的“北极之地”、西达上古圣山昆仑仙境。既有繁华热闹、歌舞升平的中原富庶之地，又有大漠边关、丝绸之路上的小小驿站。每壹个城镇之中的建筑、草木，乃至于店中出售的食物，都各有其特色。游戏的剧情受人称赞，迷宫难度较前几代有所降低，而且在国内单机游戏日渐式微的4代更具独特意义。

3、废品机械师

这是一款Axolot Games制作并发行的人物扮演游戏。该作以生存为主调，玩家将扮演一名清道夫，在随机生成的全球中寻觅，收集素材，并制作出各种有意思的物品，包括建筑、机器以及车辆等。

4、二之国2：亡灵之国

这是由日式巨商Level 5打造的《二之国》系列正统续作，该系列用动人的故事、创造的操作和惊叹的艺术效果，在RPG领域开辟了一篇新领域。其出色的吉卜力的风格和故事表现手法，让玩家能够感受到《二之国》这款特别日式的游戏的魔力。

本作讲述壹个少年成长为国王的故事，玩家将在在成长经过中遇到了各种各样的人，发生各种各样的事，最后成为一名出色的国王。制作组将这些体系、故事、画面等各种要素相结合，创作了壹个带有人情味的全球性的作品，并继前作之后继续挑战新的高峰，把这种风格发挥到了更理想的水准。

5、永恒之柱2：死亡之火

这是由Obsidian Entertainment制作并发行的一款人物扮演游戏。本作依旧沿用了前作的上帝视角，然而无论是在音效、画面、UI还是游戏的建模、剧情，都有了综合的提高。而且游戏的官方中文玩家们也都等于一致地给出了高度的评价。

在本作中光和重生之神Eothas将会回归，这位此前曾被认为已经死亡了的人物目前正栖身于壹个石巨人的体内，而这个石巨人已经在玩家们的主城下方沉睡上了千年之久。当他从地底下苏醒的时候破坏了玩家们的庇护所，局势危在旦夕。游戏中的人物们都有自己的生活和职业，也有各自奋斗的目标，因此即使你不在游戏中他们仍然会继续着这些活动主题，进行中的任务也会由于届时的人物情形和环境而出现不同的机会和变化。

6、英雄传说：闪之轨迹

游戏最大的壹个亮点就是画面的进化，人物也从之前的Q版形象变为了正常比例，而且本作无论在战斗、剧情演出等方面都比之前的系列作品有大幅提高。游戏的舞台是泽姆利亚大陆上的帝国，背景设定是和《空轨》同时代、同一全球。

战斗依然采用指令式，然而速度感特别强，通过同伴之间的羁绊之力可以实现压倒性的战略。在移动、街道和对话的时候，人物都会有各种各样的语音演出。在地图中可以360度旋转镜头，让玩家尝试到更加丰盛的场景魔力

二、童年java动作小游戏主角能连招的游戏

童年Java动作小游戏中主角能连招的游戏有《全球武术巡回赛》。

《全球武术巡回赛》是一款在童年时期备受欢迎的Java动作小游戏。该游戏以其特殊的格斗机制和丰盛的连招体系而著称，让玩家在操控人物进行战斗时能够尝试到极高的游戏趣味。

游戏特征：

经典风格：游戏采用了典范的经典风格，画面简洁明了，色彩组合和谐，让玩家仿佛回到了那个充满回忆的年代。连招攻击：玩家可以操控人物进行各种连招攻击，通过组合不同的按键来释放出瑰丽的招式，让战斗更加刺激和有趣。格斗尝试：游戏提供了丰盛的格斗元素，包括不同的人物选择、多样的攻击方法和防御诀窍，让玩家能够充分尝试到格斗游戏的魔力。挑战性：游戏中的关卡设计巧妙，敌人种类繁多，难度逐渐提高，需要玩家不断练习和提高自己的格斗诀窍才能顺利通关。《全球武术巡回赛》不仅是一款能够唤起玩家童年回忆的游戏，更是一款能够锻炼玩家反应能力和格斗诀窍的典范之作。如果你对格斗游戏感兴趣，不妨尝试一下这款游戏，相信它会给你带来不一样的游戏尝试。

三、怎样写出好的Java代码

怎样写出好的Java代码

1．优雅需要付出代价。

从短期利益来看，对某个难题提出优雅的化解方式，似乎也许花你更多的时刻。但当它终于能够正确执行并可轻易套用于新案例中，不需要花上数以时计，甚至以天计或以月计的辛苦代价时，你会看得到先前所花功夫的回报（即使没有人可以衡量这一点）。这不仅给你壹个可更容易开发和调试的程序，也更易于领会和维护。这正是它在金钱上的价格所在。这一点有赖某种人生经验才能够了解，由于当你努力让某一段程序代码变得相对优雅时，你并不是处于一种具生产力的情形下。请抗拒那些催促你赶工的大众，由于那么做只会减缓你的速度罢了。

2．先求能动，再求快。

即使你已确定某段程序代码极为重要，而且是体系的重要瓶颈，这个准则依然成立。尽也许简化设计，让体系能够先正确动作。如果程序的执行不够快，再量测其效能。几乎你总是会发现，你所认为的”瓶颈”其实都不是难题所在。把你的时刻花在刀口上吧。

3．记下”各个击破”的原理。

如果你所探讨的难题过于混杂，试着想像该难题的基本动作会是啥子，并假设这一小块物品能够神奇地处理掉最难的部分。这”一小块”物品其实就是对象–请撰写运用该对象的程序代码，接着检视对象，并将其中困难的部分再包装成其他对象，依此类推。

4．区分class开发者和class运用者（运用端程序员）。

Class运用者扮演着”客户”人物，不需要（也不了解）class的底层运作方法。Class开发者必须是class设计专家，并撰写class，使它能够尽也许被大多数新人程序员所用，而且在程序中能够稳当执行。一套程序库只有在具备通透性的情况下，运用起来才会容易。

5．当你撰写class时，试着给予明了易懂的名称，减少不必要的注解。

你给客户端程序员的接口，应该保持概念上的单纯性。不了这个目的，当函数的重载（overloading）适合制作出直觉、易用的接口时，请善加运用。

6．也必你的解析和设计必须让体系中的classes保持最少，须让其Public interfaces保持最少，以及让这些classes和其他classes之间的关联性（尤其是base classes）保持最少。

如果你的设计所得结局更甚于此，请问问自己，是否其中每一样物品在整个程序生活期中都饶富价格？如果并非如此，维护它们会使你付出代价。开发团队的成员都有不维护”无益于生产力提高”的任何物品的倾给；这是许多设计方式无法解释的现象。

7．让全部物品尽量自动化。先撰写测试用的程序代码（在你撰写class之前），并让它和class结合在一起。请运用makefile或类似工具，自动进行测试动作。

通过这种方法，只要执行测试程序，全部的程序变动就可以自动获取验证，而且可以立即发现错误。由于你了解的测试架构所具备的安全性，因此当你发现新的需求时，你会更勇于进行综合修改。程序语言最大的改进，是来自型别检查、异常处理等机制所赋予的内置测试动作。但这些功能只能协助你到达某种程度。开发壹个稳固体系时，你得自己验证自己的classes或程序的性质。

8．在你撰写class之前先写测试码，以便验证你的class是否设计完备。如果你无法撰写测试码，你便无法了解你的class的也许长相。撰写测试码通常能够显现出额外的特性（features）或限制( constraints)__它们并不一定总是能够在解析和设计经过中出现。测试码也可做为展示class用法的示例程序。

9．全部软件设计上的难题，都可以通过”引入额外的概念性间接层（conceptual indirection）”加以简化。这个软件工程上的基础法则是抽象化概念的根据，而抽象化概念正是面给对象程序设计的主要性质。

10．间接层(indirection)应该要有意义（和准则-9致）。

这里所指的意义可以像”将共用程序代码置于惟一函数”这么简单。如果你加入的间接层（或抽象化、或封装等等）不具意义，它也许就和没有适当的间接层一样糟糕。

11．让class尽也许微小而无法切割（atomic）。

赋予每个class单一而清楚的用途。如果你的classes或你的体系成长得过于复杂，请将复杂的classes切割成相对简单的多少classes。最明显的壹个判断指针就是class的大致：如果它很大，那么它职业量过多的机会就也许很高，那就应该被切割。从头设计class的提议线索是：

1）复杂的switch语句：请思考运用多态（Polymorphism）。

2）许多函数各自处理类型极为不同的动作：请思考切割为多个不同的（classes）。

12．小心冗长的引数列（argument lists）。

冗长的引数列会使函数的调用动作不易撰写、阅读、维护。你应该试着将函数搬移到更适当的class中，并尽量以对象为引数。

13．不要一再重复。

如果某段程序代码不断出现于许多derived class函数中，请将该段程序代码置于某个base class函数内，接着在derived class函数中调用。这么做不仅可以省下程序代码空间，也可以让修改该段程序代码动作更易于进行。有时候找出此种共通程序代码还可以为接口增加实用功能。

14．小心switch语句或成串的if-else子句。

通常这种情况代表所谓的”type-check coding”。也就是说到底会执行哪一段程序代码，乃是依据某种型别信息来做抉择（开始，确切型别也许不特别明显）。你通常可以运用继承和多态来取代此类程序代码；Polymorphical method（多态函数）的调用会自动执行此类型别检验，并提供更可靠更容易的扩充性。

15．从设计见解来看，请找出变动的事物，并使它和不变的事物分离。

也就是说，找出体系中也许被你改变的元素，将它们封装于classes中。你可以在《Thinking in Patterns with Java》（可不收费下载于 www. BruceEckel. Com）大量进修到这种意识。

16．不要利用subclassing来扩充基础功能。

如果某个接口元素对class而言极重要，它应该被放在base class里头，而不是直到衍生（derivation）时才被加入。如果你在继承经过中加入了函数，或许你应该从头思索整个设计。

17．少就是多。

从class的最小接口开始妨展，尽也许在化解难题的前提下让它保持既小又单纯。不要预先考量你的class被运用的全部也许方法。一旦class被实际运用，你天然会了解你得怎样扩充接口。一旦class被运用后，你就无法在不影响客户程序代码的情况下缩减其接口。如果你要加入更多函数倒是没有难题–不会影响既有的客户程序代码，它们只需从头编译即可。但即使新函数取代了旧函数的功能，也请你保留既有接口。如果你得通过”加入更多引数”的方法来扩充既有函数的接口，请你以新引数写出壹个重载化的函数；通过这种方法就不会影响既有函数的任何客户了。

18．大声念出你的classes,确认它们符合逻辑。

请base class和derived class之间的关系是”is-a”(是一种)，让class和成员对象之间的关系是”has-a”(有壹个)。

19．当你犹豫不决于继承（inheritance）或合成（组合，composition）时，请你问问自己，是否需要给上转型（upcast）为基础型别。

如果不需要，请优先选择合成（也就是是运用成员对象）。这种作法可以消除”过多基础型别”。如果你采用继承，运用者会认为他们应该可以给上转型。

20．运用数据成员来表示数值的变化，运用经过覆写的函数（overrided method）来代表行为的变化。

也就是说，如果你找到了某个 class,带有一些情形变量，而其函数会依据这些变量值切换不同的行为，那么你或许就应该从头设计，在subclasses和覆写后的函数（overrided methods）中展现行为止的差异。

21．小心重载（overloading）。

函数不应该依据引数值条件式地选择执行某一段程序代码。这种情况下你应该撰写两个或更多个重载函数（overloaded methods）

22．运用异常体系（exception hierarchies）

最好是从Java标准异常体系中衍生特定的classes,捕捉异常的人便可以捕捉特定异常，之后才捕捉基本异常。如果你加入新的衍生异常，原有的客户端程序仍能通过其基础型别来捕捉它。

23．有时候简单的聚合（aggregation）就够了。

飞机上的”旅客舒适体系”包括数个分离的元素：座椅、空调、视讯设备等等，你会需要在飞机上产生许多这样的物品。你会将它们声明为Private成员并开发出壹个最新的接口吗？不会的，在这个例子中，元素也是Public接口的一部分，因此仍然是安全的。当然啦，简单聚合并不一个常被运用的解法，但有时候的确是。

24．试着从客户程序员和程序维护的角度思索。

你的class应该设计得尽也许容易运用。你应该预先考量也许性有的变动，并针对这些也许的变动进行设计，使这些变动日后可轻易完成。

25．小心”巨大对象并发症”。

这往往是刚踏OOP领域的经过式（procedural）程序员的壹个苦恼，由于他们往往最终还是写出壹个经过式程序，并将它们摆放到壹个或两个巨大对象中。注意，除了application framework(应用程序框架，译注：一种很独特的、大型OO程序库，帮你架构程序本体)之外，对象代表的是程序中的意识，而不是程序本身。

26．如果你得用某种丑陋的方法来达成某个动作，请将丑陋的部分局限在某个class里头。

27．如果你得用某种不可移植方法来达成某个动作，请将它抽象化并局限于某个class里头。这样壹个”额外间接层”能够防止不可移植的部分扩散到整个程序。这种作法的具体呈现便是Bridge设计玩法（design pattern）。

28．对象不应仅仅只用来持有数据。

对象也应该具有定义明确界限清楚的行为。有时候运用”数据对象”是适当的，但只有在通用形容器不适用时，才适合刻意以数据对象来包装、传输一群数据项。

29．欲从既有的classes身上产生新的classes时，请以组合(composition)为优先考量。

你应该只在必要时才运用继承。如果在组合适用之处你却选择了继承，你的设计就渗杂了非必要的复杂性。

30．运用继承和函数覆写机制来展现行为上的差异，运用fields(数据成员)来展现情形上的差异。

这句话的极端例子，就是继承出不同的classes表现各种不同的颜色，而不运用”color”field.

31．当心变异性（variance）。

语意相异的两个对象拥有相同的动作（或说职责）是也许的。OO全球中存在着一种天生的引诱，让人想要从某个class继承出另壹个subclass,为的是获取继承带来的福利。这便是所谓”变异性”。没有任何正当理由足以让大家强迫制造出某个其实并不存在的superclass/subclass关系。相对好的化解方法是写出壹个共用的base class,它为两个derived classes制作出共用接口–这种方法会耗用更多空间，但你可以如你所盼望地从继承机制获取好处，而且或许能够在设计上获取重大发现。

32．注意继承上的限制。

最清晰易懂的设计是将功能加到继承得来的class里头；继承经过中拿掉旧功能（而非增加新功能）则是一种可疑的设计。制度可以打破。如果你所处理的是旧有的class程序库，那么在某个class的subclass限制功能，也许会比从头制定整个结构（俾使新class得以良好地相称于旧 class）有效率得多。

33．运用设计玩法（design patterns）来减少”赤裸裸无加掩饰的机能（naked functionality）”。

举个例子，如果你的class只应该产出惟一壹个对象，那么请不要以加思索毫无设计的手法来完成它，接着撰写”只该产生一份对象”这样的注解就拍拍屁股走人。请将它包装成singleton（译注：壹个有名的设计玩法，可译为”单件”）。如果主程序中有多而混乱的”用以产生对象”的程序代码，请找出类似 factory method这样的生成玩法（creational patterns），使价钱可用以封装生成动作减少”赤裸裸无加掩饰的机能”（naked functionality）不仅可以让你的程序更易领会和维护，也可以阻止出于好意却带来意外的维护者。

34．当心”因解析而导致的瘫痪（analysis paralysis）”。

你往往必须在获取全部信息之前让项目继续前进。而且领会未知部分的最好也更快的方法，通常就是实际前进一步而不只是纸上谈兵。除非找到化解办法，否则无法了解化解办法。Java拥有内置的防火墙，请让它们发挥影响。你在单一class或一组classes中所犯的错误，并不会伤害整个体系的完整性。

35．当你认为你已经获取一份杰出的解析、设计或实现时，请试着加以演练。

将团队以外的某些人带进来-他不必非得是个顾问不可，他可以是企业其他团队的成员。请那个人以新鲜的姿态审视你们的成果，这样可以在尚可轻易修改的阶段找出难题，其收获会比因演练而付出的时刻和金钱代价来得高。实现（Implementation）

36.请遵守Sun的程序编写习性。

价钱可以在下面内容网址找到相关文档：java.sun.com/docs/codeconv/idex.html。本书尽也许遵守这些习性。众多Java程序员看到的程序代码，都有是由这些习性构成的。如果你固执地停留在过去的编写风格中，你的（程序代码）读者会相对辛苦。不论你决定采用啥子编写习性，请在整个程序中保持一致。你可以在home.wtal.de/software-solutions/jindent上找到壹个用来重排Java程序的不收费工具。

37.无论运用何种编写风格，如果你的团队（或整个企业，那就更好了）能够加以标准化，那么的确会带来显著效果。这代表每个人都可以在其他人不遵守编写风格修改其作品，这是个公正的游戏。标准化的价格在于，解析程序代码时所花的脑力较小，因而可以专心于程序代码的实质意义。

38.遵守标准的大致写规范。

将 class名称的第壹个字母应为大写。数据成员、函数、对象（references）的第壹个字母应为小写。全部识别名称的每个字都应该连在一块儿，全部非首字的第壹个字母都应该大写。例如： ThisIsAClassName thisIsAMethodOrFieldName如果你在static final基本型别的定义处指定了常量初始式（constant initializers）,那么该识别名称应该全为大写，代表壹个编译期常量。 Packages是个特例，其名称皆为小写，即使非首字的字母亦是如此。域名（org, net, edu等等）皆应为小写。（这是Java 1.1迁移至Java 2时的一项改变）。

39、不要自己发明”装饰用的”Private数据成员名称。

通常这种的形式是在最前端加上底线和其他字符，匈牙利命名法（Hungarian notation）是其中最差的示范。在这种命名法中，你得加入额外字符来表示数据的型别、用途、位置等等。仿佛你用的是汇编语言（assembly language）而编译器没有提供任何协肋似的。这样的命名方法容易让人混淆又难以阅读，也不易推行和维护。就让classes和packages来进行”名称上的范

围制定（name scoping）”吧。

40、当你拟定通用性的class时，请遵守正规形式（canonical form）。

包括equals()、hashCode()、clone()(实现出Cloneable),并实现出Comparable和Serialiable等等。

41、对于那些”取得或改变Private数据值”的函数，请运用Java Beans的”get”、”set”、”is”等命名习性，即使你当时不认为自己正在撰写Java Bean。这么做不仅可以轻易以Bean的运用方法来运用你的class,也是对此类函数的一种标准命名方法，使读者更易于领会。

42、对于你所拟定的每壹个class，请思考为它加入static public test()，其中含有class功能测试码。

你不需要移除该测试就可将程序纳入项目。而且如果有所变动，你可以轻易从头执行测试。这段程序代码也可以做为class的运用示例。

43、有时候你需要通过继承，才得以访问base class的protected成员。

这也许会引发对多重基类（multiple base types）的认识需求。如果你不需要给上转型，你可以先衍生新的class发便执行protected访问动作，接着在”需要用到上述 protected成员”的全部classes中，将新class声明为成员对象，而非直接继承。

44、避免纯粹为了效率考量而运用final函数。

只有在程序能动但执行不够快时，而且效能量测工具（profiler）显示某个函数的调用动作成为瓶颈时，才运用final函数。

45、如果两个classes因某种功能性缘故而产生了关联（例如容器containers和迭代器iterators）,那么请试着让其中某个class成为另壹个class的内隐类（inner class）。

这不仅强调二者间的关联，也是通过”将class名称嵌套置于另壹个class内”而使同壹个class名称在单一Package中可被重复运用。Java容器库在每个容器类中都定义了壹个内隐的（inner）Iterator class,因而能够提供容器一份共通接口。运用内隐类的另壹个缘故是让它成为private实现物的一部分。在这里，内隐类会为信息隐藏带来好处，而不是对上述的class关联性提供肋益，也不是为了防止命名空间污染难题(namespace pollution)。

46、任什么时候候你都要注意那些高度耦合（coupling）的 classes.请思考内隐类（inner classes）为程序拟定和维护带来的好处。内隐类的运用并不是要去除classes间的耦合，而是要让耦合关系更明显也更便利。

47、不要成为”过早最佳化”的牺牲品。

那会让人神经错乱。尤其在体系建构初期，先别烦恼到底要不要撰写（或避免）原生函数（native methods）、要不要将某些数声明为final、要不要调校程序代码效率等等。你的主要难题应该是先证明设计的正确性，除非设计本身需要某种程度的效率。

48、让范围（影响域，scope）尽也许愈小愈好，这么一来对象的可视范围和寿命都将尽也许地小。

这种作法可降低”对象被用于错误场所，因而隐藏难以察觉的臭虫”的机会。假设你有个容器，以及一段走访该容器的程序片段。如果你复制该段程序代码，将它用于新的容器身上，你也许会不小心以旧容器的大致做为新容器的走访上限值。如果旧容器已不在访问范围内，那么编译期便可找出这样的错误。

49、运用Java标准程序库提供的容器。

请熟悉他们的用法。你将因此大幅提高你的生产力。请优先选择ArrayList来处理序列（sequences），选择HashSet来处理集中（sets）、选择HashMap来处理关联式数组（associative arrays），选择Linkedlist(而不是Stack)来处理 shacks和queues。

50、对壹个强固的（robust）程序而言，每壹个组成都必须强固。

请在你所撰写的每个class中运用Java提供的全部强固提高工具：访问权限、异常、型别检验等等。通过这种方法，你可以在建构体系时安全地移往抽象化的下壹个层次。

51、宁可在编译期发生错误，也不要在执行期发生错误。

试着在最靠近难题发生点的地方处理难题。请优先在”掷出异常之处”处理难题，并在拥有足够信息以处理异常的最接近处理函数（handler）中捕捉异常。请进行现阶段你能够对该异常所做的处理；如果你无法化解难题，应该再次掷出异常。

52、当心冗长的函数定义。

函数应该是一种简短的、”描述并实现class接口中某个可分离部分”的功能单元。过长且复杂的函数不仅难以维护，维护代价也高。或许它尝试做太多事务了。如果你发现这一类函数，代表它应该被切割成多相函数。这种函数也提醒你或许得撰写新的class。小型函数同样能够在你的class中被重复运用。（有时候函数必须很大才行，但它们应该只做一件事务。）

53、尽也许保持”Private”。

一旦你对外公开了程序库的概况（method、Class或field）。你便再也无法移除它们。由于如果移除它们，便会破坏某个现有的程序代码，使得它们必须从头被编写或从头设计。如果你只公开必要部分，那么你便可以改变其他物品而不造成伤害。设计总是会演化，因此这是个特别重要的自在度。通过这种方法，实现码的更动对derived class造成的冲击会降最低。在多线程环境下，私密性格外重要-只有private数据可受保护而不被un-synchronized（未受同步控制）的运用所破坏。

54、大量运用注解，并运用javadoc的”注解文档语法”来产生程序的说明文档。

不过注解应该赋予程序代码真正的意义；如果只是重申程序代码已经明确表示的内容，那是很烦人的。请注意，通常Java class和其函数的名称都很长，为的便是降低注解量。

55、避免运用”魔术数字”，也就是那种写死在程序代码里头的数字–如果你想改变它们，它们就会成为你的恶梦，由于你永远都没有办法了解”100″到底代表”数组大致”或其他物品。你应该产生具描述性的常量度名称，并在程序中运用该常量名称。这使程序更易于领会也更易于维护。

56、撰写构造函数时，请思考异常情形。最好情境下，构造函数不执行任何会掷出异常的动作。

次佳情境下，class只继承自（或合成自）强固的（robust）classes，因此如有任何异常被掷出，并不需要清理。其他情况下，你就得在finally子句清理合成后的classes。如果某个构造函数一定会失败，适当的动作就是掷出异常，使调用者不至于盲目认为对象已被正确产生而继续执行。

57、如果你的class需要在”客户程序员用完对象”后进行清理动作，请将清理动作，放到单一而定义明确的函数中。最好令其名称为cleanup()以便能够将用途告知他人。除了这些之后请将boolean旗标放到class中，用以代表对象是否已被清理，使finalize()得以检验其死亡条件（请参考第 4章）。

58、finalize()只可用于对象死亡条件的检验（请参考4章），俾有益于调试。

独特情况下也许需要释放一些不会被垃圾回收的内存。由于垃圾回收器也许不会被唤起处理你的对象，因此你无法运用finalize()执行必要的清理动作。基于这个缘故，你得拟定自己的”清理用”函数。在class finalize()中，请检查确认对象的确已被清理，并在对象尚未被清理时，掷出衍生自Runtime Exception的异常。运用这种架构前，请先确认finalize()在你的体系上可正常动作（这也许需要调用System.gc()来确认）。

59、如果某个对象在某个特定范围（scope）内必须被清理（cleaned up）,而不是被垃圾回收机制收回，请运用下面内容方式；将对象初始化，成功后立刻进入拥有finally子句的壹个try区段内。Finally子句会引发清理动作。

60、当你在继承经过中覆写了finalize(),请记得调用super. Finalize()。

但如果你的”直接上一层superclass”是Object，，就不需要这个动作。你应该让super.finalize()成为被覆写（overridden）之finalize()的最后壹个动作而不是第壹个动作，用以确保base class的组件在你需要它们的时候仍然可用。

61、当你撰写固定大致的对象容器，请将它们转换为数组–尤其是从某个函数返回此一容器时。

通过这种方法，你可以获取数组的”编译期型别检验”的好处，而且数组接收者也许不需要”先将数组中的对象加以转型”便能加以运用。请注意，容器库的base class(Java. Util. Collection)具有两个toArray()，能够达到这个目的。

62、在interface(接口)和abstract class(抽象类)之间，优先选择前者。

如果你了解某些物品马上被设计为壹个base class,你的第一选择应该是让它成为interface;只有在一定得放进函数或数据成员时，才应该将它改为abstract class. Interface只和”客户端想进行啥子动作”有关，class则相对把重心放在实现细节上。

63、在构造函数中只做惟一必要动作：将对象设定至适当情形。

避免调用其他函数（除了final函数），由于这些函数也许会被其他人覆写因而使你在建构经过中得不可预期的结局（请参考第7章以取得更详细的信息）。小型而简单的构造函数相对不也许掷出异常或引发难题。

64、为了避免壹个特别令人泄气的经验，请确认你的classpath中的每个名称，都只有壹个未被放到packages里头class。否则编译器会先找到另壹个名称相同的class，并回报错误消息。如果你怀疑你的classpath出了难题，试着从classpath中的每个起点查找同名的.class文件。最好还是将全部classes都放到packages里头。

65、留意一不小心犯下的重载（overloading）错误。

如果你覆写base class函数时没有正确拼写其名称，那么便会增加壹个新的函数，而不是覆写原有的函数。然而情况完全合法，因此你不会从编译器或执行期体系得到任何错误消息–你的程序代码只是无法正确影响，如此而已。

66、当心过早最佳化。

先让程序动起来，再让它快–但只有在你必须（也就是说只有在程序被证明在某段程序代码上遭遇效能瓶颈）时才这么做。除非你已经运用效能量测工具（profiler）找出瓶颈所在，否则你也许性只是在浪费你的时刻。效能调校的”隐藏成本”便是让你的程序代码变得更不可读、更难维持。

67、程序代码被阅读的时刻多于它被撰写的时刻。

清晰的设计能够制作出去易懂的程序。注解、细节说明、示例都是无价的。这些物品能够帮助你和你的后继者。如果没有其他信息，那么Java线上文档找出一些有用的信息时，你所遭遇的挫败应该足以让你相信这一点。