JAVA代码精简之道 简短的java代码

做java软件工程师，怎样才能写出好的代码？

Java代码之于java程序员而言就是左膀右臂，java代码写的好的java程序员明显更是企业的欢迎，一个优秀的java程序员的考核标准之一也是看他的编程水平。

创新互联建站长期为上千余家客户提供的网站建设服务，团队从业经验10年，关注不同地域、不同群体，并针对不同对象提供差异化的产品和服务；打造开放共赢平台，与合作伙伴共同营造健康的互联网生态环境。为集安企业提供专业的网站设计制作、成都网站制作，集安网站改版等技术服务。拥有10年丰富建站经验和众多成功案例,为您定制开发。

其实有的java程序员java代码会受到大家的追捧，是因为他在写代码时注意的细节往往多于那些不怎么关注java代码编程细节的程序员，俗话说：“细节决定成败”，那么如何写出好的java代码呢？IT培训介绍一起来讨论下：

1.重视注释

有的java程序员在写代码时，从来没有想过要在java代码后加上相关的注释，甚至是上万行的代码也没有想过加上注释，这就存在很大的问题，不说你的代码会跟其他人分享讨论，就你自己回顾你是怎么写好这篇代码的，你也是半天无法理出头绪，这就为维护和修改等等工作添加了很大的麻烦。所以，要想写出好的java代码，一定从简短的java代码编写开始注重在java代码后面加上相应的注释，养成良好的习惯。

2.重视排版整洁

看很多java程序员的排版总觉得在欣赏一幅艺术品，但是看到一些java程序员的排版却总觉得无力吐槽。同样是编写代码，但是给人的视觉体验是相当的不同，当然好的java代码给人的享受也是美的，所以要想写出好的代码，一定要重视排版整洁。

3.注重命名规则

现在在一个团队开发中，都会提前定制一个统一的命名规则，这样利于提高工作效益。但是很多java程序员是缺乏这个意识的，每次敲代码，更喜欢按照自己惯常的方式老命名模块、函数，这样是方便了自己，但是忽视团队协作，所以在日常工作中，特别是团队工作中一定要重视命名规则。

4.养成备份习惯

备份的重要性不用小编强调，相必你也知道。但是有的java程序员就是没有养成这样的好习惯，每次敲完代码就不记得随手保存，每次等到除了事故，比如电脑出了故障，辛辛苦苦敲打的java代码没保存找不回来的情况下就开始懊恼，与其这样还不如在一开始就养成良好的备份习惯，这样也方便自己日后查找利用。

如何优化JAVA代码及提高执行效率

可供程序利用的资源（内存、CPU时间、网络带宽等）是有限的，优化的目的就是让程序用尽可能少的资源完成预定的任务。优化通常包含两方面的内容：减小代码的体积，提高代码的运行效率。本文讨论的主要是如何提高代码的效率。

在Java程序中，性能问题的大部分原因并不在于Java语言，而是在于程序本身。养成好的代码编写习惯非常重要，比如正确地、巧妙地运用java.lang.String类和java.util.Vector类，它能够显著地提高程序的性能。下面我们就来具体地分析一下这方面的问题。

1、 尽量指定类的final修饰符带有final修饰符的类是不可派生的。在Java核心API中，有许多应用final的例子，例如java.lang.String。为String类指定final防止了人们覆盖length()方法。另外，如果指定一个类为final，则该类所有的方法都是final。Java编译器会寻找机会内联（inline）所有的final方法（这和具体的编译器实现有关）。此举能够使性能平均提高50%

。

2、 尽量重用对象。特别是String 对象的使用中，出现字符串连接情况时应用StringBuffer 代替。由于系统不仅要花时间生成对象，以后可能还需花时间对这些对象进行垃圾回收和处理。因此，生成过多的对象将会给程序的性能带来很大的影响。

3、 尽量使用局部变量，调用方法时传递的参数以及在调用中创建的临时变量都保存在栈（Stack）中，速度较快。其他变量，如静态变量、实例变量等，都在堆（Heap）中创建，速度较慢。另外，依赖于具体的编译器/JVM，局部变量还可能得到进一步优化。请参见《尽可能使用堆栈变量》。

4、 不要重复初始化变量 默认情况下，调用类的构造函数时，

Java会把变量初始化成确定的值：所有的对象被设置成null，整数变量（byte、short、int、long）设置成0，float和double变量设置成0.0，逻辑值设置成false。当一个类从另一个类派生时，这一点尤其应该注意，因为用new关键词创建一个对象时，构造函数链中的所有构造函数都会被自动调用。

