JAVA编码规范--综合

1
  网络综合新增条款

1.1
   注释

1.1.1    
规则

规则1      
多行“/**  */”或“/*  */”注释中不同的行结尾应该添加 <BR>换行符(1.42+)

说明：<BR>换行符在 html文档中表示强制换行，在一些开发工具中（比如Eclipse），多行注释如果不用
<BR>分隔，则代码格式化工具会将所有的行拼成一行，这个规则用来保护注释在不同IDE中的可维护性及可读性，比如以下注释：

/**

 *这是一段注释的第一行

 *这是一段注释的第二行

 */

在 Eclipse工具中格式化以后会变成：

/**

 *这是一段注释的第一行这是一段注释的第二行

 */

为保证注释格式化的正确性，必须在每行结尾添加<BR>换行符。

示例：

/**

 *这是一段注释的第一行<BR>

 *这是一段注释的第二行<BR>

 */

 

1.2
   编码

1.2.1    
规则

规则1      
在构造过程中避免调用子类可以覆写的函数。(1.42+)

说明：如果在对象构造过程中调用了子类可以覆写的函数，一旦子类覆写了这函数，由于子类对象未完成初始化，子类函数中使用的数据是不正确的，导致这个函数的处理过程不是程序员预想的过程，比如以下代码输出是 0而不是 1000：

class Parent

{

    Parent()

    {

        System.out.println(overrided());

    }

   

    int overrided()

    {

        return 100;

    }

}

 

public class Childextends Parent

{

    intmyValue = 1000;

   

    int overrided()

    {

        returnmyValue;

    }

 

    publicstaticvoid main(String[] args)

    {

        new Child();

    }

 

}

规则2      覆写equals()/hashCode()/compareTo()/clone()函数时必须符合惯例。(1.42+)

说明：覆写这几个函数时，必须根据这几个函数的惯例实现，这几个函数的惯例如下：

覆写equals()函数的惯例：

1)     
当传入的参数值是 null 时，返回 false

2)     
当传入对象的类型与当前类型不兼容时(一般可以用 instanceof来判断)，返回 false

3)     
仅当对象类型兼容且数据相同时才返回 true

4)     
equals() 函数应该具有自反性，若 a.equals(b)返回 true
则b.equals(a)也要返回 true，若 a.equals(b)返回 false
则b.equals(a)也要返回 false

5)     
覆写 equals() 函数同时也要覆写 hashCode()函数，两个函数应当成对出现。

示例(摘自java.lang.Integer)：

publicboolean equals(Object obj)

{

if (objinstanceof Integer)

{

    returnvalue == ((Integer)obj).intValue();

}

 

returnfalse;

}

 

覆写hashCode()函数的惯例：

1)     
必须保证每次调用 hashCode() 函数的返回值都一样，所以不应该使用可变的成员变量来计算 hashCode()返回值.。

2)     
当两个对象之间调用 equals() 函数返回 true时，对这两个对象调用 hashCode()
函数必须得到相同的结果。

3)     
覆写 hashCode() 函数同时也要覆写 equals()函数，两个函数应当成对出现。

示例(摘自java.lang.Integer)：

publicint hashCode()

{

returnvalue;

}

 

覆写compareTo()函数的惯例：

compareTo()函数是实现 Comparable接口时必须覆写的函数，根据这个函数的声明，实现这个函数有以下几个要求：

1)     
当传入对象的类型与当前类型不兼容时应抛出ClassCastException(可以直接用强制类型转换完成)，不要返回任何数值。

2)     
假设传入的对象是 that，则当 this > that、this == that、this < that时分别要返回正数、0、负数

示例：

class MyComparableimplements Comparable

{

    privateintvalue;

 

    /**

     *比较大小<BR>

     * 当this>that、this==that、this<
that 时分别要返回正数、0、负数

     *

     *@paramthatObject被比较的对象

     *@exceptionClassCastException对象的类型与当前类型不兼容时抛出

     *

     *@returnint

     */

    publicint compareTo(Object that)throws
ClassCastException

