java函数里传入函数 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]);
    }