5、 在JAVA + ORACLE 的应用系统开发中，java中内嵌的SQL语句尽量使用大写的形式，以减轻ORACLE解析器的解析负担。

6、 Java 编程过程中，进行数据库连接、I/O流操作时务必小心，在使用完毕后，即使关闭以释放资源。因为对这些大对象的操作会造成系统大的开销，稍有不慎，会导致严重的后果。

7、 由于JVM的有其自身的GC机制，不需要程序开发者的过多考虑，从一定程度上减轻了开发者负担，但同时也遗漏了隐患，过分的创建对象会消耗系统的大量内存，严重时会导致内存泄露，因此，保证过期对象的及时回收具有重要意义。JVM回收垃圾的条件是：对象不在被引用；然而，JVM的GC并非十分的机智，即使对象满足了垃圾回收的条件也不一定会被立即回收。所以，建议我们在对象使用完毕，应手动置成null。

8、 在使用同步机制时，应尽量使用方法同步代替代码块同步。

9、 尽量减少对变量的重复计算

例如：for(int i = 0;i list.size; i ++) {

…

}

应替换为：

for(int i = 0,int len = list.size();i len; i ++) {

…

}

10、尽量采用lazy loading 的策略，即在需要的时候才开始创建。

例如： String str = “aaa”;

if(i == 1) {

list.add(str);

}

应替换为：

if(i == 1) {

String str = “aaa”;

list.add(str);

}

11、慎用异常

异常对性能不利。抛出异常首先要创建一个新的对象。Throwable接口的构造函数调用名为fillInStackTrace()的本地（Native）方法，fillInStackTrace()方法检查堆栈，收集调用跟踪信息。只要有异常被抛出，VM就必须调整调用堆栈，因为在处理过程中创建了一个新的对象。异常只能用于错误处理，不应该用来控制程序流程。

12、不要在循环中使用：

Try {

} catch() {

}

应把其放置在最外层。

13、StringBuffer 的使用：

StringBuffer表示了可变的、可写的字符串。

有三个构造方法 :

StringBuffer (); //默认分配16个字符的空间

StringBuffer (int size); //分配size个字符的空间

StringBuffer (String str); //分配16个字符+str.length()个字符空间

你可以通过StringBuffer的构造函数来设定它的初始化容量，这样可以明显地提升性能。这里提到的构造函数是StringBuffer(int

length)，length参数表示当前的StringBuffer能保持的字符数量。你也可以使用ensureCapacity(int

minimumcapacity)方法在StringBuffer对象创建之后设置它的容量。首先我们看看StringBuffer的缺省行为，然后再找出一条更好的提升性能的途径。

StringBuffer在内部维护一个字符数组，当你使用缺省的构造函数来创建StringBuffer对象的时候，因为没有设置初始化字符长度，StringBuffer的容量被初始化为16个字符，也就是说缺省容量就是16个字符。当StringBuffer达到最大容量的时候，它会将自身容量增加到当前的2倍再加2，也就是（2*旧值+2）。如果你使用缺省值，初始化之后接着往里面追加字符，在你追加到第16个字符的时候它会将容量增加到34（2*16+2），当追加到34个字符的时候就会将容量增加到70（2*34+2）。无论何事只要StringBuffer到达它的最大容量它就不得不创建一个新的字符数组然后重新将旧字符和新字符都拷贝一遍――这也太昂贵了点。所以总是给StringBuffer设置一个合理的初始化容量值是错不了的，这样会带来立竿见影的性能增益。

StringBuffer初始化过程的调整的作用由此可见一斑。所以，使用一个合适的容量值来初始化StringBuffer永远都是一个最佳的建议。

14、合理的使用Java类 java.util.Vector。

简单地说，一个Vector就是一个java.lang.Object实例的数组。Vector与数组相似，它的元素可以通过整数形式的索引访问。但是，Vector类型的对象在创建之后，对象的大小能够根据元素的增加或者删除而扩展、缩小。请考虑下面这个向Vector加入元素的例子：

Object obj = new Object();

Vector v = new Vector(100000);

for(int I=0;

I100000; I++) { v.add(0,obj); }

除非有绝对充足的理由要求每次都把新元素插入到Vector的前面，否则上面的代码对性能不利。在默认构造函数中，Vector的初始存储能力是10个元素，如果新元素加入时存储能力不足，则以后存储能力每次加倍。Vector类就象StringBuffer类一样，每次扩展存储能力时，所有现有的元素都要复制到新的存储空间之中。下面的代码片段要比前面的例子快几个数量级：