    {

        if (this == that)

        {

            return 0;

        }

 

        MyComparable thatData = (MyComparable)that;

 

        returnthis.value - thatData.value;

    }   

}

 

覆写clone()函数的惯例：

1)     
要覆写clone()函数，则类必须实现 Cloneable接口。

2)     
必须通过调用 super.clone() 取得对象拷贝，不要通过new运算符重新构造对象拷贝。由于 Object.clone()函数实现了高效的浅拷贝功能，重新构造会白白造成性能浪费。

3)     
对于引用类型的成员变量，需要通过重新构造、克隆、数据拷贝等方式完成深度克隆。

示例(摘自java.util.ArrayList)：

4）不允许在clone方法中返回null

public Object clone()

{

try

{

ArrayList v = (ArrayList)super.clone();

v.elementData =new Object[size];

System.arraycopy(elementData, 0, v.elementData, 0,size);

v.modCount = 0;

return v;

}

catch (CloneNotSupportedException e)

{

// this shouldn't happen, since we are Cloneable

thrownew InternalError();

}

}

 

 

规则3      一个文件的总行数不能超过 2000 行 (1.42+)

说明：根据Sun公司调查得出的数据表明，文件的总行数一旦超过 2000行，文件的可维护性急速下降，并且很可能文件的职责不单一、内聚性差。需要注意的是，这里说的是文件行，不是代码行。

规则4      不要声明public类型的成员变量
(1.42+)

说明：在Java语言中，对象应该具备良好的封装性，但声明public类型的成员变量会破坏这种封装性，请使用 getter/setter函数来访问这些变量。

 

1.2.2    
建议

建议1     
一个函数的总行数不要超过 60行。(1.42+)

说明：为了使函数的具有高可读性，一个函数最好全部显示在一屏之内（一般的显示器显示一屏是在60行以内）。如果一个函数太大，说明这个函数很可能职责不单一，这会增加函数的维护难度。

 

1.3
   性能与可靠性

1.3.1    
规则

规则1      
使用 equals()函数来比较 String
是否相等。(1.42+)

说明：在 Java语言中，对 String
类型使用 ==运算符时比较的是两个对象的引用（即指针地址）是否相等，不是对内容进行比较。必须使用 equals()函数来判断两个字符串内容是否相同，以保证比较的可靠性。

示例（错误）：

void func(String str1, String str2)

{

    if (str1 == str2)

    {

        // ...

    }

}

 

示例（正确）：

void func(String str1, String str2)

{

    if (str1.equals(str2))

    {

        // ...

    }

}

规则2      不要使用双重检查完成延迟初始化(Lazy Initialization)。(1.42+)

说明：依赖双重检查进行的延迟初始化(Lazy Initialization)在多线程环境中并不安全，在《Effective Java》一书中作者做了详细的论述，这个观点是业界公认的，所以应该避免使用双重检查完成延迟初始化。根据《Effective
Java》一书的建议，可以通过定义内部类来完成延迟初始化。

示例（错误，不安全）：

public class Foo

{

    private static Foo instance = null;

 

    private Foo(){}

   

    public static Foo getInstance()

    {

        if (instance == null)

        {

            synchronized (Foo.class)

            {

                if (instance == null)

                {

                    instance = new Foo();

                }

            }

        }

        return instance;

    }

}

示例（正确，安全）：

public class Foo

{

    private static class InstanceHolder

    {

        private static Fooinstance = new Foo();

    }

 

    private Foo(){}

 

    public static Foo getInstance()

    {

        return InstanceHolder.instance;

    }

}

 

规则3      禁止使用异常控制程序流程。(1.42+)

说明：使用异常控制程序流程是一种不好的习惯，严重降低代码的可读性和可维护性，同时也严重降低性能。

示例（错误）：

public void bar(int numbers[])

{

    int i = 0;

 

    try

    {

        while (true)

        {

            logger.info("number =" + numbers[i++]);

        }

    }

    catch (ArrayIndexOutOfBoundsException e)

    {

        // do nothing

    }

}

示例（正确）：

public void bar(int numbers[])

{

    for (int i = 0; i < numbers.length; i++)

    {

        logger.info("number =" + numbers[i]);

    }

}