首页 > 代码库 > java 编码规范
java 编码规范
1.代码布局规则
2.代码书写规则
3.命名规则
4.声明规则
5.表达式和语法规则
6.注释规则
7.初始化和回收站规则
8.异常处理规则
9.线程和同步规则
10.面向对象设计规则
11.开发EJB规则
12.其他杂项规则
前 言
内容包括：JAVA代码标准规则、依据约定设计规则、开发EJB规则、代码书写格式规则、垃圾回收规则、全局静态分析规则、初始化规则、代码国际化规则、JAVA文档注释规则、类统计信息规则、其它杂项规则、命名约定规则、面向对象设计规则、代码优化规则、潜在的Bugs规则、有关线程规则、不合习惯的规则。对于显而易见的规则，没有列举示例说明。
本规范用到的术语解释如下：
规则：编程时必须遵守的规则，是Jtest执行java项目测试的依据。
建议：编程时必须加以考虑的原则，在JTest测试过程中不强行做检查。
说明：对相应规则的必要的解释
正例：对此规则或建议给出的修正后的例子
反例：对此规则或建议给出的反面的例子
级别：按照规则分为1、2、3、4、5级。其分别的定义为：
1：可能引起功能问题，不存在例外情况。
2：可能引起功能问题，存在例外情况。
3：不会引起功能问题。
4：代码格式问题。
5：建议。
1 1 代码布局规则
每一个Java源文件都包括一个公共的类或接口。当私有类或接口与公共类相关联的时候，通常可以将其与公共类放在同一个源文件当中。公共类应是文件中的第一个类或接口。
类或接口的各部分代码顺序如下：
Class或Interface 文档型注释
采用 /**
*
*
*/ 型注释。
Class或Interface声明
类变量及变量实例
变量出现的顺序为，首先公共变量，然后是package可见的变量，然后是protected变量。
构造函数（Constructors）
方法finalize()，如果有。
public方法
package可见方法
protected方法
private 方法
内部类
private字段
main方法
| 【规则1_1】 源代码文件(.java)的布局顺序是：包、import语句、源文件注释、类。 |
正例：
package com.zte;
import java.awt.peer.CanvasPeer;
import java.io.*;
import com.zte.ums.uep.*;
/**
* <p>文件名称: 题目名称</p>
* <p>文件描述: 本类描述</p>
* <p>版权所有: 版权所有(C)2001-2004</p>
* <p>公 司: *******</p>
* <p>内容摘要: // 简要描述本文件的内容，包括主要模块、函数及其功能的说明</p>
* <p>其他说明: // 其它内容的说明</p>
* <p>完成日期：// 输入完成日期，例：2000年2月25日</p>
* <p>修改记录1: // 修改历史记录，包括修改日期、修改者及修改内容</p>
* <pre>
* 修改日期：
* 版 本 号：
* 修 改 人：
* 修改内容：
* </pre>
* <p>修改记录2：…</p>
* @version 1.0
* @author 作者姓名
*/
JTest规则
暂不需要
级别：3
| 【规则1_2】 在一个类中，布局顺序依次是：非私有变量、构造器、方法、内部类、私有变量、main方法。 |
JTEST中对应：
暂不需要
级别：3
| 【规则1_3】 类中非私有变量的布局顺序是：public、package、protected。 |
JTEST中对应：
暂不需要
级别：3
| 【规则1_4】 构造器有多个时，要依据参数少的在前面，参数多的在后面的原则编写代码，提高代码可读性。 |
JTEST中对应：
待定。
级别：3
| 【规则1_5】 类中方法的布局顺序是：public、package、protected、private。 |
JTEST中对应：
暂不需要
级别：3
| 【规则1_6】 如果类声明中有main方法，则把其放在类的最后。 |
JTEST中对应：
保存路径: 内嵌
目录 Rules－Built-in Rules－Coding Conventions(CODSTA)
级别：4
| 【建议】 函数重载要集中在一起声明，提高代码可读性。 |
反例：
public class OGM {
void foo () {}
void bar () {}
void bab () {}
void foo (int a) { //违例
}
}
正例：
public class OGM {
void foo () {}
void foo (int a) { //正确
}
void bar () {}
void bab () {}
}
级别：5
| 【规则1_7】 一个类的代码行不超过2000行。 |
JTEST中对应：
保存路径: Jtest4.5\jrules\ METRICS_CTNL.rule
目录：Rules－UserDefinedRules－METRICS
级别：3
| 【规则1_8】 一个方法的代码行不超过300行。 |
JTEST中对应：
保存路径: Jtest4.5\jrules\ METRICS_TNLM.rule
目录 ：Rules－UserDefinedRules－METRICS
级别：3
2 2 代码书写规则
| 【规则2_1】每行只有一个句子，提高代码可读性。 |
反例：
public class OSPL {
int method (int a, int b) {
int i = a + b; return i; //违例
}
}
正例：
public class OSPLFixed {
int method (int a, int b) {
int i = a + b; // 正确
return i; // 正确
}
}
JTEST中对应：
保存路径: Jtest4.5\jrules\format_OSPL.rule
目录：Rules－UserDefinedRules－FORMAT
级别：3
| 【规则2_2】 每行不能超过120个字符。 |
JTEST中对应：
保存路径: Jtest4.5\jrules\FORMAT_LL.rule
目录：Rules－UserDefinedRules－FORMAT
级别：3
| 【规则2_3】 长表达式（超过120列）要在低优先级操作符处拆分成新行，操作符放在新行之首（以便突出操作符）。拆分出的新行要进行适当的缩进，使排版整齐。 |
说明：
断行方法：
- 在逗号后断行
- 在操作符前断行
- 较高级别断行优于较低级别的断行
对齐方法：
- 将新行与同一级别的先前行的表达式的起始端对齐。
- 条件表达式的续行在第一个条件处对齐。
- for循环语句的续行在初始化条件语句处对齐。
- 函数调用和函数声明的续行在第一个参数处对齐。
- 赋值语句的续行应在赋值号处对齐。
- 如果上述规则导致代码排列混乱或代码左边界少于两个缩进，可用两倍缩进替代。
下面是一些断行方法调用的示例：
正例：
someMethod(longExpression1, longExpression2, longExpression3,
longExpression4, longExpression5);
var = someMethod1(longExpression1,
someMethod2(longExpression2,
longExpression3));
下面是两个断行算术表达式例子，第一个是优选方法，因为断行出现在括号表达式之外，属于较高级别的断行。
正例：
longName1 = longName2 * (longName3 + longName4 - longName5)
+ 4 * longname6; //允许的断行方法
反例:
longName1 = longName2 * (longName3 + longName4
-longName5) + 4 * longname6; //应该避免的断行方法
下面是两个缩排方法的例子，第一个是传统的方式，第二个例子中如果采用传统方式缩排将导致第二行和第三行右边出现太多空白，因此，采用8个空格符替代。
//传统的缩排方法，第二行与第一行的括号对齐。
正例：
someMethod(int anArg, Object anotherArg, String yetAnotherArg,
Object andStillAnother) {
...//你代码的位置
}
//由8个空格符来替代与括号对齐的方法，以避免第二行、第三行出现太多的空格符
正例：
private static synchronized horkingLongMethodName(int anArg,
Object anotherArg, String yetAnotherArg,
Object andStillAnother) {
...//你代码的位置
}
对于if语句的行封装通常使用8空格规则，因为传统的4空格缩排方式使得有些语句容易被忽略掉，使if语句体难以理解。例如：
反例：
//不允许使用下面的缩进方法
if ((condition1 && condition2)
|| (condition3 && condition4)
||!(condition5 && condition6)) { //不好的封闭
doSomethingAboutIt(); //这样对齐的封闭很容易让阅读的人忽略掉这一行
}
正例：
//宜采用下面的缩进方法（分成三行的情况）
if ((condition1 && condition2)
|| (condition3 && condition4)
||!(condition5 && condition6)) {
doSomethingAboutIt();
}
//或使用下面的缩进方法（分成二行的情况）
正例：
if ((condition1 && condition2) || (condition3 && condition4)
||!(condition5 && condition6)) {
doSomethingAboutIt();
}
对于三重表达式，有三种方式可以对它进行格式化:
正例：
//单行的情况
alpha = (aLongBooleanExpression) ? beta : gamma;
//分成两行的情况，第二行的冒号与第一行的问号对齐。
alpha = (aLongBooleanExpression) ? beta
: gamma;
//分成三行的情况，第二行的问号和第三行的冒号都与第一行的括号对齐
alpha = (aLongBooleanExpression)
? beta
: gamma;
JTEST中对应：
暂不需要
级别：3
| 【规则2_4】 用空格(4个空格)替代tab键，4个空格为一缩进单位，避免不同编辑器之间的差异而导致代码布局混乱。 |
JTEST中对应：
保存路径: Jtest4.5\jrules\format_DUT.rule
目录：Rules－UserDefinedRules－FORMAT
保存路径: Jtest4.5\jrules\format_IND.rule
目录：Rules－UserDefinedRules－FORMAT
级别：4
| 【规则2_5】 package语句后用空行和import语句分隔开。不同类别的import语句之间用空行分隔。 |
说明：package语句其后可跟import语句，而且与package间隔一个空行。import包的排列顺序为java开头的包在最前面，接下来是引自外部的包，再接下来是应用程序自身的包，即import 中标准的包名要在本地的包名之前，而且按照字母顺序排列。如：
正例:
package com.zte;
import java.awt.peer.CanvasPeer; //java自身的包
import java.io……;
import com.klg.field……; //第三方的包
import com.zte.ums.uep……; //程序自身的包
JTEST中对应：
暂不需要
级别：4
| 【规则2_6】 方法之间要有一空行，不同的逻辑块之间也要有空行，在定义类和接口之前要有空行，提高代码可读性。 |
JTEST中对应：
暂不需要
级别：4
| 【规则2_7】 “}”一定独占一行，并且它们后面都没有语句。 |
JTEST中对应：
保存路径: Jtest4.5\jrules\format_CBRACE.rule
目录：Rules－UserDefinedRules－FORMAT
级别：4
| 【规则2_8】 ”{”不能独占一行，并且前面应该有空格，后面不能够有语句。 |
JTEST中对应：
保存路径: Jtest4.5\jrules\format_BRACE_SPACE.rule
目录：Rules－UserDefinedRules－FORMAT
保存路径: Jtest4.5\jrules\format_FCB.rule
目录：Rules－UserDefinedRules－FORMAT
保存路径: Jtest4.5\jrules\ format_NSAB.rule
目录：Rules－UserDefinedRules－FORMAT [z1]
级别：4
| 【规则2_9】 “(”后面不能够有空格，”)”前面不能够有空格。 |
JTEST中对应：
待定
级别：4
| 【规则2_10】 定义方法时，方法名字和”( ”之间没有空格。 |
反例：
class MSP {
public void method () { //违例
}
public void method1 () { //违例
}
}
正例：
class MSPFixed {
public void method() { // 正确
}
public void method1 () { // 正确
}
}
JTEST中对应：
保存路径: Jtest4.5\jrules\FORMAT_MSP2.rule
目录：Rules－UserDefinedRules－FORMAT
级别：4
| 【规则2_11】 “if”、”for”、”while”、”switch”关键字和”()”之间要有一个空格。 |
JTEST中对应：
保存路径: Jtest4.5\jrules\format_SC.rule
目录：Rules－UserDefinedRules－FORMAT
级别：4
| 【规则2_12】 在声明方法中，形式参数之间(逗号以后)要有一空格，提高代码可读性。 |
反例：
public class SAC {
public void method (int i,int j) { } //违例
}
正例：
public class SAC {
public void method (int i, int j) { } //正确
}
JTEST中对应：
保存路径: Jtest4.5\jrules\format_SAC.rule
目录：Rules－UserDefinedRules－FORMAT
级别：4
| 【规则2_13】 在for循环中语句中，分号之后要有一空格，提高代码可读性。 |
反例：
public class SAS {
public void method () {
for (int i = 0;i < 10;i++) { //违例
System.out.println ("i: " + i);
}
}
}
正例：
public class SAS {
public void method () {
for (int i = 0; i < 10; i++) { //正确
System.out.println ("i: " + i);
}
}
}
JTEST中对应：
保存路径: Jtest4.5\jrules\format_SAS.rule
目录：Rules－UserDefinedRules－FORMAT
级别：4
| 【规则2_14】 在一元(“++”,”--”)运算符和变量之间不允许有空格，提高代码可读性。 |
反例：
public class SAUOP {
public void method (int x) {
System.out.println("x: " + ++ x); // 违例
}
}
public class SAUOP {
public void method (int x) {
System.out.println("x: " + x ++); // 违例
}
}
正例：
public class SAUOP {
public void method (int x) {
System.out.println("x: " + ++x); // 正确
}
}
public class SAUOP {
public void method (int x) {
System.out.println("x: " + x++); // 正确
}
}
JTEST中对应：
保存路径: Jtest4.5\jrules\format_SAUOP.rule
目录：Rules－UserDefinedRules－FORMAT
保存路径: Jtest4.5\jrules\format_SBUOP.rule
目录：Rules－UserDefinedRules－FORMAT
级别：4
| 【规则2_15】 在二元(“>>”,”<<”,”|”,”^ ”)运算符和变量之间要有空格。 |
反例：
public class SBOP {
public void method (int x, int y) {
int z = x>>y; //违例
z = z&0xff; //违例
}
}
正例：
public class SBOPFixed {
public void method (int x, int y) {
int z = x | y; //正确
z = z & 0xff; //正确
}
}
JTEST中对应：
保存路径: Jtest4.5\jrules\format_SBOP.rule
目录：Rules－UserDefinedRules－FORMAT
级别：4
| 【规则2_16】在运算符(“?”)前后都要有空格；在二元(“||”,”&&”,”<=”,”==”) 逻辑运算符前后都要有空格。 |
JTEST中对应：
保存路径: Jtest4.5\jrules\format_SCOP.rule
目录：Rules－UserDefinedRules－FORMAT
保存路径: Jtest4.5\jrules\format_SLOP.rule
目录：Rules－UserDefinedRules－FORMAT
保存路径: Jtest4.5\jrules\format_SROP.rule
目录：Rules－UserDefinedRules－FORMAT
级别：4
| 【规则2_17】 类型强制转换后面应该有一空格。 |
JTEST中对应：
保存路径: Jtest4.5\jrules\format_CMS.rule
目录：Rules－UserDefinedRules－FORMA
级别：4
| 【规则2_18】 对于非界面的程序，用大写标识符静态变量替代数字常量和字符串常量，避免直接使用数字常量，提高代码可读性。 |
说明：
指定的常量（final,static变量）的采用可以使得代码更容易被理解与维护当代码中使用如下的整型常量时，Jtest不报错：-1，0，1，2，3，4，5，6，7，8，9，10
反例：
class USN {
int[] getArray () {
return new int [1000]; //违例
}
}
正例：
class USNFixed {
int[] getArray () {
return new int [ARRAY_SIZE]; //正确
}
private static final int ARRAY_SIZE = 1000;
}
例外：
某些类，特别是界面类中，无法满足此要求。对于这种例外情况，在类的注释中增加说明：@JTI2_18，则不检查此类。
JTEST中对应：
保存路径: Jtest4.5\jrules\CODSTA_USN. rule
目录：Rules－UserDefinedRules－CODSTA
级别：3
| 【规则2_19】 import语句必须引用到具体的类。 |
说明：
在某些不同的包下，可能存在相同的类名，如果不指明具体的类名称，可能会引起潜在的错误。
反例：
import java.util.*;
正例：
import java.util.Hashtable
JTEST中对应：
保存路径: Jtest4.5\jrules\CODSTA_IMPT. rule
目录：Rules－UserDefinedRules－CODSTA
级别：3
3 3 命名规则
命名规范的目的是提高程序的可读性，使程序易于理解。
命名的基本原则：
使用完整的英文描述符准确描述变量variable/域field/类class
较好的命名应该象firstName、grandTotal、CorporateCustomer, 而诸如x1、y1等命名反映任何命名含义，而且造成代码难以理解、维护和改进。
采用应用领域相关的术语来命名
软件开发人员应注意软件用户的一些约定术语，不应当随意的创造术语。这会降低软件的易维护性。
采用大小写混合的方式提高命名的可读性
一般情况下应该用小写字母来命名，其中类（class）和接口（interface）名称的首字母用大写。
谨慎使用缩写
设计命名中应该慎用缩写命名。如要采用，则应采用统一的缩略规则，并且在文中的相应部分统一采用缩写。例如，采用num作为number的缩写，那么在整个文档中应该始终使用该缩写。
避免太长的命名
命名的长度一般小于30个字母，最好不要超过15个字母。
避免采用仅有大小写不同命名
命名时应避免采用几乎相同的名称。例如，变量名称persistentObject和persistentObjects不应当同时运用；anSqlDatabase和anSQLDatabase也不应同时使用。
将标准缩略词的首字母进行大小写变化
有时名称中会含有固定的缩略词，例如SQL代表Standard Query Language. 而在命名时sqlDatabase和SqlDatabase就比sQLDatabase和SQLDatabase易于阅读。
避免下划线命名
| 【规则3_1】 标识符只能由26个英文字母，10个数字，及下划线的一个子集来组成，并严格禁止使用连续的下划线。 |
说明：这样做的目的是为了使程序易读。因为 variable_name 和 variable__name 很难区分，下划线符号‘_’若出现在标识符头或结尾，容易与不带下划线‘_’的标识符混淆。用户定义的标识符下划线也不能出现在标识符结尾
JTEST中对应：
暂不需要
级别：3
| 【建议】 标识符应当使用完整的英文描述，标识符的命名应当符合“min-length && max-information”原则，谨慎使用缩写。 |
说明：对于标识符应当使用完整的英文进行描述，对于整个描述较长的，可对单词进行缩略。对单词的缩略可按较短的单词可通过去掉“元音”形成缩写，较长的单词可取单词的头几个字母形成缩写，一些单词有大家公认的缩写，常用单词的缩写必须统一。协议中的单词的缩写与协议保持一致。对于某个系统使用的专用缩写应该在某处做统一说明。设计命名中应该慎用缩写命名。如要采用，则应采用统一的缩略规则，并且在代码的相应部分统一采用缩写。例如，采用num作为number的缩写，那么在整个代码中应该始终使用该缩写。
级别：5
| 【建议】标识符前最好不加个人姓名、姓名缩写、项目、产品、部门的标识。 |
说明：这样做的目的是为了代码的可重用性
级别：5
| 【建议】 保证用户自定义非静态字段命名、非静态局部变量命名、非静态方法命名、方法形式参数命名、静态方法命名等符合正则表达式。 |
级别：5
| 【规则3_3】 程序中不要出现仅靠大小写区分的相似的标识符。 |
说明：命名时应避免采用几乎相同的名称。例如，变量名称persistentObject和persistentObjects不应当同时运用；anSqlDatabase和anSQLDatabase也不应同时使用。
JTEST中对应：
待定。
级别：1
| 【规则3_4】保证包名全部用小写字母命名，在构成包名的单词之间不用下划线。 |
说明：包名是一个顶级域名（如当前的com,edu,gov,mil,net,org）或服从ISO Atandsrd 3166,1981中规定的两英文字母国家标识符。
包名称的随后成份根据组织自身的命名规范变化。这样的规范或许通过指定分公司、部门、项目、机器、帐户等来确定目录名成分。请看下面的示例说明：
com.sun.eng
com.apple.quicktime.v2
edu.cmu.cs.bovik.cheese
JTEST中对应：
保存路径: Jtest4.5\jrules\NAMING_PKG.rule
目录：Rules－UserDefinedRules－NAMING
级别：3
| 【规则3_5】 类名首字母大写，构成类名的单词之间用大小写分割，之间不用下划线。 |
JTEST中对应：
保存路径: Jtest4.5\jrules\ NAMING_CNX.rues
目录：Rules－UserDefinedRules－NAMING
级别：3
| 【规则3_6】 方法名称应采用完整的英文单词组成，首字母小写，在构成方法名的单词之间不用下划线。 |
说明：方法名力求清晰、明了，通过方法名就能够判断方法的主要功能。方法名中不同意义字段之间不要用下划线连接，而要把每个字段的首字母大写以示区分。方法命名采用大小写字母结合的形式，但专有名词不受限制。
JTEST中对应：
保存路径: Jtest4.5\jrules\ NAMING _MNX.rues
目录：Rules－UserDefinedRules－NAMING
级别：3
| 【规则3_7】常量静态字段全部用大写字母，构成标识符的多个单词之间用下划线分隔。 |
反例：
class USF {
public static final int size = 10; //违例
}
正例：
class USFFixed {
public static final int SIZE = 10; //正确
}
JTEST中对应：
保存路径: Jtest4.5\jrules\NAMING_USF.rule
目录：Rules－UserDefinedRules－NAMING
级别：3
| 【规则3_8】非静态、常量字段，包括全局变量和局部变量首字母小写。 |
JTEST中对应：
保存路径: 内嵌
目录 Rules－Built-in Rules－Naming Convention(NAMING)。
级别：2
| 【规则3_9】方法参数的首字母小写。 |
JTEST中对应：
保存路径: 内嵌
目录 Rules－Built-in Rules－Naming Convention(NAMING)。
级别：2
| 【规则3_10】 以get打头的方法不能返回boolean值。 |
反例：
public class GETA {
public int method () { //违例
return _count;
}
private int _count = 100;
}
正例：
public class GETAFixed {
public int getCount () {
return _count;
}
private int _count = 2; //正确
}
JTEST中对应：
保存路径: Jtest4.5\jrules\NAMING_GETA.rule
目录：Rules－UserDefinedRules－NAMING
级别：3
| 【规则3_11】 获取器方法返回值是boolean型的要以”is”,”have”,”can”,”has”打头，提高代码可读性。 |
反例：
public class GETB {
public boolean method () { //违例
return _ready;
}
private boolean _ready = false;
}
正例：
public class GETBFixed {
public boolean isReady () { //正确
return _ready;
}
private boolean _ready = false;
}
JTEST中对应：
保存路径: Jtest4.5\jrules\NAMING_GETB.rule
目录：Rules－UserDefinedRules－NAMING
级别：3
| 【规则3_12】 用”is”,”have”,”can”,”has”打头的方法必须返回boolean型. |
反例：
public class IRB {
public int isOK () { //违例
return _value;
}
private int _value;
}
正例：
public class IRBFixed {
public boolean isOK () { //正确
return _value;
}
private boolean _value;
}
JTEST中对应：
保存路径: Jtest4.5\jrules\NAMING_IRB.rule
目录：Rules－UserDefinedRules－NAMING
级别：3
| 【建议】 使用习惯的变量命名规则，增强代码的维护性。 |
说明：对于定义单个字母表示的变量一般遵循以下的规则：
· b 表示一个字节
· c 表示一个字符
· d 表示一个double
· f 表示一个float
· i, j, k 表示整数
· l表示一个常整形
· o表示一个对象
· s表示一个字符串
反例：
public class CVN {
void method () {
int b = 1; //违例
}
}
正例：
public class CVNFixed {
void method () {
int i = 1; //正确
}
}
级别：5
| 【建议】 组件接口的命名应该采用全英文单词，后缀为该组件的类型；命名应能够较好表达该组件的用途，并使得该组件易于在applet或application中查找。 |
说明：组件名称应避免诸如botton1、botton2等抽象的名称。建议组件接口命名时，前缀是组件的类型，因为控件的设计基本上都是可视化开发环境，当在界面上添加某个控件时，控件的名字都是有前缀(控件类型)+数字组成的，这样只需要修改数字即可，也不必移动光标，节省编写代码时间。
级别：5
| 【规则3_14】 数组（array）和vector的命名方法是，用array和vector所存对象名称的复数表示，名称为全英文单词组成，非开头单词的首字母采用大写。 |
JTEST中对应：
保存路径: Jtest4.5\jrules\NAMING_ARRS.rule
目录：Rules－UserDefinedRules－NAMING
保存路径: Jtest4.5\jrules\ NAMING _VECS.rule
目录：Rules－UserDefinedRules－NAMING
级别：3
| 【规则3_15】 数据流的命名以in或out或inOut打头。 |
说明：这是Sun公司的约定。
输入流
命名用in +“流名称”；
输出流
命名用out +“流名称”；
输入/输出流
命名用inOut +“流名称”;
JTEST中对应：
保存路径: Jtest4.5\jrules\FORMAT_INOUT.rule
目录：Rules－UserDefinedRules－FORMAT
级别：3
| 【规则3_16】 避免类方法和构造函数同名，提高代码可读性。 |
反例：
public class NAMING {
public NAMING () {} //构造函数
public void NAMING (int size) {} //违例
}
正例：
public class NAMINGFixed {
public NAMINGFixed () {} //构造函数
public NAMINGFixed (int size) {} //正确
}
JTEST中对应：
保存路径: Jtest4.5\jrules\PB_NAMING.rule
目录：Rules－UserDefinedRules－PB
级别：1
| 【规则3_17】 避免方法内的局部变量名称和类成员变量同名，提高代码可读性。 |
反例：
public class HMF {
public void method () {
final int i = 5; //违例
System.out.println (i);
}
private int i = 0;
}
正例：
public class HMFFixed {
public void method () {
final int x = 5; //正确
System.out.println (x);
}
private int i = 0;
}
JTEST中对应：
保存路径: Jtest4.5\jrules\MISC_HMF.rule
目录：Rules－UserDefinedRules－MISC
级别：1
| 【规则3_18】 避免类成员变量的名字和方法中的参数同名，提高代码可读性。 |
反例：
public class MPC {
void method (int i, int j) {} //违例
void j() {}
private int i = 0;
}
正例：
public class MPCFixed {
void method (int first, int second) {} //正确
void j() {}
private int i = 0;
}
JTEST中对应：
保存路径: Jtest4.5\jrules\PB_MPC.rule
目录：Rules－UserDefinedRules－PB
级别：2
4 4 声明规则
| 【规则4_1】 避免在一个声明语句中声明多个不同类型变量，比如一个整型变量，一个整型变量数组；避免在一个声明语句中声明多个变量，同时方便注释。 |
（与公司规范5－1相同）
反例：
class VDT{
private int index, index1[]; //违例：一个整型，一个整型数组
public void method ()
{
int aaa, bbb[]; //违例：一个整型，一个整型数组
int ccc;
int ddd;
}
}
class MVOS {
String s1，s2; //违例：同一个声明语句声明两个变量
public MVOS()
{
s1 = "hello";
s2 = "world";
}
}
正例：
class VDT {
private int index,
private index1[]; //正确
public void method () {
int aaa,
int bbb[]; //正确
int ccc;
int ddd;
}
}
class MVOS {
String s1; //正确
String s2; //正确
public MVOS() {
s1 = "hello";
s2 = "world";
}
}
JTEST中对应：
避免在一个声明语句中声明多个不同类型变量
保存路径: Jtest4.5\jrules\CODSTA_VDT.rule
目录：Rules－UserDefinedRules－CODSTA
避免在一个声明语句中声明多个变量
保存路径: Jtest4.5\jrules\CODSTA_MVOS. rule
目录：Rules－UserDefinedRules－CODSTA
级别：3
| 【建议】变量声明只应该放在代码段的开始部分。最好不要到使用时才声明变量。 |
说明：代码段是指花括号{}所包括的区域。唯一的例外是for循环中的循环变量。
正例：
void myMethod()
{
int myInt = 0; //方法块的开始
if (condition)
{
int yourInt = 0; //”if”块的开始
//其它语句
}
}
级别：5
| 【规则4_2】在循环体中避免声明变量，提高代码运行性能。 |
反例：
public class LOOP {
public void method(int max) {
for (int i = 0; i < max; i++) {
StringBuffer sb = new StringBuffer(); //违例
sb.append("loop: ");
sb.append(i);
System.out.println(sb.toString());
}
}
}
正例：
public class LOOPFixed {
public void method(int max) {
StringBuffer sb = new StringBuffer(); //正确
for (int i = 0; i < max; i++) {
sb.append("loop: ");
sb.append(i);
System.out.println(sb.toString());
sb.setLength(0);
}
}
}
JTEST中对应：
保存路径: Jtest4.5\jrules\ OPT_LOOP.rule
目录：Rules－UserDefinedRules－Optimization（OPT）
级别：1
| 【规则4_4】 声明长整形long变量时，结尾用大写字母”L”代替小写字母”l”，避免和数字”1”混淆，提高代码可读性。 |
JTEST中对应：
保存路径: Jtest4.5\jrules\CODSTA_LONG. rule
目录：Rules－UserDefinedRules－CODSTA
级别：3
| 【规则4_5】 声明数组时”[]”放在数组变量的前面，这和C/C++正好相反。 |
反例：
public class IAD {
private int attr[]; //违例
private String str1[]; //违例
}
正例：
public class IADFixed {
private int[] attr; // 正确
private String[] str1; // 正确
}
JTEST中对应：
保存路径: Jtest4.5\jrules\format_IAD.rule
目录：Rules－UserDefinedRules－FORMAT
级别：3
| 【规则24_6】 不能声明Date类型数组， 因为Date相对占有较大空间，这样节约资源，优化代码。 |
反例：
public class DUD {
Date d[]; // 违例
}
正例：
public class DUD {
long d[]; // 正确
}
JTEST中对应：
保存路径: Jtest4.5\jrules\GC_DUD.rule
目录：Rules－UserDefinedRules－GC
级别：3
| 【规则4_7】 对于不是实现接口的或者是重载的方法，如果没有使用任何实例类成员，包括方法和字段，那么就把方法声明为静态的，提高代码的封装性。 |
反例：
public class ASI {
public int add (int i, int j) { //违例
return i + j;
}
}
正例：
public class ASIFixed {
public static int method (int i, int j) { //正确
return i + j;
}
}
JTEST中对应：
保存路径: Jtest4.5\jrules\CODSTA_ASI. rule
目录：Rules－UserDefinedRules－CODSTA
级别：3
| 【建议】 对于一个子系统的代码，在一个接口中定义所有常量，提高代码的可维护性。 |
说明：
在一个类定义所有常量和在一个接口中定义所有常量没有什么区别，由用户来决定。
反例：
class DCI {
int getMax () {
return MAX;
}
static final int MAX = 1000; //违例
}
正例：
class DCI {
int getMax () {
return Constants.MAX;
}
}
interface Constants {
int MAX = 1000;
}
级别：5
| 【规则24_8】 在一个接口内部避免多余的修饰符。 |
反例：
interface AAI {
public void method (); //违例: 多余的"public"
abstract int getSize (); //违例: 多余的"abstract"
static int SIZE = 100; //违例: 多余的"static"
}
正例：
interface AAIFixed {
void method (); //正确
int getSize (); //正确
int SIZE = 100; //正确
}
JTEST中对应：
保存路径: 内嵌
目录 Rules－Built-in Rules－Unused Code （UC）
级别：2
| 【规则24_9】 如果抽象类所有方法是抽象型的，所有字段是静态常量，则把该类声名为接口。 |
反例：
abstract class ASFI { //违例
abstract void method();
final static String ID = "final static string";
}
正例：
interface ASFIFixed { //正确
void method();
String ID = "MISC_ASFI";
}
JTEST中对应：
保存路径: Jtest4.5\jrules\MISC_ASFI.rule
目录：Rules－UserDefinedRules－MISC
级别：1
| 【规则24_10】 私有常量字段要有final保留字。 |
反例：
public class FF {
private int size = 5; //违例
private int method (int x) {
return x + size;
}
}
正例：
public class FFFixed {
private final int size = 5; //正确
private int method (int x) {
return x + size;
}
}
JTEST中对应：
保存路径: Jtest4.5\jrules\MISC_FF.rule
目录：Rules－UserDefinedRules－MISC
级别：2
| 【规则24_11】 方法内的局部常量的声明要有final保留字。 |
反例：
package examples.rules.misc;
public class FLV {
private int method (int x) {
int size = 5; //违例
return size + x;
}
}
正例：
Declare the variable "final".
package examples.rules.misc;
public class FLVFixed {
private int method (int x) {
final int size = 5; //正确
return size + x;
}
}
JTEST中对应：
保存路径: Jtest4.5\jrules\MISC_FLV.rule
目录：Rules－UserDefinedRules－MISC
级别：2
| 【规则24_12】 保证内部类定义成pivate，提高类的封装性。 |
JTEST中对应：
保存路径: Jtest4.5\jrules\SECURITY_INNER.rule
目录：Rules－UserDefinedRules－SECURITY
级别：1
| 【规则24_13】 避免在非公共类声明公共构造函数。 |
反例：
class PCTOR {
public PCTOR () { //违例
}
}
正例：
class PCTORFixed {
private PCTOR () { //正确
}
}
JTEST中对应：
保存路径: Jtest4.5\jrules\MISC_PCTOR.rule
目录：Rules－UserDefinedRules－MISC
级别：1
| 【规则24_14】 非公共类避免定义公共常量字段、保护常量字段。 |
反例：
class APPF {
int _a = 10; //违例
private int _c = 14;
}
class APROF {
protected int _a = 10; //违例
}
class APROFFixed {
protected void setA (int a) { //正确
_a = a;
}
protected int getA () { //正确
return _a;
}
private int _a = 10; //正确
}
正例：
class APPFFixed {
public void setA (int a) { //正确
_a = a;
}
public int getA () { //正确
return _a;
}
private int _a = 10; //正确
private int _c = 14;
}
JTEST中对应：
保存路径: Jtest4.5\jrules\OOP_APPF.rule
目录：Rules－UserDefinedRules－OOP
保存路径: Jtest4.5\jrules\OOP_APROF.rule
目录：Rules－UserDefinedRules－OOP
级别：1
| 【建议】 避免使用public static final数组字段。 |
反例：
class PSFA {
public static final int[] MUTABLE = { 0 }; //违例
public static void main (String[] args) {
MUTABLE[0] = 1;
System.out.println ("MUTABLE[0]=" + MUTABLE[0]);
}
}
正例：
class PSFAFixed {
private static final int[] MUTABLE = { 0 }; //正确
public static final List unmutable =
Collections.unmodifiableList (Arrays.asList(MUTABLE));
}
JTEST中对应：
保存路径: Jtest4.5\jrules\MISC_PSFA.rule
目录：Rules－UserDefinedRules－MISC
级别：5
| 【规则24_15】 避免定义未使用的局部变量，优化代码。 |
JTEST中对应：
保存路径: Jtest4.5\jrules\UC_AUV.rule
目录：Rules－UserDefinedRules－UC
级别：2
| 【规则24_16】 对于不是实现接口的或者是重载的方法，避免定义没有使用的参数，优化代码。 |
JTEST中对应：
保存路径: Jtest4.5\jrules\UC_UP.rule
目录：Rules－UserDefinedRules－UC
级别：2
5 5 表达式和语句规则
| 【规则5_1】 If语句和else语句写成{ }代码块。 |
反例：
public class BLKIF {
public void method (boolean b) {
if (b) //违例
System.out.println ("inside of if");
else //违例
System.out.println ("OUTSIDE of if");
}
}
正例：
public class BLKIF {
public void method (boolean b) {
if (b) { //正确
System.out.println ("inside of if");
}
else { //正确
System.out.println ("OUTSIDE of if");
}
}
}
JTEST中对应：
保存路径: Jtest4.5\jrules\MISC_BLKIF.rule
目录：Rules－UserDefinedRules－MISC
保存路径: Jtest4.5\jrules\MISC_BLKELSE.rule
目录：Rules－UserDefinedRules－MISC
级别：3
| 【规则5_2】 避免if语句后的空语句体。 |
反例：
public class IEB {
void method (int i) {
if (i < 0) ; //违例
System.out.println("negative i");
}
}
正例：
public class IEBFixed {
void method (int i) {
if (i < 0) { //正确
System.out.println("negative i");
}
}
}
JTEST中对应：
保存路径: 内嵌
目录 Rules－Built-in Rules－Possible Bugs (PB)
级别：1
| 【规则5_3】 把数字常量放在比较表达式的右边。 |
JTEST中对应：
保存路径: Jtest4.5\jrules\CODSTA_CRS. rule
目录：Rules－UserDefinedRules－CODSTA
级别：3
| 【规则5_4】 避免在if条件语句中使用浮点型变量。 |
反例：
public class DCF {
int method (double d) {
if (d == 1.0) { //违例
return 1;
}
return 0;
}
}
正例：
public class DCFFixed {
int method (int d) { //正确
if (d == 1) {
return 1;
}
return 0;
}
}
JTEST中对应：
保存路径: Jtest4.5\jrules\PB_DCF.rule
目录：Rules－UserDefinedRules－PB
级别：2
| 【规则5_5】 避免在”if”条件中赋值。 |
说明：
Java编译器对boolean型变量在if条件语句中的赋值时合法的，对整型变量的赋值是不合法的，所以下面的反例在语法上是正确的，但不提倡这样写代码。
反例：
public class ASI {
public int foo (boolean b) {
int ret = 0;
if (b = true) { //违例
ret = 3;
}
return ret;
}
}
正例：
public class ASIFixed {
public int foo (boolean b) {
int ret = 0;
if (b) { //正确
ret = 3;
}
return ret;
}
}
JTEST中对应：
保存路径: Jtest4.5\jrules\PB_ASI.rule
目录：Rules－UserDefinedRules－PB
级别：1
| 【规则5_6】 for、while循环语句写成{ }代码块 |
反例：
public class BLKFOR{
public void method () {
for (int i = 0; i < 10; i++) //违例
System.out.println (i * i); //在循环内部
System.out.println (i); //在循环外部
}
}
正例：
public class BLKFORFixed {
public void method () {
for (int i = 0; i < 10; i++) { //正确
System.out.println (i * i); //在循环内部
System.out.println (i); //在循环内部
}
}
}
JTEST中对应：
保存路径: 内嵌
目录：Rules－Built-in Rules－Miscellaneous (MISC)
保存路径: Jtest4.5\jrules\MISC_BLKWHL.rule
目录：Rules－UserDefinedRules－MISC
级别：3
| 【规则5_7】 如果for循环语句不完整，则要么补全循环语句，要么用while替换。 |
反例：
public class PCIF {
void method (int i) {
for (; i < 1000; ) { //违例
i++;
}
}
}
正例：
public class PCIFFixed {
void method (int i) {
while (i < 1000) { // 正确
i++;
}
}
}
JTEST中对应：
保存路径: Jtest4.5\jrules\MISC_PCIF.rule
目录：Rules－UserDefinedRules－MISC
级别：1
| 【规则5_8】 避免for循环语句后是空语句。 |
反例：
public class FEB {
void method () {
for (int i = 0; i < 10; i++) ; //违例
System.out.println (i); //该语句在循环的外面
}
}
正例：
public class FEBFixed {
void method () {
for (int i = 0; i < 10; i++) { //正确
System.out.println (i); //该语句在循环的里面
}
}
}
JTEST中对应：
保存路径: 内嵌
目录 Rules－Built-in Rules－Possible Bugs (PB)
级别：1
| 【规则5_9】 在for循环语句体中，避免对循环控制变量赋值。 |
反例：
public class FLVA {
int method () {
int sum = 0;
for (int i = 0; i < 100; i++) {
i += 3; //违例
sum += i;
}
}
}
正例：
public class FLVA {
int method () {
int sum = 0;
for (int i = 0; i < 100; i += 4) { //正确
sum += i;
}
return sum;
}
}
JTEST中对应：
保存路径: Jtest4.5\jrules\PB_FLVA.rule
目录：Rules－UserDefinedRules－PB
级别：1
| 【规则5_10】 避免使用实型变量作为循环的边界条件。 |
反例：
class UBD {
public static void main(String[] args) {
double funds = 1.0; //违例
int itemsBought = 0;
for (double price = .10; funds >= price; price += .10) { //违例
funds -= price;
itemsBought++;
}
System.out.println(itemsBought + " items bought.");
System.out.println("Change : $" + funds);
}
}
正例：
class UBDFixed {
public static void main(String[] args) {
final BigDecimal TEN_CENTS = new BigDecimal(".10"); //正确
int itemsBought = 0;
BigDecimal funds = new BigDecimal("1.00"); //正确
for (BigDecimal price = TEN_CENTS;
funds.compareTo(price) >= 0;
price = price.add(TEN_CENTS)) {
itemsBought++;
funds = funds.subtract(price);
}
System.out.println(itemsBought + " items bought.");
System.out.println("Money left over: $" + funds);
}
}
JTEST中对应：
保存路径: Jtest4.5\jrules\MISC_UBD.rule
目录：Rules－UserDefinedRules－MISC
级别：1
| 【规则5_11】 避免在循环表达式中调用函数或方法，提高代码性能。 |
反例：
class CEL {
void method (Vector vector) {
for (int i = 0; i < vector.size (); i++) // 违例
{
System.out.println(i);
}
}
}
正例：
class CELFixed {
void method (Vector vector) {
int size = vector.size ();
for (int i = 0; i < size; i++) //正确
{
System.out.println(i);
}
}
}
JTEST中对应：
保存路径: Jtest4.5\jrules\OPT_CEL.rule
目录：Rules－UserDefinedRules－OPT
级别：3
| 【建议】 避免在循环语句内部出现”try/catch/finally”，优化代码。 |
反例：
public class TRY {
void method (FileInputStream fis) {
for (int i = 0; i < size; i++) {
try { //违例
_sum += fis.read ();
}
catch (Exception e) {
e.printStackTrace();
}
}
}
private int _sum;
}
正例：
public class TRY {
void method (FileInputStream fis) {
try { //正确
for (int i = 0; i < size; i++) {
_sum += fis.read ();
}
}
catch (Exception e) {
e.printStackTrace();
}
}
}
级别：5
| 【规则5_12】 对每个switch语句都要有default分支，每个分支语句都要包括break语句。提高代码可读性，防止潜在的bugs。 |
反例：
public class PDS {
void method (int i) {
switch (i) { //违例
case 0:
System.out.println ("Zero");
break;
}
}
}
public class SBC {
int method (int i) {
int x = 0;
switch (i) {
case 1:
x = 10;
break;
case 2: //违例
x = 20;
default:
a = 40;
break;
}
}
}
正例：
public class PDSFixed {
void method (int i) {
switch (i) {
case 0:
System.out.println ("Zero");
break;
default: //正确
}
}
}
public class SBCFixed {
void method (int i) {
int x = 0;
switch (i) {
case 1:
x = 10;
break;
case 2: //违例
x = 20;
break;
default:
x = 40;
break;
}
}
}
JTEST中对应：
保存路径: 内嵌
目录 Rules－Built-in Rules－Possible Bugs (PB)
保存路径: 内嵌
目录 Rules－Built-in Rules－Possible Bugs (PB)
级别：1
| 【规则5_13】 在switch语句中，避免把case分支写成文本标签。 |
反例：
public class TLS {
static int method (int i) {
switch (i) {
case 4:
case3: //违例: label typo
i++;
break;
case 25:
unusedlabel: //违例: unused label.
break;
}
return i;
}
}
正例：
public class TLSFixed {
static int method (int i) {
switch (i) {
case 4:
case 3: //正确
i++;
break;
case 25:
//正确
break;
}
return i;
}
}
JTEST中对应：
保存路径: 内嵌
目录 Rules－Built-in Rules－Possible Bugs (PB)
级别：1
| 【规则5_14】 在返回(return)语句中避免使用”( )”。 |
JTEST中对应：
保存路径: Jtest4.5\jrules\format_UP.rule
目录：Rules－UserDefinedRules－FORMAT
级别：3
| 【规则5_15】 赋值语句避免嵌套赋值，避免在一条语句中将一个数值赋给多个变量，提高代码可读性。 |
反例：
public class NEA{
int method (int i, int j)
{
int k = (i = i + j) + j; //违例
return k;
}
}正例：
public class NEAFixed
{
int method (int i, int j)
{
i = i + j; //正确
int k = i + j; //正确
return k;
}
JTEST中对应：
赋值语句避免嵌套赋值：
保存路径: 内嵌
目录 Rules－Built-in Rules－Coding Conventions(CODSTA)
避免在一条语句中将一个数值赋给多个变量:
保存路径: Jtest4.5\jrules\FORMAT_MUTIVAR.rule
目录：Rules－UserDefinedRules－FORMAT
级别：1
| 【规则5_16】 用”?”号操作符替换if条件赋值语句。 |
反例：
public class IFAS {
void method(boolean isTrue) {
if (isTrue) //违例
_value = http://www.mamicode.com/0;
else
_value = http://www.mamicode.com/1;
}
private int _value = http://www.mamicode.com/0;
}
正例：
public class IFASFixed {
void method(boolean isTrue) {
_value = http://www.mamicode.com/(isTrue ? 0 : 1); //正确
}
private int _value = http://www.mamicode.com/0;
}
JTEST中对应：
保存路径: Jtest4.5\jrules\OPT_IFAS.rule
目录：Rules－UserDefinedRules－OPT
级别：4
| 【规则5_17】 在一个独立的方法中，使用”!”运算符不允许多于三次，提高代码的可读性。 |
反例：
public class DUN {
boolean method (boolean a, boolean b) { // 违例
if (!a)
return (!a && !b);
else
return !b;
}
}
正例：
public class DUNFixed {
boolean method (boolean a, boolean b) {
if (a)
return !b;
else
return (! (a || b) );
}
}
例外：
在方法的注释中存在@JTI5_17
JTEST中对应：
保存路径: Jtest4.5\jrules\CODSTA_DUN. rule
目录：Rules－UserDefinedRules－CODSTA
级别：2
| 【规则5_18】 在字符串连接运算中，避免连续和数字相加，防止错误。 |
反例：
public class DCP {
public static void main (String args []) {
System.err.println ("2+9 = " + 2 + 9); //违例
}
}
正例：
public class DCPFixed {
public static void main (String args []) {
System.err.println ("2+9 = " + (2 + 9)); //正确
}
}
JTEST中对应：
保存路径: 内嵌
目录 Rules－Built-in Rules－Possible Bugs (PB)
级别：3
| 【规则5_19】 如果一个字符串和单个字符进行串联运算,则用单号替代双引号。 |
反例：
public class STR {
public String method(String s) {
String string = s + "d"; //违例
return string;
}
}
正例：
public class STRFixed {
public void method(String s) {
String string = s + ‘d‘; //正确
return string;
}
}
JTEST中对应：
保存路径: Jtest4.5\jrules\OPT_STR.rule
目录：Rules－UserDefinedRules－OPT
级别：3
| 【规则5_20】 对象比较、字符串比较时，使用equals ()方法。 |
反例：
public class UEI {
public boolean notEqual (Choice other) {
boolean monthly = co.getSelectedItem () != other; //违例
return monthly;
}
private Choice co = null;
}
正例：
public class UEIFixed {
public boolean notEqual (Choice other) {
boolean monthly = !(co.getSelectedItem ().equals (other)); //正确
return monthly;
}
private Choice co = null;
}
JTEST中对应：
保存路径: Jtest4.5\jrules\PB_UEI.rule
目录：Rules－UserDefinedRules－PB
保存路径: Jtest4.5\jrules\PB_UEI2.rule
目录：Rules－UserDefinedRules－PB
级别：2
| 【建议】 避免强制的转换高精度类型为低精度类型。 |
反例：
public class CLP {
void method () {
double d = 4.25;
int I;
i = this.square ((int) d); //违例
}
int square (int i) {
return I;
}
}
JTEST中对应：
保存路径: 内嵌
目录 Rules－Built-in Rules－Possible Bugs (PB)
级别：5
| 【规则5_21】 禁止在循环体中使用字符串相加。TEST-LOOPS |
反例：
public class DCP {
public static void main (String args []) {
String s = “”;
for ( int I=0; I<100; I++ ) {
s = s + “ aaa” + I;
}
}
}
正例：
public class DCPFixed {
public static void main (String args []) {
StringBuffer sb = new StringBuffer();
for ( int I=0; I<100; I++ ) {
sb.append(“ aaa”);
sb.append(i);
}
}
}
JTEST中对应：
保存路径: Jtest4.5\jrules\TEST_LOOPS.rule
目录：Rules－UserDefinedRules－TEST
级别：3
| 【规则5_22】 禁止将null作为equals方法的参数。 |
反例：
void method () {
if (a.equals(null)) // 违例
}
正例：
void method (){
if (a == null) //正确
}
JTEST中对应：
保存路径: Jtest4.5\jrules\TEST_ANEP2.rule
目录：Rules－UserDefinedRules－TEST
级别：1
| 【规则5_23】 禁止出现 a = a 样式的赋值语句。 |
JTEST中对应：
保存路径: Jtest4.5\jrules\TEST_AEA.rule
目录：Rules－UserDefinedRules－TEST
级别：1
6 6 注释规则
JAVA程序有两类注释：一类是实现性注释（implementation comments），另一类是文档型注释（documentation comments）。其中，Implementation 注释有C和C++两种格式，/*...*/ 和//。文档型注释是JAVA程序所独有的，在/**...*/中限定。文档型注释能够被javadoc文件工具提取到HTML文件中。
Implementation注释用于注释代码或者注释特殊的实现。文档型注释主要是描述代码段的说明，从一种非面向实现的角度来写给开发人员阅读，这些开发人员可能手边并没有源代码。
通常注释应该是给代码一个总的描述或者提供从代码本身不太容易看出的附加性信息。注释的内容应只与读代码和理解代码有关。例如，关于相应的包（package）是如何构建，以及存放在什么目录中，不应该包括在注释中。对代码中不太明显的设计意图进行说明是应该的，但也应避免对一些明显的信息进行重复说明，尽量避免那些随着代码的维护会过时的注释。
注意：
- 过于频繁的注释常常意味着代码质量较低。但你觉得必须频繁添加注释时，应考虑重写该段代码了。
- 注释内容不应封在星号（*）或者其它字母围成的矩形框中；注释中不应带有特殊注释字符如制表符（form-feed）和退格符（backspace）。
文档注释基本原则：
- 注释应能使代码更加明确
- 避免注释部分的过度装饰
- 保持注释部分简单、明确
- 在编码以前就应开始写注释
- 注释应说明设计思路而不是描述代码的行为
| 【规则6_1】 注释说明应与代码保持一致，去掉无关的注释。 |
反例：
public class SYNTAX {
/** @throws an io exception */ //违例
FileInputStream openFile (String path) {
throws java.io.IOException；
}
/** @throws no exceptions */ //违例
static void method () {
}
}
正例：
public class SYNTAXFixed {
/** @throws IOException */ //正确
FileInputStream openFile (String path) {
throws IOException;
}
/** @throws $none */ //正确
static void method () {
}
}
JTEST中对应：
无。
级别：4
| 【规则6_2】 一个类或者接口的Java文档注释不低于20%。 |
JTEST中对应：
保存路径: Jtest4.5\jrules\JAVADOC_PERCENT.rule
目录：Rules－UserDefinedRules－JAVADOC
级别：3
| 【规则6_3】 注释符与注释内容之间要用一个空格进行分隔。 |
反例：
/*注释内容*/
//注释内容
正例：
/* 注释内容 */
// 注释内容
JTEST中对应：
待定。
级别：4
| 【规则6_4】 注释应与其描述的代码相近，对代码的注释应放在其上方或右方（对单条语句的注释）相邻位置，不可放在下面，如放于上方则需与其上面的代码用空行隔开。 |
说明：在使用缩写时或之前，应对缩写进行必要的说明。
正例：
如下书写比较结构清晰
// 获得子系统索引
subSysIndex = data.getSysIndex;
// 代码段1注释
[ 代码段1 ]
/* 代码段2注释 */
[ 代码段2 ]
反例1：
如下例子注释与描述的代码相隔太远。
/* 获得子系统索引 */
subSysIndex = subSys.getSysIndex();
反例2：
如下例子注释不应放在所描述的代码下面。
subSysIndex = subSys.getSysIndex();
/* 获得子系统索引 */
反例3：
如下例子，显得代码与注释过于紧凑。
/* 代码段1注释 */
[ 代码段1 ]
/* 代码段2注释 */
[ 代码段2 ]
JTEST中对应：
暂不需要
级别：4
| 【规则6_5】 注释与所描述内容进行同样的缩进。 |
说明：可使程序排版整齐，并方便注释的阅读与理解。
正例：
如下注释结构比较清晰
int doSomething(){
/* 代码段1注释 */
[ 代码段1 ]
/* 代码段2注释 */
[ 代码段2 ]
}
反例：
如下例子，排版不整齐，阅读不方便；
int doSomething()
{
/* 代码段1注释 */
[ 代码段1 ]
/* 代码段2注释 */
[ 代码段2 ]
}
JTEST中对应：
暂不需要
级别：4
| 【规则6_6】 注释使用中文注释。与doc有关的标准英文单词标签保留。 |
说明：与doc相关的标签如下表：
| 标签 |
用处 |
用途 |
| @author 作者的名称 |
类、接口 |
说明特定某一段程序代码的作者。每一个作者各有一个标记。 |
| @deprecated |
类、方法 |
说明该类的应用程序编程接口 (API) 已被废弃，因此应不再使用。 |
| @exception name description |
方法 |
说明由方法发出的异常。一个异常采用一个标记，并要给出异常的完整类名。 |
| @param name 参数名的描述 |
方法 |
用来说明传递给一个方法的参数，其中包括参数的类型/类和用法。每个参数各有一个标记。 |
| @return 方法返回值的描述 |
方法 |
若方法有返回值，对该返回值进行说明。应说明返回值的类型/类和可能的用途。 |
| @since |
类、方法 |
说明自从有 JDK 1.1 以来，该项已存在了多长时间。 例如： since JDK 1.1 |
| @see 类名 |
类、接口、方法、字段 |
在文档中生成指向特定类的超文本链接。可以并且应该采用完全合法的类名。 |
| @see ClassName#member functionName |
类、接口、方法、字段 |
在文档中生成指向特定方法的超文本链接。可以并且应该采用完全合法的类名。 |
| @version 版本号 |
类、接口 |
说明特定一段代码的版本信息。 |
级别：3
| 【规则6_7】 在Java文档注释中，避免使用不存在的”@”标记 |
说明：
比如方法中没有参数，那么就不应该再有@值注释标记。符合Java文档注释规范
反例：
/**
* Javadoc comment
* @unsupported tag
*/
public class BT {
}
正例：
/**
* Javadoc comment
* replaced tag with comment text. //正确
*/
public class BT {
}
JTEST中对应：
保存路径: 内嵌
目录 Rules－Built-in Rules－Javadoc Comments （JAVADOC）
级别：3
| 【建议】通过对方法、变量等正确的命名以及合理地组织代码结构，使代码成为自注释的。 |
说明：清晰准确的方法、变量的命名，可增加代码的可读性，减少不必要的注释。
级别：5
| 【建议】尽量避免在注释中使用缩写，特别是不常用缩写。 |
说明：在使用缩写时，应对缩写进行必要的说明。
级别：5
| 【规则6_8】 源文件有头注释，注明作者、版权、版本信息，提高代码可维护性。源文件的头注释等同于和源文件同名的类的注释。 |
正例：
/**
* <p>文件名称: 题目名称</p>
* <p>文件描述: 本类描述</p>
* <p>版权所有: 版权所有(C)2001-2004</p>
* <p>公 司: *******</p>
* <p>内容摘要: // 简要描述本文件的内容，包括主要模块、函数及其功能的说明</p>
* <p>其他说明: // 其它内容的说明</p>
* <p>完成日期：// 输入完成日期，例：2000年2月25日</p>
* <p>修改记录1: // 修改历史记录，包括修改日期、修改者及修改内容</p>
* <pre>
* 修改日期：
* 版 本 号：
* 修 改 人：
* 修改内容：
* </pre>
* <p>修改记录2：…</p>
* @version 1.0
* @author 作者姓名
*/
JTEST中对应：
无。
级别：5
| 【规则6_9】 源文件Java文档注释中，要使用”@version”标记，注明版本。提高代码可维护性。 |
JTEST中对应：
保存路径: Jtest4.5\jrules\JAVADOC_MVJDT.rule
目录：Rules－UserDefinedRules－JAVADOC
级别：3
| 【规则6_10】源文件Java文档注释中，要使用”@author”标记，注明作者，提高代码可维护性。 |
JTEST中对应：
保存路径: Jtest4.5\jrules\JAVADOC_MAJDT.rule
目录：Rules－UserDefinedRules－JAVADOC
级别：3
| 【规则6_11】 在公共类、保护类、私有包类、私有类和接口中都要提供Java文档注释说明，提高代码可读性。 |
JTEST中对应：
保存路径: Jtest4.5\jrules\ JAVADOC_PJDCC.rule
目录：Rules－UserDefinedRules－JAVADOC
级别：3
| 【规则6_12】 接口的方法和类公共方法都应该有JAVA文档注释；在公共方法Java文档注释中，对每个参数都使用”@para”进行说明，提高代码可读性；在公共方法的Java文档注释中，除返回值为void之外，要使用”@return”标记，注明返回值，提高代码可维护性；在同步公共方法使用”@concurrency”Java文档注释标记；如果公共方法处理了异常，则在公共方法Java文档注释中应有”@ throws”或”@Excepation”标记说明。 |
JTEST中对应：
保存路径: Jtest4.5\jrules\ JAVADOC_PJDCM.rule
目录：Rules－UserDefinedRules－JAVADOC
保存路径: Jtest4.5\jrules\ JAVADOC_Param.rule
目录：Rules－UserDefinedRules－JAVADOC
保存路径: Jtest4.5\jrules\JAVADOC_MRDC.rule
目录：Rules－UserDefinedRules－JAVADOC
保存路径: Jtest4.5\jrules\ JAVADOC_SMJT.rule
目录：Rules－UserDefinedRules－JAVADOC
保存路径: Jtest4.5\jrules\ JAVADOC_THROW.rule
目录：Rules－UserDefinedRules－JAVADOC
级别：3
| 【规则6_13】 Package方法都应该有JAVA文档注释；在同步Package方法使用”@concurrency”Java文档注释标记；如果Package方法处理了异常，则在Package方法Java文档注释中应有”@ throws”或”@Excepation”标记说明。 |
JTEST中对应：
保存路径: Jtest4.5\jrules\ JAVADOC_PJDCM3.rule
目录：Rules－UserDefinedRules－JAVADOC
保存路径: Jtest4.5\jrules\ JAVADOC_SMJT3.rule
目录：Rules－UserDefinedRules－JAVADOC
保存路径: Jtest4.5\jrules\ JAVADOC_THROW3.rule
目录：Rules－UserDefinedRules－JAVADOC
级别：3
| 【规则6_14】 保护方法都应该有JAVA文档注释；在同步保护方法使用”@concurrency”Java文档注释标记；如果保护方法处理了异常，则在保护方法Java文档注释中应有”@ throws”或”@Excepation”标记说明。 |
JTEST中对应：
保存路径: Jtest4.5\jrules\ JAVADOC_PJDCM2.rule
目录：Rules－UserDefinedRules－JAVADOC
保存路径: Jtest4.5\jrules\ JAVADOC_SMJT2.rule
目录：Rules－UserDefinedRules－JAVADOC
保存路径: Jtest4.5\jrules\ JAVADOC_THROW2.rule
目录：Rules－UserDefinedRules－JAVADOC
级别：3
| 【规则6_17建议】 私有方法应该有JAVA文档注释。同步保护方法使用”@concurrency”Java文档注释标记；JAVADOC-SMJT2-2 |
JTEST中对应：[z2]
待定
级别：3
| 【建议】 Java语言中，公共的属性采用单行文档注释，对于需要比较多的声明的，可进行多行注释。 |
说明：注释的原则是有助于对程序的阅读理解，注释不宜太多也不能太少，注释语言必须准确、易懂、简洁。有效的注释是指在代码的功能、意图层次上进行注释，提供有用、额外的信息。
对于public型变量的单行声明：
正例：
/** classVar1 对classVar1的声明 */
public static int classVar1;
对于public型变量的多行声明：
正例：
/**
* classVar1 对classVar1的声明第一行
* 对classVar1的声明第二行（继续对classVar1的声明）
*/
public static int classVar1;
对于public型变量的多行声明：
正例：
/**
* classVar1 对classVar1的声明第一行
* 对classVar1的声明第二行（继续对classVar1的声明）
*/
public static int classVar1;
级别：5
| 【规则6_15】 如有”toString()”方法，要对其进行Java文档注释。 |
说明：建议每个类都定义一个toString()方法。
JTEST中对应：
保存路径: Jtest4.5\jrules\JAVADOC_TSMJT.rule
目录：Rules－UserDefinedRules－JAVADOC
级别：3
| 【规则6_16】 对void方法，避免使用”@return” Java文档注释标记。 |
JTEST中对应：
保存路径: Jtest4.5\jrules\JAVADOC_VMCR.rule
目录：Rules－UserDefinedRules－JAVADOC
级别：3
7 7 初始化和回收规则
| 【规则7_1】 在构造函数中确保初始化所有字段；在方法中确保初始化所有局部变量；确保初始化所有静态字段；避免因未初始化的字段而导致潜在的bugs。 |
反例：
class CSI {
CSI () {
this (12);
k = 0;
}
CSI (int val) {
j = val;
}
public boolean method (int size) {
int max; //违例
return size > 0;
}
private int i = 5;
private int j;
private int k;
}
正例：
class CSIFixed {
CSIFixed () {
this (12);
}
CSIFixed (int val) {
j = val;
k = 0; //正确
}
public boolean method (int size) {
int max = 0; // 正确
return size > 0;
}
private int i = 5;
private int j;
private int k;
}
JTEST中对应：
在构造函数中确保初始化所有字段
保存路径：内嵌
目录 Rules－Built-in Rules－Initialization （INIT）
确保初始化所有静态字段
保存路径：内嵌
目录 Rules－Built-in Rules－Initialization （INIT）
在方法中确保初始化所有局部变量
保存路径: Jtest4.5\jrules\INIT_LV.rule
目录：Rules－UserDefinedRules－INIT
级别：2
| 【规则7_2】 在初始化过程中，避免使用非常量静态字段，因为静态字段的生存期是整个系统的过程，这样尽可能的节省资源。 |
反例：
public class NFS {
static int max = 10;//违例
int size = max; //违例
}
正例：
public class NFS{
static final int MAX = 10; //正确
static int max = 10;
int size = NFS.MAX; //正确
}
JTEST中对应：[z3]
保存路径: Jtest4.5\jrules\INIT_NFS.rule
目录：Rules－UserDefinedRules－INIT
级别：2
| 【规则7_3】 初始化字符串对象时避免使用new保留字，避免资源浪费。 |
反例：
void method () {
System.out.println (_s);
}
private String _s = new String ("ACDO");
正例：
void method (){
System.out.println (_s);
}
private String _s = "ACDO"; // 正确
JTEST中对应：
保存路径: Jtest4.5\jrules\CODSTA_ACDO.rule
目录：Rules－UserDefinedRules－CODSTA
级别：3
| 【规则7_4】 不允许在一个finalize( )删除事件监听器，避免垃圾回收器无法回收资源。 |
反例：
public class FM extends Applet {
public void finalize () throws Throwable {
beepButton.removeActionListener (act); //违例
}
public void init () {
beepButton = new Button ("Beep");
act = new FMAction ();
this.add (beepButton);
beepButton.addActionListener (act);
}
class FMAction implements ActionListener {
public void actionPerformed (ActionEvent ae) {
Toolkit tk = Toolkit.getDefaultToolkit ();
tk.beep ();
}
}
private Button beepButton;
private FMAction act;
}
JTEST中对应：
保存路径: Jtest4.5\jrules\GC_FM.rule
目录：Rules－UserDefinedRules－GC
级别：1
| 【规则7_5】 在finalize ()方法的finally块中调用super.finalize ( )。 |
反例：
class IFF {
public void finalize () throws Throwable {
try {
}
catch (Exception e) {
}
finally { //违例
return;
}
}
}
正例：
class IFFFixed {
public void finalize () throws Throwable {
try {
}
catch (Exception e) {
}
finally {
super.finalize (); // 正确
}
}
}
JTEST中对应：
保存路径: Jtest4.5\jrules\GC_IFF.rule
目录：Rules－UserDefinedRules－GC
级别：1
| 【规则7_6】 避免显式的调用finalize ()方法，防止垃圾回收器无法回收资源。 |
反例：
class NCF {
public void finalize () throws Throwable {
close_resources ();
super.finalize ();
}
public void close_resources () {}
}
class Test {
void cleanup () throws Throwable {
_ncf.finalize (); //违例
_ncf = null;
}
private NCF _ncf = new NCF ();
}
正例：
class NCFFixed {
public synchronized void release () throws Throwable{
if (!_released) {
close_resources (); // do what the old ‘finalize ()‘ did
_released = true;
}
}
public void finalize () throws Throwable {
release ();
super.finalize ();
}
public void close_resources () {}
private boolean _released = false;
}
class TestFixed {
void closeTest () throws Throwable {
_ncf.release (); //正确
_ncf = null;
}
private NCFFixed _ncf = new NCFFixed ();
}
JTEST中对应：
保存路径: Jtest4.5\jrules\GC_NCF.rule
目录：Rules－UserDefinedRules－GC
级别：1
| 【规则7_7】 初始化Boolean对象时避免使用new保留字，避免资源浪费。 |
反例：
void method () {
System.out.println (_s);
}
private Boolean _s = new Boolean (true); // 违例
正例：
void method (){
System.out.println (_s);
}
private Boolean _s = Boolean.valueOf(true); // 正确
JTEST中对应：
保存路径: Jtest4.5\jrules\TEST_ANCB.rule
目录：Rules－UserDefinedRules－TEST
级别：3
8 8 异常处理规则
| 【规则8_1】 避免直接或间接的定义扩展Error或Throwable的异常。 |
反例：
public class NDC_Exception extends Error { //违例
public NDC_Exception (String s) {
super(s);
}
}
正例：
public class NDC_ExceptionFixed extends Exception { //正确
public NDC_ExceptionFixed (String s) {
super(s);
}
}
JTEST中对应：
保存路径: Jtest4.5\jrules\PB_NDC.rule
目录：Rules－UserDefinedRules－PB
级别：1
| 【规则8_2】 避免直接或间接的定义扩展’RuntimeException’的异常。 |
反例：
public class NXRE extends RunTimeException { //违例
public NXRE (String s) {
super(s);
}
}
正例：
public class NXREFixed extends Exception { //正确
public NXREFixed (String s) {
super(s);
}
}
例外：
在类的标记中声明了@JTI8_2的除外
JTEST中对应：
保存路径: Jtest4.5\jrules\PB_NXRE.rule
目录：Rules－UserDefinedRules－PB
级别：1
| 【规则8_3】 捕获用户自定义的异常要继承Exception。 |
JTEST中对应：
保存路径: 内嵌
目录 Rules－Built-in Rules－Naming Convention(NAMING)
级别：2
| 【规则8_4】 Catch语句块不能为空。 |
说明：如果Catch语句块为空，那么在try语句产生异常时，会把异常给屏蔽掉，导致异常捕获不到，产生意想不到的后果。
反例：
public class AECB {
public void method () {
try {
System.in.read ();
}
catch (java.io.IOException e) {
//违例
}
}
}
正例：
public class AECBFixed {
public void method () {
try {
System.in.read ();
}
catch (java.io.IOException ignore) {
}
}
}
JTEST中对应：
保存路径: Jtest4.5\jrules\PB_AECB.rule
目录：Rules－UserDefinedRules－PB
保存路径: Jtest4.5\jrules\PB_AECB2.rule（针对嵌套的catch语句）
目录：Rules－UserDefinedRules－PB
级别：1
| 【规则8_5】 禁止直接catch 异常“‘RuntimeException‘Exception”或者” ‘Throwable”，而应该捕获具体的异常类型。对于catch “Exception”的情况，只允许在实现线程的run方法或者finally语句块中出现。加TEST-AETR? |
反例：
public class AECB {
public void method () {
try {
System.in.read ();
}
catch(Exception e) { //违例
System.out.println("Descriptive error");
}
}
}
正例：
public class AECBFixed {
public void method () {
try {
System.in.read ();
}
catch (java.io.IOException e) {
System.out.println("Descriptive error"); //正确
}
}
}
JTEST中对应：[z4]
保存路径: Jtest4.5\jrules\CODSTA_NCE.rule和CODSTA_NCE2.rule
目录：Rules－UserDefinedRules－Coding Convention （CODSTA）
级别：1
| 【规则8_6】 定义扩展Exception类的异常，避免直接抛出Exception类异常，防止可能的捕获不到某些异常。 |
反例：
public class NTX {
void lostDetailsTest () throws Exception { //违例
throw new java.io.IOException ("IO exception");
}
}
正例：
public class NTXFixed {
void lostDetailsTest () throws java.io.IOException { //正确
throw new java.io.IOException ("IO exception");
}
}
JTEST中对应：
保存路径: 内嵌
目录 Rules－Built-in Rules－Coding Conventions(CODSTA)
级别：1
| 【规则8_8】 禁止在CATCH语句中不做任何处理，仅仅将异常简单抛出 |
反例：
public class AECB {
public void method () throw IOException{
try {
System.in.read ();
}
catch(IOException e) { //违例
throw e；
}
}
}
正例：
public class AECBFixed {
public void method () throws IOException{
System.in.read ();
}
}
JTEST中对应：
通过走查
级别：1
9 9 线程和同步规则
| 【规则9_1】 用notifyAll()方法替代notify()方法。 |
说明：当多个线程有等待同一个对象，notify()唤醒其中的某个等待线程，而无法确定唤醒哪个线程。使用notifyAll()可以唤醒所有线程。
反例：
public class ANF {
public synchronized void notifyThread () {
notify (); //违例
}
}
正例：
public class ANFFixed {
public synchronized void notifyThread () {
notifyAll (); //正确
}
}
JTEST中对应：
保存路径: Jtest4.5\jrules\TRS_ANF.rule
目录：Rules－UserDefinedRules－TRS
级别：1
| 【规则9_2】 避免使用java.lang.ThreadGroup类型的变量，处于安全方面的考虑。 |
说明：java.lang.ThreadGroup在安全方面有缺陷，而且也没有必要这样定义，使用数组定义。
JTEST中对应：
保存路径: Jtest4.5\jrules\TRS_AUTG.rule
目录：Rules－UserDefinedRules－TRS
级别：1
| 【规则9_3】 避免使用“Thread.yield( )”方法。 |
说明：当应用程序运行在不同的虚拟机上时，Thread.yield对程序行为产生无法预知的后果。如果你依据Thread.yield( )来作为程序存活周期和安全机制，那么你的程序就不能一直保持正常运行。尽可能的减少当前运行的线程数。
JTEST中对应：
保存路径: Jtest4.5\jrules\TRS_AUTY.rule
目录：Rules－UserDefinedRules－TRS
级别：1
| 【规则9_4】 避免在同步方法中再调用同步方法而导致死锁。 |
反例：
public class CSFS extends Thread
{
public static void main (String[] args)
{
CSFS thread1 = new CSFS ();
CSFS thread2 = new CSFS ();
thread1.setMonitor (thread2);
thread2.setMonitor (thread1);
thread1.start ();
thread2.start ();
//程序将退出: thread1和thread2死锁.
}
public synchronized void run ()
{
// 给其它线程让出时间开时运行
try { Thread.sleep (1000); } catch (InterruptedException e) {}
_monitor.synchronizedMethod (); // 违例
}
synchronized void synchronizedMethod () {}
void setMonitor (CSFS monitor) {_monitor = monitor;}
private CSFS _monitor;
}
JTEST中对应：
保存路径: Jtest4.5\jrules\TRS_CSFS.rule
目录：Rules－UserDefinedRules－TRS
级别：2
| 【规则9_5】 定义扩展了线程的子类，要有run( )方法。 |
反例：
public class MRUN extends Thread{
public MRUN () {}
// 违例, 没有run()
}
正例：
public class MRUNFixed extends Thread {
public MRUNFixed extends Thread () {}
public void run () {} // 正确
}
JTEST中对应:
保存路径: Jtest4.5\jrules\TRS_MRUN.rule
目录：Rules－UserDefinedRules－TRS
级别：1
| 【规则9_6】 避免调用‘Thread.resume ()‘、‘Thread.stop ()‘、‘Thread.suspend ()‘或‘Runtime.runFinalizersOnExit ()‘方法。 |
JTEST中对应:
保存路径: Jtest4.5\jrules\TRS_THRD.rule
目录：Rules－UserDefinedRules－TRS
级别：1
| 【建议】 禁止在循环语句的内部调用wait方法。 |
反例：
class UWIL {
void method (java.util.Vector v) {
try {
while (v.size () == 0) //违例
wait ();
}
catch (java.lang.InterruptedException e) { }
}
}
正例：
class UWIL {
void method (java.util.Vector v) {
try {
if (v.size () == 0)
wait (); //正确
}
catch (java.lang.InterruptedException e) { }
}
}
JTEST中对应:
保存路径: Jtest4.5\jrules\TRS_noWaitInDoWhile.rule
目录：Rules－UserDefinedRules－TRS
保存路径: Jtest4.5\jrules\TRS_noWaitInFor.rule
目录：Rules－UserDefinedRules－TRS
保存路径: Jtest4.5\jrules\TRS_noWaitInWhile.rule
目录：Rules－UserDefinedRules－TRS
级别：5
| 【规则9_8】 使用‘wait ()‘ 和 ‘notifyAll ()‘替代polling loops。 |
反例：
public class UWNA {
void method (Object o) {
while (true) {
while (!_ready) {
try {
sleep (300); // 违例
} catch (Exception e) {}
}
synchronized (o) {
// process data.
}
}
}
public void ready () { _ready = true; }
private boolean _ready;
}
正例：
public class UWNAFixed {
void method () {
while (true) {
synchronized (lock) {
while (!_ready) {
try {
lock.wait ();
} catch (Exception e) {}
}
// process data.
}
}
}
public void ready () {
_ready = true;
lock.notifyAll ();
}
private boolean _ready;
private Object lock;
}
JTEST中对应:
保存路径: Jtest4.5\jrules\TRS_UWNA.rule
目录：Rules－UserDefinedRules－TRS
级别：2
10 10 面向对象设计规则
| 【规则10_1】 避免在抽象类构造函数中调用抽象方法。 |
说明：抽象类构造函数中调用抽象方法将导致在对象析构之前使用其方法，导致异常发生。
反例：
abstract class NCAC {
public NCAC () {
System.out.println("Constructor: ");
test (); //违例
}
abstract public void test ();
}
正例：
abstract class NCACFixed {
public NCACFixed () {
System.out.println("Constructor: "); //正确
}
abstract public void test ();
}
JTEST中对应：
保存路径: Jtest4.5\jrules\CODSTA_NCAC. rule
目录：Rules－UserDefinedRules－CODSTA
级别：1
| 【规则10_2】 避免隐含的继承常量字段、静态方法。 |
反例：
public class AHV {
protected long a = 4;
}
public class AHV_ extends AHV {
protected int a = 5; //违例
}
正例：
public class AHV {
protected long a = 4;
}
public class AHV_ extends AHV {
protected int b = 5; //正确
}
JTEST中对应：
保存路径: 内嵌
目录 Rules－Built-in Rules－Object Oriented Programming (OOP)
保存路径: 内嵌
目录 Rules－Built-in Rules－Object Oriented Programming (OOP)
级别：2
| 【规则10_3】 处理了接口的抽象类的方法的body不能为空。 |
反例：
abstract public class IIN implements B {
public void f () {
int i = 9;
i = 10;
}
public void g () {} //违例
abstract public void h ();
}
interface B {
public void f ();
public void g ();
public void h ();
}
正例：
abstract public class IINFixed implements B {
public void f () {
int i = 9;
i = 10;
}
abstract public void g () {}; //正确
abstract public void h ();
}
interface B {
public void f ();
public void g ();
public void h ();
}
JTEST中对应：
保存路径: Jtest4.5\jrules\OOP_IIN.rule
目录：Rules－UserDefinedRules－OOP
级别：1
| 【规则10_4】 嵌套内部类不能超过两层次。 |
反例：
public class LEVEL {
class Level1 {
class Level2 {
class Level3 { //违例
private boolean _isClosed = false;
}
private int _count = 0;
}
private int _size = 0;
}
private int _length = 0;
}
正例：
public class LEVELFixed {
class Level1 {
class Level2 {
private int _count = 0;
}
private int _size = 0;
}
private int _length = 0;
}
JTEST中对应：
保存路径: Jtest4.5\jrules\OOP_LEVEL.rule
目录：Rules－UserDefinedRules－OOP
级别：1
| 【规则10_5】 避免覆盖父类的private方法，保证类的封装性。 |
反例：
class OPM extends Super {
private void method () {} //违例
}
class Super {
private void method () {}
public static void main (String[] args) {
OPM x = new OPM ();
test (x);
}
private static void test (Super x) {
x.method (); // invokes ‘Super.method ()‘, not ‘OPM.method ()‘
}
}
正例：
class OPMFixed extends Super {
private void renamedMethod () {} //正确
}
JTEST中对应：
保存路径: 内嵌
目录 Rules－Built-in Rules－Object Oriented Programming (OOP)
级别：2
| 【规则10_6】 避免通过定义实例对象来存取对象中的静态字段和方法。 |
反例：
class AUO {
static void staticMethod () {}
void method () {}
public static void main (String[] args) {
AUO object = new AUO ();
object.staticMethod (); //违例
object.method ();
}
}
正例：
class AUOFixed {
static void staticMethod () {}
void method () {}
public static void main (String[] args) {
AUO object = new AUO ();
AUO.staticMethod (); //正确
object.method ();
}
}
JTEST中对应：
保存路径: Jtest4.5\jrules\MISC_AUO.rule
目录：Rules－UserDefinedRules－MISC
级别：2
| 【规则10_7】 如果类所有的方法和属性都是静态(static)的，那么要定义缺省的构造器，并且应该是私有(private)的，提高类的封装性。 |
反例：
public class UCC {
public UCC() {} //违例
public static String getS() {
return s;
}
public static String s = "foo";
}
正例：
public class UCDCFixed {
private UCDCFixed () {} //正确
public static String s = "foo";
public static String getS() {
return s;
}
}
JTEST中对应：
保存路径: Jtest4.5\jrules\CODSTA_UCDC. rule
目录：Rules－UserDefinedRules－CODSTA
级别：1
| 【规则10_8】 所有使用了equals方法的类，必须重载equals方法 |
JTEST中对应：
待定
级别：1
| 【规则10_9】 所有在HashTable、HashMap中保存的类，必须重载equals和hashCode方法。 |
JTEST中对应：
待定
级别：1
11 11 开发EJB规则
| 【规则11_1】Bean类必须定义成public型，这是Sun公司Java组的约定。 |
JTEST中对应：
保存路径: Jtest4.5\jrules\EJB_CDP. rule
目录：Rules－UserDefinedRules－EJB
级别：1
| 【规则11_2】 EJB类不能定义成abstract、final、static型，这是Sun公司Java组的约定。 |
JTEST中对应：
保存路径: Jtest4.5\jrules\EJB_CNDA. rule
目录：Rules－UserDefinedRules－EJB
保存路径: Jtest4.5\jrules\EJB_CNDF. rule
目录：Rules－UserDefinedRules－EJB
保存路径: Jtest4.5\jrules\EJB_CNDS. rule
目录：Rules－UserDefinedRules－EJB
级别：1
| 【规则11_3】 EJB类中至少有一个ejbCreate()方法，并且是public型，不能有static或final保留字，这是Sun公司Java组的约定。 |
JTEST中对应：
保存路径: Jtest4.5\jrules\EJB_CRTE.rule
目录：Rules－UserDefinedRules－EJB
级别：1
| 【规则11_4】 在EJB相应的Bean类里面至少处理一个ejbCreate()方法。 |
JTEST中对应：
保存路径: Jtest4.5\jrules\EJB_IECM. rule
目录：Rules－UserDefinedRules－EJB
级别：1
| 【规则11_5】 在EntityBean类里面至少处理一个‘ejbPostCreate()’方法，并且有public保留字。 |
JTEST中对应：
保存路径: Jtest4.5\jrules\EJB_IEPM. rule
目录：Rules－UserDefinedRules－EJB
级别：1
| 【规则11_6】 在Bean类里面，不允许定义finalize ()方法。 |
JTEST中对应：
保存路径: Jtest4.5\jrules\EJB_MNDF. rule
目录：Rules－UserDefinedRules－EJB
级别：1
| 【规则11_7】 Finder方法必须返回主键值或主键集合值。 |
JTEST中对应：
保存路径: Jtest4.5\jrules\EJB_RT. rule
目录：Rules－UserDefinedRules－EJB
级别：1
| 【规则11_8】 会话Bean的ejbCreate()方法返回值必须是void型。 |
JTEST中对应：
保存路径: Jtest4.5\jrules\EJB_RTC. rule
目录：Rules－UserDefinedRules－EJB
级别：1
| 【规则11_9】 不允许引用this参数，不允许返回this型。 |
说明：Sun公司Java开发组的约定。
JTEST中对应：
保存路径: Jtest4.5\jrules\EJB_THISRET.rule
Jtest4.5\jrules\EJB_THISARG.rule
目录：Rules－UserDefinedRules－EJB
级别：1
| 【规则11_10】 不允许修改和编辑安全配置对象。 |
说明：Sun公司Java开发组的约定，这是出于安全方面的考虑。
JTEST中对应：
保存路径: Jtest4.5\jrules\EJB_AMSC.rule
目录：Rules－UserDefinedRules－EJB
级别：1
| 【规则11_11】 在Bean类中不允许装载本地库。 |
说明：Sun公司Java开发组的约定，这是出于安全方面的考虑。
JTEST中对应：
保存路径: Jtest4.5\jrules\EJB_LNLrule.rule
目录：Rules－UserDefinedRules－EJB
级别：1
| 【规则11_12】 避免使用线程。 |
说明：Sun公司Java开发组的约定，EJB服务器负责管理EJB的调度和部署，同时也是出于安全方面的考虑。
JTEST中对应：
保存路径: Jtest4.5\jrules\EJB_THREAD.rule
目录：Rules－UserDefinedRules－EJB
级别：1
| 【规则11_13】 避免使用java.io、java.awt包。 |
JTEST中对应：
保存路径: Jtest4.5\jrules\awt_not.rule
目录：Rules－UserDefinedRules－EJB
保存路径: Jtest4.5\jrules\io_not.rule
目录：Rules－UserDefinedRules－EJB
级别：1
12 12 其他杂项规则
| 【规则12_1】 mian(String[] str)仅仅用于程序入口点方法。 |
反例：
public class MAIN {
public static void main (String[] args) {
System.out.println ("This is the main method.");
}
public static void main () { //违例
System.out.println ("This is another method named main.");
}
}
正例：
public class MAINFixed {
public static void main (String[] args) {
System.out.println ("This is the main method.");
}
public static void other_main () { //正确
System.out.println ("This is another method, now named other_main.");
}
}
JTEST中对应：
保存路径: Jtest4.5\jrules\PB_MAIN.rule
目录：Rules－UserDefinedRules－PB
级别：1
| 【规则12_2】 在序列化类中，对于‘readResolve ()‘ 和‘writeReplace ()‘方法要有protected修饰符。 |
JTEST中对应：
保存路径: Jtest4.5\jrules\PB_MASP.rule
目录：Rules－UserDefinedRules－PB
级别：1
| 【规则12_3建议】 对序列化类要处理readObject ()、writeObject()方法。加PB-OROM2 |
反例：
class OROM implements Serializable { //违例
/**
* Max should always be positive. (for the sake of the example)
*/
public void setMax (int max) {
_max = max;
}
public int getMax () {
return _max;
}
private int _max;
private static final long serialVersionUID = 1;
}
正例：
class OROMFixed implements Serializable {
private void readObject (ObjectInputStream in) //正确
throws IOException, ClassNotFoundException {
in.defaultReadObject ();
if ( _max < 0 )
throw new IOException ("Illegal max value read: " + _max);
}
/**
* Max should always be positive. (for the sake of the example)
*/
public void setMax (int max) {
_max = max;
}
public int getMax () {
return _max;
}
private int _max;
private static final long serialVersionUID = 1;
}
JTEST中对应：
保存路径: Jtest4.5\jrules\PB_OROM.rule
目录：Rules－UserDefinedRules－PB
级别：5
| 【规则12_4】 避免使用‘System.getenv ()‘方法。 |
反例：
public class ENV {
void method (String name) {
System.getenv (name); //违例
}
}
正例：
public class ENV {
void method (String name) {
System.getProperty (name); //正确
}
}
JTEST中对应：
保存路径: Jtest4.5\jrules\PORT_ENV.rule
目录：Rules－UserDefinedRules－PORT
级别：1
| 【规则12_5】 在‘ComponentListener.componentResized ()‘避免调用’setSize ()’方法，防止死循环。 |
反例：
public class DNCSS extends Component {
public void componentResized (ComponentEvent e) {
Dimension d = getSize ();
setSize(d.width - 10, d.height - 10); //违例
}
}
正例：
public class DNCSSFixed extends Component {
public void componentResized (ComponentEvent e) {
Dimension d = getSize ();
//正确
}
}
JTEST中对应：
保存路径: Jtest4.5\jrules\PB_DNCSS.rule
目录：Rules－UserDefinedRules－PB
级别：1
| 【规则12_6】 对于Ojbect对象的比较，在equals()方法处理中使用instanceof，优化代码。 |
反例：
public class EQL2 {
public int value;
public boolean equals (Object o) {
EQL2 temp = (EQL2)o;
return temp.value =http://www.mamicode.com/= value; //违例
}
}
正例：
public class EQL2Fixed {
public int value;
public boolean equals (Object o) {
if (o instanceof EQL2Fixed) { //正确
EQL2Fixed temp = (EQL2Fixed)o;
return temp.value =http://www.mamicode.com/= value;
}
else {
return false;
}
}
}
JTEST中对应：
保存路径: Jtest4.5\jrules\PB_EQL2.rule
目录：Rules－UserDefinedRules－PB
级别：3
| 【规则12_7】 禁止使用system.out.println( )输出，需要使用PSF提供的调试打印模块。 |
JTEST中对应：
保存路径: Jtest4.5\jrules\FORMAT_PRINTLN.rule
目录：Rules－UserDefinedRules－FORMAT
级别：2
| 【规则12_8】 使用’System.arrayCopy()’替代循环拷贝数组，优化性能。 |
反例：
public class IRB {
int[] copyArray (int[] array) {
int length = array.length;
int[] copy = new int [length];
for (int i = 0; i < length; i++)
copy[i] = array[i]; //违例
return copy;
}
}
正例：
public class IRB {
int[] copyArray (int[] array) {
int length = array.length;
int[] copy = new int [length];
System.arraycopy(array, 0, copy, 0, length); //正确
return copy;
}
}
JTEST中对应：
保存路径: Jtest4.5\jrules\OPT_IRB.rule
目录：Rules－UserDefinedRules－OPT
级别：2
| 【规则12_9】 进行字符串分割操作时，使用 ‘StringTokenizer‘ 替代 ‘indexOf()‘ 或 ‘subString ()‘。 |
反例：
class UST {
static void parseString (String string) {
int index = 0;
int next_index = 0;
while ((next_index = string.indexOf (‘.‘, index)) != -1) {
System.out.println (string.substring (index, next_index));
index = next_index + 1;
}
}
}
正例：
class USTFixed {
static void parseString (String string) {
StringTokenizer tokenizer = new StringTokenizer (string, ".");
while (tokenizer.hasMoreTokens ())
System.out.println (tokenizer.nextToken ());
}
}
JTEST中对应：
保存路径: Jtest4.5\jrules\MISC_UST.rule，Jtest4.5\jrules\MISC_UST2.rule
目录：Rules－UserDefinedRules－MISC
级别：1
| 【规则12_10】 在克隆方法中避免使用本类构造函数。 |
反例：
public class CLNC implements Cloneable {
public Object clone() {
CLNC cl = new CLNC(); //违例
cl._field = _field;
return cl;
}
private int _field = 0;
}
正例：
public class CLNCFixed implements Cloneable {
public Object clone() {
CLNCFixed cl = (CLNCFixed) super.clone(); //正确
cl._field = _field;
return cl;
}
private int _field = 0;
}
JTEST中对应：
保存路径: Jtest4.5\jrules\MISC_CLNC.rule
目录：Rules－UserDefinedRules－MISC
级别：1
| 【规则12_11】 如有克隆方法就要调用父类克隆方法。 |
反例：
public class CLONE {
public Object clone() { //违例:没有调用super.clone ()
CLONE cl = new CLONE();
cl._field = _field;
return cl;
}
private int _field = 0;
}
正例：
public class CLONEFixed {
public Object clone() {
CLONEFixed cl = (CLONEFixed) super.clone(); //正确
cl._field = _field;
return cl;
}
private int _field = 0;
}
JTEST中对应：
保存路径: Jtest4.5\jrules\MISC_CLONE.rule
目录：Rules－UserDefinedRules－MISC
级别：1
| 【规则12_12】 避免给方法里的参数赋值。 |
说明：
当参数值在某个方法中用多次时，给该方法参数赋值会产生潜在的bugs
反例：
class AFP {
int method (int low, int high) {
int count = 0;
while (low++ < high) { //违例
count += low;
}
return count;
}
}
正例：
class AFPFixed {
int avg (int x) {
int count = 0;
int i = x;
while (i++ < 10) {
count += i;
}
return count % i;
}
}
JTEST中对应：
保存路径: Jtest4.5\jrules\MISC_AFP.rule
目录：Rules－UserDefinedRules－MISC
级别：1
| 【规则12_13】 返回值以零长度数组替代null。 |
反例：
class ARNFixed{
String[] getStringList () {
if (slist.size() == 0){
return null; //违例
}
return (String[])slist.toArray (new String[slist.size ()]);
}
void find () {
ARN a = new ARN ();
String[] list = a.getStringList ();
if (list != null) {
if (Arrays.asList (list).contains ("Hello")) {
System.out.println ("find");
}
}
}
private List slist;
}
正例：
class ARNFixed {
String[] getStringList () {
return (String[])slist.toArray (new String[slist.size()]); //正确
}
void find () {
ARNFixed a = new ARNFixed ();
String[] list = a.getStringList ();
if (Arrays.asList (list).contains ("Hello")) {
System.out.println ("find");
}
}
private List slist;
}
JTEST中对应：
保存路径: Jtest4.5\jrules\MISC_ARN.rule
目录：Rules－UserDefinedRules－MISC
级别：1
| 【建议】 建议避免定义静态无边界集合类型变量，因为无边界集合类型项对占用较多空间，这样可以避免浪费资源，优化代码。 |
反例：
public class STV {
public static Vector vector = new Vector (); //违例
void addToVector () {
Object o = new Object ();
vector.add (o); // 该临时对象永远不会释放
}
}
正例：
public class STVFixed {
public static void addToVector () {
// 在调用add()之前先检查Vector的容量.
if (vector.size() < MAX_SIZE) { //正确
Object o = new Object ();
vector.add(o);
}
else {
System.err.println("vector MAX_SIZE exceeded.");
}
}
public static Vector vector = new Vector (5); //正确
public static final int MAX_SIZE = 100;
}
级别：5
| 【规则12_14】 不允许创建一个未命名的独立封装类，然后再转化成字符串，避免浪费资源，优化代码。 |
反例：
public class AUTP {
String foobar (int x) {
return new Integer (x).toString (); //违例
}
}
正例：
class AUTPFixed {
String foobar (int x) {
return Integer.toString (x); // 正确
}
}
JTEST中对应：
保存路径: Jtest4.5\jrules\GC_AUTP.rule
目录：Rules－UserDefinedRules－GC
级别：2
| 【规则12_15】 处理对象流(ObjectStream)时，调用reset()方法，避免潜在的内存泄漏。 |
说明：
使用ObjectOutputStream或者ObjectInputStream的’reset()’方法来清除写入Stream的Objects队列.还有一种修补的方法:使用DataStreams替代ObjectStreams。
反例：
public class OSTM {
public void writeToStream(ObjectOutputStream os, String s) // 违例
throws IOException {
os.writeObject (s);
}
}
正例：
public class OSTMFixed {
public void writeToStream(ObjectOutputStream os, String s)
throws IOException {
os.writeObject (s);
os.reset(); // 正确
}
}
JTEST中对应：
保存路径: Jtest4.5\jrules\GC_OSTM.rule
目录：Rules－UserDefinedRules－GC
级别：1
| 【规则12_16】 如有打开的数据流，在finally语句块中关闭数据流，避免潜在的bugs。 |
反例：
public class CS {
public void method (java.io.File f) {
try {
java.io.FileInputStream fis = new java.io.FileInputStream (f);
fis.read ();
fis.close ();
} catch (java.io.FileNotFoundException e1) {
System.out.println("File not found");
} catch (java.io.IOException e2) {
System.out.println("I/O Exception");
} // 违例: 如果有异常发生‘fis‘永远不会关闭
}
}
正例：
public class CSFixed {
public void method (java.io.File f) {
try {
java.io.FileInputStream fis = new java.io.FileInputStream (f);
fis.read ();
} catch (java.io.FileNotFoundException e1) {
System.out.println("File not found");
} catch (java.io.IOException e2) {
System.out.println("I/O Exception");
}
finally {
fis.close (); // 正确
}
}
}
JTEST中对应：
保存路径: 内嵌
目录 Rules－Built-in Rules－Optimization (OPT)
级别：1
| 【规则12_17】同类方法的in，out参数，返回值，异常方式要尽量一致。 |
反例：
//当对应的taskID不存在时，抛异常。
void removeTask(String taskID) throws TimerException;
//当对应的taskID不存在时，不抛异常。
void pauseTask(String taskID) throws TimerException;
正例：
上述的两个方法在taskID不存在时，要么都抛异常，要么都不抛。
JTEST中对应：
无。
级别：5
java 编码规范