Object obj = new Object();

Vector v = new Vector(100000);

for(int I=0; I100000; I++) { v.add(obj); }

同样的规则也适用于Vector类的remove()方法。由于Vector中各个元素之间不能含有“空隙”，删除除最后一个元素之外的任意其他元素都导致被删除元素之后的元素向前移动。也就是说，从Vector删除最后一个元素要比删除第一个元素“开销”低好几倍。

假设要从前面的Vector删除所有元素，我们可以使用这种代码：

for(int I=0; I100000; I++)

{

　v.remove(0);

}

但是，与下面的代码相比，前面的代码要慢几个数量级：

for(int I=0; I100000; I++)

{

　v.remove(v.size()-1);

}

从Vector类型的对象v删除所有元素的最好方法是：

v.removeAllElements();

假设Vector类型的对象v包含字符串“Hello”。考虑下面的代码，它要从这个Vector中删除“Hello”字符串：

String s = "Hello";

int i = v.indexOf(s);

if(I != -1) v.remove(s);

这些代码看起来没什么错误，但它同样对性能不利。在这段代码中，indexOf()方法对v进行顺序搜索寻找字符串“Hello”，remove(s)方法也要进行同样的顺序搜索。改进之后的版本是：

String s = "Hello";

int i = v.indexOf(s);

if(I != -1) v.remove(i);

这个版本中我们直接在remove()方法中给出待删除元素的精确索引位置，从而避免了第二次搜索。一个更好的版本是：

String s = "Hello"; v.remove(s);

最后，我们再来看一个有关Vector类的代码片段：

for(int I=0; I++;I v.length)

如果v包含100,000个元素，这个代码片段将调用v.size()方法100,000次。虽然size方法是一个简单的方法，但它仍旧需要一次方法调用的开销，至少JVM需要为它配置以及清除堆栈环境。在这里，for循环内部的代码不会以任何方式修改Vector类型对象v的大小，因此上面的代码最好改写成下面这种形式：

int size = v.size(); for(int I=0; I++;Isize)

虽然这是一个简单的改动，但它仍旧赢得了性能。毕竟，每一个CPU周期都是宝贵的。

15、当复制大量数据时，使用System.arraycopy()命令。

16、代码重构：增强代码的可读性。

例如：

public class ShopCart {

private List carts ;

…

public void add (Object item) {

if(carts == null) {

carts = new ArrayList();

}

crts.add(item);

}

public void remove(Object item) {

if(carts. contains(item)) {

carts.remove(item);

}

}

public List getCarts() {

//返回只读列表

return Collections.unmodifiableList(carts);

}

//不推荐这种方式

//this.getCarts().add(item);

}

17、不用new关键词创建类的实例

用new关键词创建类的实例时，构造函数链中的所有构造函数都会被自动调用。但如果一个对象实现了Cloneable接口，我们可以调用它的clone()方法。clone()方法不会调用任何类构造函数。

在使用设计模式（Design Pattern）的场合，如果用Factory模式创建对象，则改用clone()方法创建新的对象实例非常简单。例如，下面是Factory模式的一个典型实现：

public static Credit getNewCredit() {

return new Credit();

}

改进后的代码使用clone()方法，如下所示：

private static Credit BaseCredit = new Credit();

public static Credit getNewCredit() {

return (Credit) BaseCredit.clone();

}

上面的思路对于数组处理同样很有用。

18、乘法和除法

考虑下面的代码：

for (val = 0; val 100000; val +=5) {

alterX = val * 8; myResult = val * 2;

}

用移位操作替代乘法操作可以极大地提高性能。下面是修改后的代码：

for (val = 0; val 100000; val += 5) {

alterX = val 3; myResult = val 1;

}

修改后的代码不再做乘以8的操作，而是改用等价的左移3位操作，每左移1位相当于乘以2。相应地，右移1位操作相当于除以2。值得一提的是，虽然移位操作速度快，但可能使代码比较难于理解，所以最好加上一些注释。

19、在JSP页面中关闭无用的会话。

一个常见的误解是以为session在有客户端访问时就被创建，然而事实是直到某server端程序调用HttpServletRequest.getSession(true)这样的语句时才被创建，注意如果JSP没有显示的使用 %@pagesession="false"% 关闭session，则JSP文件在编译成Servlet时将会自动加上这样一条语句HttpSession

session = HttpServletRequest.getSession(true);这也是JSP中隐含的session对象的来历。由于session会消耗内存资源，因此，如果不打算使用session，应该在所有的JSP中关闭它。

