I've a book named JavaCodingStandards. This book provides some suggestions for writing clean and understandable code by keeping the code in a good style. Do you need it?
这里 java.io.* 使用来代替InputStream and OutputStream 的。 Class 接下来的是类的注释,一般是用来解释类的。 /** * A class representing a set of packet and byte counters * It is observable to allow it to be watched, but only * reports changes when the current set is complete */
接下来是类定义,包含了在不同的行的 extends 和 implements public class CounterSet extends Observable implements Cloneable Class Fields 接下来是类的成员变量: /** * Packet counters */protected int<> packets;
public 的成员变量必须生成文档(JavaDoc)。proceted、private和 package 定义的成员变量如果名字含义明确的话,可以没有注释。 存取方法 接下来是类变量的存取的方法。它只是简单的用来将类的变量赋值获取值的话,可以简单的写在一行上。 /** * Get the counters * @return an array containing the statistical data. This array has been * freshly allocated and can be modified by the caller. */public int<> getPackets() { return copyArray(packets, offset); }public int<> getBytes() { return copyArray(bytes, offset); }public int<> getPackets() { return packets; }public void setPackets(int<> packets) { this.packets = packets; }
其它的方法不要写在一行上 构造函数 接下来是构造函数,它应该用递增的方式写(比如:参数多的写在后面)。 访问类型 ("public", "private" 等.) 和 任何 "static", "final" 或 "synchronized" 应该在一行中,并且方法和参数另写一行,这样可以使方法和参数更易读。 publicCounterSet(int size){ this.size = size;} 克隆方法 如果这个类是可以被克隆的,那么下一步就是 clone 方法: publicObject clone() { try { CounterSet obj = (CounterSet)super.clone(); obj.packets = (int<>)packets.clone(); obj.size = size; return obj; }catch(CloneNotSupportedException e) { throw new InternalError("Unexpected CloneNotSUpportedException: " + e.getMessage()); }} 类方法 下面开始写类的方法: /** * Set the packet counters * (such as when restoring from a database) */protected finalvoid setArray(int<> r1, int<> r2, int<> r3, int<> r4) throws IllegalArgumentException{ // // Ensure the arrays are of equal size // if (r1.length != r2.length || r1.length != r3.length || r1.length != r4.length) throw new IllegalArgumentException("Arrays must be of the same size"); System.arraycopy(r1, 0, r3, 0, r1.length); System.arraycopy(r2, 0, r4, 0, r1.length);} toString 方法 无论如何,每一个类都应该定义 toString 方法: publicString toString() { String retval = "CounterSet: "; for (int i = 0; i < data.length(); i++) { retval += data.bytes.toString(); retval += data.packets.toString(); } return retval; }} main 方法 如果main(String<>) 方法已经定义了, 那么它应该写在类的底部. 代码编写格式 代码样式 代码应该用 unix 的格式,而不是 windows 的(比如:回车变成回车+换行) 文档化 必须用 javadoc 来为类生成文档。不仅因为它是标准,这也是被各种 java 编译器都认可的方法。使用 @author 标记是不被推荐的,因为代码不应该是被个人拥有的。 缩进 缩进应该是每行2个空格. 不要在源文件中保存Tab字符. 在使用不同的源代码管理工具时Tab字符将因为用户设置的不同而扩展为不同的宽度. 如果你使用 UltrEdit 作为你的 Java 源代码编辑器的话,你可以通过如下操作来禁止保存Tab字符, 方法是通过 UltrEdit中先设定 Tab 使用的长度室2个空格,然后用 Format|Tabs to Spaces 菜单将 Tab 转换为空格。 页宽 页宽应该设置为80字符. 源代码一般不会超过这个宽度, 并导致无法完整显示, 但这一设置也可以灵活调整. 在任何情况下, 超长的语句应该在一个逗号或者一个操作符后折行. 一条语句折行后, 应该比原来的语句再缩进2个字符. {} 对 {} 中的语句应该单独作为一行. 例如, 下面的第1行是错误的, 第2行是正确的: if (i>0) { i ++ }; // 错误, { 和 } 在同一行 if (i>0) { i ++ }; // 正确, { 单独作为一行 } 语句永远单独作为一行.
如果 } 语句应该缩进到与其相对应的 { 那一行相对齐的位置。 括号 左括号和后一个字符之间不应该出现空格, 同样, 右括号和前一个字符之间也不应该出现空格. 下面的例子说明括号和空格的错误及正确使用: CallProc( AParameter ); // 错误 CallProc(AParameter); // 正确 不要在语句中使用无意义的括号. 括号只应该为达到某种目的而出现在源代码中。下面的例子说明错误和正确的用法: if ((I) = 42) { // 错误 - 括号毫无意义 if (I == 42) or (J == 42) then // 正确 - 的确需要括号 程序编写规范 exit() exit 除了在 main 中可以被调用外,其他的地方不应该调用。因为这样做不给任何代码代码机会来截获退出。一个类似后台服务地程序不应该因为某一个库模块决定了要退出就退出。 异常 申明的错误应该抛出一个RuntimeException或者派生的异常。 顶层的main()函数应该截获所有的异常,并且打印(或者记录在日志中)在屏幕上。 垃圾收集 JAVA使用成熟的后台垃圾收集技术来代替引用计数。但是这样会导致一个问题:你必须在使用完对象的实例以后进行清场工作。比如一个prel的程序员可能这么写: ... { FileOutputStream fos = new FileOutputStream(projectFile); project.save(fos, "IDE Project File"); } ...
编程技巧 byte 数组转换到 characters 为了将 byte 数组转换到 characters,你可以这么做: "Hello world!".getBytes(); Utility 类 Utility 类(仅仅提供方法的类)应该被申明为抽象的来防止被继承或被初始化。 初始化 下面的代码是一种很好的初始化数组的方法: objectArguments = new Object<> { arguments }; 枚举类型 JAVA 对枚举的支持不好,但是下面的代码是一种很有用的模板: class Colour { public static final Colour BLACK = new Colour(0, 0, 0); public static final Colour RED = new Colour(0xFF, 0, 0); public static final Colour GREEN = new Colour(0, 0xFF, 0); public static final Colour BLUE = new Colour(0, 0, 0xFF); public static final Colour WHITE = new Colour(0xFF, 0xFF, 0xFF);}
资源一般我们与数据库的Connection打的交道最多,在一些第三方管理的基础上管理好你Connection,结果集等数据库方面的资源。编码风格是所有的编程语言都差不多的,这要你自己去培养好的编码习惯。
这个是CodingConvension,就是编码规则。写Java代码,这个是最基本的,必看的资料。
有关文件打开读写,网络连接,数据库连接一般都要加上异常处理...
有关资源释放的代码必须执行时需要这样写
try
{
//资源占用
}
catch()
{
//异常处理
}
finally
{
//资源释放写在这里,无论异常是否发生,这些代码均会执行
}
不过像楼上他们说的,还是要注意的。
This book provides some suggestions for writing clean and understandable code by keeping the code in a good style.
Do you need it?
http://www.skyinn.org/downloads/Java_codeconv.doc
Exception 放在最后
说明:程序中不再被使用的对象仍被引用,导致这些对象占有的内存无法及时被JVM释放,造成内存泄漏,需对引用无效对象的引用及时设置成null。
例如:
import java.util.EmptyStackException;public class LeakStack
{
private Object[] stack;
private int initialCapacity;
private int top = -1;
public LeakStack(int initialCapacity)
{
stack = new Object[initialCapacity];
}
public void push(Object e)
{
top++;
stack[top] = e;
}
public Object pop()
{
Object temp = stack[top];
/*这里将引起内存泄漏,在pop后,stack[top]引用的对象并没有被其它变量引用,但此时stack[top]引用的对象却是无用的,由于无用的对象被引用,JVM无法回收被占用的内存。在这里增加语句
stack[top] = null;
,由于无用的对象不再被引用,JVM将会及时的回收被对象占用的内存*/
top--;
return temp;
}
public static void main(String [] args)
{
try
{
int round = 1000;
LeakStack s = new LeakStack(2000);
for(int i = 0; i < 200; i++)
{
System.out.println("push" + i);
for(int j = 0; j < round; j++)
{
s.push(new byte[65000]);
}
System.out.println("pop" + i);
for(int j = 0; j < round; j++)
{
s.pop();
}
}
}
catch(EmptyStackException e)
{
e.printStackTrace(System.out);
}
}
}有一个例子:
import java.util.Vector;
public class Leak
{
/*如果方法MemoryLeak被调用,将会引起内存泄漏。虽然引用被设置成null,但创建的对象仍被v的元素引用,JVM无法回收对象占有的内存,须增加语句
v = null;
JVM将会及时的回收对象占有的内存。
*/
public void MemoryLeak()
{
Vector v=new Vector(10);
for (int i=1;i<100; i++)
{
Object o=new Object();
v.add(o);
o = null;
}
…/*其它处理,但没有使用引用v */
}
}
这两个例子都是会引起内存泄漏的例子,
我希望大家帮我找一些类似这些情况的例子!
--来自代码实验室http://www.code-labs.com/
JAVA代码编写的30条建议 列举了大量有用的建议,帮助大家进行低级程序设计,并提供了代码编写的一般性指导: (1) 类名首字母应该大写。字段、方法以及对象(句柄)的首字母应小写。对于所有标识符,其中包含的所有单词都应紧靠在一起,而且大写中间单词的首字母。例如: ThisIsAClassName thisIsMethodOrFieldName 若在定义中出现了常数初始化字符,则大写static final基本类型标识符中的所有字母。这样便可标志出它们属于编译期的常数。 Java包(Package)属于一种特殊情况:它们全都是小写字母,即便中间的单词亦是如此。对于域名扩展名称,如com,org,net或者edu等,全部都应小写(这也是Java 1.1和Java 1.2的区别之一)。 (2) 为了常规用途而创建一个类时,请采取“经典形式”,并包含对下述元素的定义: equals() hashCode() toString() clone()(implement Cloneable) implement Serializable (3) 对于自己创建的每一个类,都考虑置入一个main(),其中包含了用于测试那个类的代码。为使用一个项目中的类,我们没必要删除测试代码。若进行了任何形式的改动,可方便地返回测试。这些代码也可作为如何使用类的一个示例使用。 (4) 应将方法设计成简要的、功能性单元,用它描述和实现一个不连续的类接口部分。理想情况下,方法应简明扼要。若长度很大,可考虑通过某种方式将其分割成较短的几个方法。这样做也便于类内代码的重复使用(有些时候,方法必须非常大,但它们仍应只做同样的一件事情)。 (5) 设计一个类时,请设身处地为客户程序员考虑一下(类的使用方法应该是非常明确的)。然后,再设身处地为管理代码的人考虑一下(预计有可能进行哪些形式的修改,想想用什么方法可把它们变得更简单)。 (6) 使类尽可能短小精悍,而且只解决一个特定的问题。下面是对类设计的一些建议: ■一个复杂的开关语句:考虑采用“多形”机制 ■数量众多的方法涉及到类型差别极大的操作:考虑用几个类来分别实现 ■许多成员变量在特征上有很大的差别:考虑使用几个类 (7) 让一切东西都尽可能地“私有”??private。可使库的某一部分“公共化”(一个方法、类或者一个字段等等),就永远不能把它拿出。若强行拿出,就可能破坏其他人现有的代码,使他们不得不重新编写和设计。若只公布自己必须公布的,就可放心大胆地改变其他任何东西。在多线程环境中,隐私是特别重要的一个因素??只有private字段才能在非同步使用的情况下受到保护。 (8) 谨惕“巨大对象综合症”。对一些习惯于顺序编程思维、且初涉OOP领域的新手,往往喜欢先写一个顺序执行的程序,再把它嵌入一个或两个巨大的对象里。根据编程原理,对象表达的应该是应用程序的概念,而非应用程序本身。 (9) 若不得已进行一些不太雅观的编程,至少应该把那些代码置于一个类的内部。 (10) 任何时候只要发现类与类之间结合得非常紧密,就需要考虑是否采用内部类,从而改善编码及维护工作(参见第14章14.1.2小节的“用内部类改进代码”)。 (11) 尽可能细致地加上注释,并用javadoc注释文档语法生成自己的程序文档。 (12) 避免使用“魔术数字”,这些数字很难与代码很好地配合。如以后需要修改它,无疑会成为一场噩梦,因为根本不知道“100”到底是指“数组大小”还是“其他全然不同的东西”。所以,我们应创建一个常数,并为其使用具有说服力的描述性名称,并在整个程序中都采用常数标识符。这样可使程序更易理解以及更易维护。 (13) 涉及构建器和异常的时候,通常希望重新丢弃在构建器中捕获的任何异常??如果它造成了那个对象的创建失败。这样一来,调用者就不会以为那个对象已正确地创建,从而盲目地继续。 (14) 当客户程序员用完对象以后,若你的类要求进行任何清除工作,可考虑将清除代码置于一个良好定义的方法里,采用类似于cleanup()这样的名字,明确表明自己的用途。除此以外,可在类内放置一个boolean(布尔)标记,指出对象是否已被清除。在类的finalize()方法里,请确定对象已被清除,并已丢弃了从RuntimeException继承的一个类(如果还没有的话),从而指出一个编程错误。在采取象这样的方案之前,请确定finalize()能够在自己的系统中工作(可能需要调用System.runFinalizersOnExit(true),从而确保这一行为)。 (15) 在一个特定的作用域内,若一个对象必须清除(非由垃圾收集机制处理),请采用下述方法:初始化对象;若成功,则立即进入一个含有finally从句的try块,开始清除工作。 (16) 若在初始化过程中需要覆盖(取消)finalize(),请记住调用super.finalize()(若Object属于我们的直接超类,则无此必要)。在对finalize()进行覆盖的过程中,对super.finalize()的调用应属于最后一个行动,而不应是第一个行动,这样可确保在需要基础类组件的时候它们依然有效。 (17) 创建大小固定的对象集合时,请将它们传输至一个数组(若准备从一个方法里返回这个集合,更应如此操作)。这样一来,我们就可享受到数组在编译期进行类型检查的好处。此外,为使用它们,数组的接收者也许并不需要将对象“造型”到数组里。 (18) 尽量使用interfaces,不要使用abstract类。若已知某样东西准备成为一个基础类,那么第一个选择应是将其变成一个interface(接口)。只有在不得不使用方法定义或者成员变量的时候,才需要将其变成一个abstract(抽象)类。接口主要描述了客户希望做什么事情,而一个类则致力于(或允许)具体的实施细节。 (19) 在构建器内部,只进行那些将对象设为正确状态所需的工作。尽可能地避免调用其他方法,因为那些方法可能被其他人覆盖或取消,从而在构建过程中产生不可预知的结果(参见第7章的详细说明)。 (20) 对象不应只是简单地容纳一些数据;它们的行为也应得到良好的定义。 (21) 在现成类的基础上创建新类时,请首先选择“新建”或“创作”。只有自己的设计要求必须继承时,才应考虑这方面的问题。若在本来允许新建的场合使用了继承,则整个设计会变得没有必要地复杂。 (22) 用继承及方法覆盖来表示行为间的差异,而用字段表示状态间的区别。一个非常极端的例子是通过对不同类的继承来表示颜色,这是绝对应该避免的:应直接使用一个“颜色”字段。 (23) 为避免编程时遇到麻烦,请保证在自己类路径指到的任何地方,每个名字都仅对应一个类。否则,编译器可能先找到同名的另一个类,并报告出错消息。若怀疑自己碰到了类路径问题,请试试在类路径的每一个起点,搜索一下同名的.class文件。 (24) 在Java 1.1 AWT中使用事件“适配器”时,特别容易碰到一个陷阱。若覆盖了某个适配器方法,同时拼写方法没有特别讲究,最后的结果就是新添加一个方法,而不是覆盖现成方法。然而,由于这样做是完全合法的,所以不会从编译器或运行期系统获得任何出错提示??只不过代码的工作就变得不正常了。 (25) 用合理的设计方案消除“伪功能”。也就是说,假若只需要创建类的一个对象,就不要提前限制自己使用应用程序,并加上一条“只生成其中一个”注释。请考虑将其封装成一个“独生子”的形式。若在主程序里有大量散乱的代码,用于创建自己的对象,请考虑采纳一种创造性的方案,将些代码封装起来。 (26) 警惕“分析瘫痪”。请记住,无论如何都要提前了解整个项目的状况,再去考察其中的细节。由于把握了全局,可快速认识自己未知的一些因素,防止在考察细节的时候陷入“死逻辑”中。 (27) 警惕“过早优化”。首先让它运行起来,再考虑变得更快??但只有在自己必须这样做、而且经证实在某部分代码中的确存在一个性能瓶颈的时候,才应进行优化。除非用专门的工具分析瓶颈,否则很有可能是在浪费自己的时间。性能提升的隐含代价是自己的代码变得难于理解,而且难于维护。 (28) 请记住,阅读代码的时间比写代码的时间多得多。思路清晰的设计可获得易于理解的程序,但注释、细致的解释以及一些示例往往具有不可估量的价值。无论对你自己,还是对后来的人,它们都是相当重要的。如对此仍有怀疑,那么请试想自己试图从联机Java文档里找出有用信息时碰到的挫折,这样或许能将你说服。 (29) 如认为自己已进行了良好的分析、设计或者实施,那么请稍微更换一下思维角度。试试邀请一些外来人士??并不一定是专家,但可以是来自本公司其他部门的人。请他们用完全新鲜的眼光考察你的工作,看看是否能找出你一度熟视无睹的问题。采取这种方式,往往能在最适合修改的阶段找出一些关键性的问题,避免产品发行后再解决问题而造成的金钱及精力方面的损失。 (30) 良好的设计能带来最大的回报。简言之,对于一个特定的问题,通常会花较长的时间才能找到一种最恰当的解决方案。但一旦找到了正确的方法,以后的工作就轻松多了,再也不用经历数小时、数天或者数月的痛苦挣扎。我们的努力工作会带来最大的回报(甚至无可估量)。而且由于自己倾注了大量心血,最终获得一个出色的设计方案,成功的快感也是令人心动的。坚持抵制草草完工的诱惑??那样做往往得不偿失。 (31) 可在Web上找到大量的编程参考资源,甚至包括大量新闻组、讨论组、邮寄列表等。
Java文件样式
代码编写格式
程序编写
编程技巧
Swing
调试
性能
可移植性
参考资料
作者简介
所有的程序开发手册都包含了各种规则。一些习惯自由程序人员可能对这些规则很不适应,但是在多个开发人员共同写作的情况下,这些规则是必需的。这不仅仅是为了开发效率来考虑,而且也是为了后期维护考虑。 命名规范 定义这个规范的目的是让项目中所有的文档都看起来像一个人写的,增加可读性,减少项目组中因为换人而带来的损失。(这些规范并不是一定要绝对遵守,但是一定要让程序有良好的可读性)
Package 的命名 Package 的名字应该都是由一个小写单词组成。
Class 的命名 Class 的名字必须由大写字母开头而其他字母都小写的单词组成
Class 变量的命名 变量的名字必须用一个小写字母开头。后面的单词用大写字母开头。
Static Final 变量的命名 Static Final 变量的名字应该都大写,并且指出完整含义。
参数的命名 参数的名字必须和变量的命名规范一致。
数组的命名 数组应该总是用下面的方式来命名: byte<> buffer;
而不是: byte buffer<>;
方法的参数 使用有意义的参数命名,如果可能的话,使用和要赋值的字段一样的名字: SetCounter(int size){ this.size = size;}
Java 文件样式 所有的 Java(*.java) 文件都必须遵守如下的样式规则
版权信息 版权信息必须在 java 文件的开头,比如: /** * Copyright ® 2000 Shanghai XXX Co. Ltd. * All right reserved. */
其他不需要出现在 javadoc 的信息也可以包含在这里。
Package/Imports package 行要在 import 行之前,import 中标准的包名要在本地的包名之前,而且按照字母顺序排列。如果 import 行中包含了同一个包中的不同子目录,则应该用 * 来处理。 package hotlava.net.stats;import java.io.*;import java.util.Observable;import hotlava.util.Application;
这里 java.io.* 使用来代替InputStream and OutputStream 的。
Class 接下来的是类的注释,一般是用来解释类的。 /** * A class representing a set of packet and byte counters * It is observable to allow it to be watched, but only * reports changes when the current set is complete */
接下来是类定义,包含了在不同的行的 extends 和 implements public class CounterSet extends Observable implements Cloneable
Class Fields 接下来是类的成员变量: /** * Packet counters */protected int<> packets;
public 的成员变量必须生成文档(JavaDoc)。proceted、private和 package 定义的成员变量如果名字含义明确的话,可以没有注释。
存取方法 接下来是类变量的存取的方法。它只是简单的用来将类的变量赋值获取值的话,可以简单的写在一行上。 /** * Get the counters * @return an array containing the statistical data. This array has been * freshly allocated and can be modified by the caller. */public int<> getPackets() { return copyArray(packets, offset); }public int<> getBytes() { return copyArray(bytes, offset); }public int<> getPackets() { return packets; }public void setPackets(int<> packets) { this.packets = packets; }
其它的方法不要写在一行上
构造函数 接下来是构造函数,它应该用递增的方式写(比如:参数多的写在后面)。 访问类型 ("public", "private" 等.) 和 任何 "static", "final" 或 "synchronized" 应该在一行中,并且方法和参数另写一行,这样可以使方法和参数更易读。 publicCounterSet(int size){ this.size = size;}
克隆方法 如果这个类是可以被克隆的,那么下一步就是 clone 方法: publicObject clone() { try { CounterSet obj = (CounterSet)super.clone(); obj.packets = (int<>)packets.clone(); obj.size = size; return obj; }catch(CloneNotSupportedException e) { throw new InternalError("Unexpected CloneNotSUpportedException: " + e.getMessage()); }}
类方法 下面开始写类的方法: /** * Set the packet counters * (such as when restoring from a database) */protected finalvoid setArray(int<> r1, int<> r2, int<> r3, int<> r4) throws IllegalArgumentException{ // // Ensure the arrays are of equal size // if (r1.length != r2.length || r1.length != r3.length || r1.length != r4.length) throw new IllegalArgumentException("Arrays must be of the same size"); System.arraycopy(r1, 0, r3, 0, r1.length); System.arraycopy(r2, 0, r4, 0, r1.length);}
toString 方法 无论如何,每一个类都应该定义 toString 方法: publicString toString() { String retval = "CounterSet: "; for (int i = 0; i < data.length(); i++) { retval += data.bytes.toString(); retval += data.packets.toString(); } return retval; }}
main 方法 如果main(String<>) 方法已经定义了, 那么它应该写在类的底部.
代码编写格式
代码样式 代码应该用 unix 的格式,而不是 windows 的(比如:回车变成回车+换行)
文档化 必须用 javadoc 来为类生成文档。不仅因为它是标准,这也是被各种 java 编译器都认可的方法。使用 @author 标记是不被推荐的,因为代码不应该是被个人拥有的。
缩进 缩进应该是每行2个空格. 不要在源文件中保存Tab字符. 在使用不同的源代码管理工具时Tab字符将因为用户设置的不同而扩展为不同的宽度. 如果你使用 UltrEdit 作为你的 Java 源代码编辑器的话,你可以通过如下操作来禁止保存Tab字符, 方法是通过 UltrEdit中先设定 Tab 使用的长度室2个空格,然后用 Format|Tabs to Spaces 菜单将 Tab 转换为空格。
页宽 页宽应该设置为80字符. 源代码一般不会超过这个宽度, 并导致无法完整显示, 但这一设置也可以灵活调整. 在任何情况下, 超长的语句应该在一个逗号或者一个操作符后折行. 一条语句折行后, 应该比原来的语句再缩进2个字符.
{} 对 {} 中的语句应该单独作为一行. 例如, 下面的第1行是错误的, 第2行是正确的: if (i>0) { i ++ }; // 错误, { 和 } 在同一行 if (i>0) { i ++ }; // 正确, { 单独作为一行 } 语句永远单独作为一行.
如果 } 语句应该缩进到与其相对应的 { 那一行相对齐的位置。
括号 左括号和后一个字符之间不应该出现空格, 同样, 右括号和前一个字符之间也不应该出现空格. 下面的例子说明括号和空格的错误及正确使用: CallProc( AParameter ); // 错误 CallProc(AParameter); // 正确 不要在语句中使用无意义的括号. 括号只应该为达到某种目的而出现在源代码中。下面的例子说明错误和正确的用法: if ((I) = 42) { // 错误 - 括号毫无意义 if (I == 42) or (J == 42) then // 正确 - 的确需要括号
程序编写规范
exit() exit 除了在 main 中可以被调用外,其他的地方不应该调用。因为这样做不给任何代码代码机会来截获退出。一个类似后台服务地程序不应该因为某一个库模块决定了要退出就退出。
异常 申明的错误应该抛出一个RuntimeException或者派生的异常。 顶层的main()函数应该截获所有的异常,并且打印(或者记录在日志中)在屏幕上。
垃圾收集 JAVA使用成熟的后台垃圾收集技术来代替引用计数。但是这样会导致一个问题:你必须在使用完对象的实例以后进行清场工作。比如一个prel的程序员可能这么写: ... { FileOutputStream fos = new FileOutputStream(projectFile); project.save(fos, "IDE Project File"); } ...
除非输出流一出作用域就关闭,非引用计数的程序语言,比如JAVA,是不能自动完成变量的清场工作的。必须象下面一样写: FileOutputStream fos = new FileOutputStream(projectFile); project.save(fos, "IDE Project File"); fos.close();
Clone 下面是一种有用的方法: implements Cloneable public Object clone() { try { ThisClass obj = (ThisClass)super.clone(); obj.field1 = (int<>)field1.clone(); obj.field2 = field2; return obj; } catch(CloneNotSupportedException e) { throw new InternalError("Unexpected CloneNotSUpportedException: " + e.getMessage()); } }
final 类 绝对不要因为性能的原因将类定义为 final 的(除非程序的框架要求) 如果一个类还没有准备好被继承,最好在类文档中注明,而不要将她定义为 final 的。这是因为没有人可以保证会不会由于什么原因需要继承她。
访问类的成员变量 大部分的类成员变量应该定义为 protected 的来防止继承类使用他们。 注意,要用"int<> packets",而不是"int packets<>",后一种永远也不要用。 public void setPackets(int<> packets) { this.packets = packets; } CounterSet(int size) { this.size = size; }
编程技巧
byte 数组转换到 characters 为了将 byte 数组转换到 characters,你可以这么做: "Hello world!".getBytes();
Utility 类 Utility 类(仅仅提供方法的类)应该被申明为抽象的来防止被继承或被初始化。
初始化 下面的代码是一种很好的初始化数组的方法: objectArguments = new Object<> { arguments };
枚举类型 JAVA 对枚举的支持不好,但是下面的代码是一种很有用的模板: class Colour { public static final Colour BLACK = new Colour(0, 0, 0); public static final Colour RED = new Colour(0xFF, 0, 0); public static final Colour GREEN = new Colour(0, 0xFF, 0); public static final Colour BLUE = new Colour(0, 0, 0xFF); public static final Colour WHITE = new Colour(0xFF, 0xFF, 0xFF);}
这种技术实现了RED, GREEN, BLUE 等可以象其他语言的枚举类型一样使用的常量。 他们可以用 '==' 操作符来比较。 但是这样使用有一个缺陷:如果一个用户用这样的方法来创建颜色 BLACK new Colour(0,0,0) 那么这就是另外一个对象,'=='操作符就会产生错误。她的 equal() 方法仍然有效。由于这个原因,这个技术的缺陷最好注明在文档中,或者只在自己的包中使用。
Swing
避免使用 AWT 组件
混合使用 AWT 和 Swing 组件 如果要将 AWT 组件和 Swing 组件混合起来使用的话,请小心使用。实际上,尽量不要将他们混合起来使用。
滚动的 AWT 组件 AWT 组件绝对不要用 JscrollPane 类来实现滚动。滚动 AWT 组件的时候一定要用 AWT ScrollPane 组件来实现。
避免在 InternalFrame 组件中使用 AWT 组件 尽量不要这么做,要不然会出现不可预料的后果。
Z-Order 问题 AWT 组件总是显示在 Swing 组件之上。当使用包含 AWT 组件的 POP-UP 菜单的时候要小心,尽量不要这样使用。
调试
调试在软件开发中是一个很重要的部分,存在软件生命周期的各个部分中。调试能够用配置开、关是最基本的。 很常用的一种调试方法就是用一个 PrintStream 类成员,在没有定义调试流的时候就为 null,类要定义一个 debug 方法来设置调试用的流。
性能
在写代码的时候,从头至尾都应该考虑性能问题。这不是说时间都应该浪费在优化代码上,而是我们时刻应该提醒自己要注意代码的效率。比如:如果没有时间来实现一个高效的算法,那么我们应该在文档中记录下来,以便在以后有空的时候再来实现她。 不是所有的人都同意在写代码的时候应该优化性能这个观点的,他们认为性能优化的问题应该在项目的后期再去考虑,也就是在程序的轮廓已经实现了以后。
不必要的对象构造
不要在循环中构造和释放对象
使用 StringBuffer 对象 在处理 String 的时候要尽量使用 StringBuffer 类,StringBuffer 类是构成 String 类的基础。String 类将 StringBuffer 类封装了起来,(以花费更多时间为代价)为开发人员提供了一个安全的接口。当我们在构造字符串的时候,我们应该用 StringBuffer 来实现大部分的工作,当工作完成后将 StringBuffer 对象再转换为需要的 String 对象。比如:如果有一个字符串必须不断地在其后添加许多字符来完成构造,那么我们应该使用 StringBuffer 对象和她的 append() 方法。如果我们用 String 对象代替 StringBuffer 对象的话,会花费许多不必要的创建和释放对象的 CPU 时间。
避免太多的使用 synchronized 关键字 避免不必要的使用关键字 synchronized,应该在必要的时候再使用她,这是一个避免死锁的好方法。
可移植性 Borland Jbulider 不喜欢 synchronized 这个关键字,如果你的断点设在这些关键字的作用域内的话,调试的时候你会发现的断点会到处乱跳,让你不知所措。除非必须,尽量不要使用。
换行 如果需要换行的话,尽量用 println 来代替在字符串中使用"\n"。 你不要这样: System.out.print("Hello,world!\n"); 要这样: System.out.println("Hello,world!"); 或者你构造一个带换行符的字符串,至少要象这样: String newline = System.getProperty("line.separator"); System.out.println("Hello world" + newline);
PrintStream PrintStream 已经被不赞成(deprecated)使用,用 PrintWrite 来代替她。
参考资料
查找有关 Thread 类和 Java 2 平台,标准版,API 规范的其他方面的信息。