对于那些无需跟踪会话状态的页面，关闭自动创建的会话可以节省一些资源。使用如下page指令：%@ page session="false"%

20、JDBC与I/O

如果应用程序需要访问一个规模很大的数据集，则应当考虑使用块提取方式。默认情况下，JDBC每次提取32行数据。举例来说，假设我们要遍历一个5000行的记录集，JDBC必须调用数据库157次才能提取到全部数据。如果把块大小改成512，则调用数据库的次数将减少到10次。

[p][/p]21、Servlet与内存使用

许多开发者随意地把大量信息保存到用户会话之中。一些时候，保存在会话中的对象没有及时地被垃圾回收机制回收。从性能上看，典型的症状是用户感到系统周期性地变慢，却又不能把原因归于任何一个具体的组件。如果监视JVM的堆空间，它的表现是内存占用不正常地大起大落。

解决这类内存问题主要有二种办法。第一种办法是，在所有作用范围为会话的Bean中实现HttpSessionBindingListener接口。这样，只要实现valueUnbound()方法，就可以显式地释放Bean使用的资源。另外一种办法就是尽快地把会话作废。大多数应用服务器都有设置会话作废间隔时间的选项。另外，也可以用编程的方式调用会话的setMaxInactiveInterval()方法，该方法用来设定在作废会话之前，Servlet容器允许的客户请求的最大间隔时间，以秒计。

22、使用缓冲标记

一些应用服务器加入了面向JSP的缓冲标记功能。例如，BEA的WebLogic Server从6.0版本开始支持这个功能，Open

Symphony工程也同样支持这个功能。JSP缓冲标记既能够缓冲页面片断，也能够缓冲整个页面。当JSP页面执行时，如果目标片断已经在缓冲之中，则生成该片断的代码就不用再执行。页面级缓冲捕获对指定URL的请求，并缓冲整个结果页面。对于购物篮、目录以及门户网站的主页来说，这个功能极其有用。对于这类应用，页面级缓冲能够保存页面执行的结果，供后继请求使用。

23、选择合适的引用机制

在典型的JSP应用系统中，页头、页脚部分往往被抽取出来，然后根据需要引入页头、页脚。当前，在JSP页面中引入外部资源的方法主要有两种：include指令，以及include动作。

include指令：例如%@ include file="copyright.html"

%。该指令在编译时引入指定的资源。在编译之前，带有include指令的页面和指定的资源被合并成一个文件。被引用的外部资源在编译时就确定，比运行时才确定资源更高效。

include动作：例如jsp:include page="copyright.jsp"

/。该动作引入指定页面执行后生成的结果。由于它在运行时完成，因此对输出结果的控制更加灵活。但时，只有当被引用的内容频繁地改变时，或者在对主页面的请求没有出现之前，被引用的页面无法确定时，使用include动作才合算。

24、及时清除不再需要的会话

为了清除不再活动的会话，许多应用服务器都有默认的会话超时时间，一般为30分钟。当应用服务器需要保存更多会话时，如果内存容量不足，操作系统会把部分内存数据转移到磁盘，应用服务器也可能根据“最近最频繁使用”（Most

Recently

Used）算法把部分不活跃的会话转储到磁盘，甚至可能抛出“内存不足”异常。在大规模系统中，串行化会话的代价是很昂贵的。当会话不再需要时，应当及时调用HttpSession.invalidate()方法清除会话。HttpSession.invalidate()方法通常可以在应用的退出页面调用。

25、不要将数组声明为：public static final 。

26、HashMap的遍历效率讨论

经常遇到对HashMap中的key和value值对的遍历操作，有如下两种方法：MapString, String[] paraMap = new HashMapString, String[]();

................//第一个循环

SetString appFieldDefIds = paraMap.keySet();

for (String appFieldDefId : appFieldDefIds) {

String[] values = paraMap.get(appFieldDefId);

......

}

//第二个循环

for(EntryString, String[] entry : paraMap.entrySet()){

String appFieldDefId = entry.getKey();

String[] values = entry.getValue();

.......

}

第一种实现明显的效率不如第二种实现。

分析如下 SetString appFieldDefIds = paraMap.keySet(); 是先从HashMap中取得keySet

代码如下：

public SetK keySet() {

SetK ks = keySet;

return (ks != null ? ks : (keySet = new KeySet()));

}

private class KeySet extends AbstractSetK {

public IteratorK iterator() {

return newKeyIterator();

}

public int size() {

return size;

}

public boolean contains(Object o) {

return containsKey(o);

}

public boolean remove(Object o) {

return HashMap.this.removeEntryForKey(o) != null;

}

public void clear() {

HashMap.this.clear();

}

}

其实就是返回一个私有类KeySet, 它是从AbstractSet继承而来，实现了Set接口。

再来看看for/in循环的语法

for(declaration : expression_r)

statement

在执行阶段被翻译成如下各式

for(IteratorE #i = (expression_r).iterator(); #i.hashNext();){

declaration = #i.next();

statement

}

因此在第一个for语句for (String appFieldDefId : appFieldDefIds) 中调用了HashMap.keySet().iterator() 而这个方法调用了newKeyIterator()

IteratorK newKeyIterator() {

return new KeyIterator();

}

private class KeyIterator extends HashIteratorK {

public K next() {

return nextEntry().getKey();

}

}

所以在for中还是调用了

在第二个循环for(EntryString, String[] entry : paraMap.entrySet())中使用的Iterator是如下的一个内部类

private class EntryIterator extends HashIteratorMap.EntryK,V {

public Map.EntryK,V next() {

return nextEntry();

}

}

此时第一个循环得到key，第二个循环得到HashMap的Entry

效率就是从循环里面体现出来的第二个循环此致可以直接取key和value值

而第一个循环还是得再利用HashMap的get(Object key)来取value值

现在看看HashMap的get(Object key)方法

public V get(Object key) {

Object k = maskNull(key);

int hash = hash(k);

int i = indexFor(hash, table.length); //Entry[] table

EntryK,V e = table;

while (true) {

if (e == null)

return null;

if (e.hash == hash eq(k, e.key))

return e.value;

e = e.next;

}

}

其实就是再次利用Hash值取出相应的Entry做比较得到结果，所以使用第一中循环相当于两次进入HashMap的Entry中

而第二个循环取得Entry的值之后直接取key和value，效率比第一个循环高。其实按照Map的概念来看也应该是用第二个循环好一点，它本来就是key和value的值对，将key和value分开操作在这里不是个好选择。

北大青鸟设计培训：如何写出优质Java代码的4个技巧？

如果现在要求对你写的Java代码进行优化，那你会怎么做呢？作者在本文介绍了可以提高系统性能以及代码可读性的四种方法，如果你对此感兴趣，就让java课程一起来看看吧。

我们平时的编程任务不外乎就是将相同的技术套件应用到不同的项目中去，对于大多数情况来说，这些技术都是可以满足目标的。

然而，有的项目可能需要用到一些特别的技术，因此工程师们得深入研究，去寻找那些最简单但最有效的方法。

在以前一篇文章中，我们讨论了必要时可以使用的四种特殊技术，这些特殊技术可以创建更好的Java软件；而本文我们将介绍一些有助于解决常见问题的通用设计策略和目标实现技术，即： 1.只做有目的性的优化 2.常量尽量使用枚举 3.重新定义类里面的equals()方法 4.尽量多使用多态性值得注意的是，本文中描述的技术并不是适用于所有情况。

另外这些技术应该什么时候使用以及在什么地方使用，都是需要使用者经过深思熟虑的。

1.只做有目的性的优化大型软件系统肯定非常关注性能问题。

虽然我们希望能够写出最高效的代码，但很多时候，如果想对代码进行优化，我们却无从下手。

最重要的是天下没有免费的午餐，因此为了降低代价，我们通常会通过类似于缓存、循环展开或预计算值这类技术去实现优化，这样反而增加了系统的复杂性，也降低了代码的可读性。

如果这种优化可以提高系统的性能，那么即使变得复杂，那也是值得的，但是做决定之前，必须首先知道这两条信息： 1.性能要求是什么 2.性能瓶颈在哪里首先我们需要清楚地知道性能要求是什么。

如果最终是在要求以内，并且最终用户也没有提出什么异议，那么就没有必要进行性能优化。

但是，当添加了新功能或者系统的数据量达到一定规模以后就必须进行优化了，否则可能会出现问题。

在这种情况下，不应该靠直觉，也不应该依靠检查。

因为即使是像MartinFowler这样有经验的开发人员也容易做一些错误的优化，正如在重构(第70页)一文中解释的那样：如果分析了足够多的程序以后，你会发现关于性能的有趣之处在于，大部分时间都浪费在了系统中的一小部分代码中里面。

如果对所有代码进行了同样的优化，那么最终结果就是浪费了90%的优化，因为优化过以后的代码运行得频率并不多。

因为没有目标而做的优化所耗费的时间，都是在浪费时间。

如何写出好的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 线上文档找出一些有用的信息时，你所遭遇的挫败应该足以让你相信这一点。