JAVA规则 基本篇:

JAVA规则 基本篇:

(1) 避免使用NEW关键字来创建String对象。    

把一个String常量copy到String 对象中通常是多余、浪费时间的      

Public class test{
         Public void method(){
             System.out.print (str);
     }
private String str = new String ("1"); //这里新建对象是完全没有必的.
private String str2=”2”  //正确的应该如此 }

(2) 避免使用不必要的嵌套。

过多的嵌套会使你的代码复杂化，减弱可性。   Public class test {
   String add (){
Int c=(a=a+b)+b;  //过于复杂 Return c
    }
}


(3) 避免在同一行声明不同类型的多个变量这样可以使程序更加清晰.
    private int index, index1[];
    正确的应该如此：      private int index;  
     private int index1[];

(4) 在每一行里写一条语句     这条规则不包括for语句：

比如：'for (int i = 0; i < 10; i++) x--;’可以增加代码的可读性。   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;  
    }
}

 

 

（5）经常从finalize ()中调用super.finalize ()
这里的finalize ()是java在进行垃圾收集的时候调用的，和finally不一样。如果你的父类没有定义finally（）的话，你也应该调用。

里有两个原因：

改变代码的情况下能够将父类的finally方法加到你的类中。

以后你会养成习惯调用父类的finally方法， 即使父类没有定义finally方法的时候

正确的方法应该如此：   public class parentFinalize {
    protected void finalize () throws Throwable {
        super.finalize();  // FIXED   
    }

（6）不要在finalize ()中注销listeners

不要再finalize ()方法中中注销listeners，finalize ()只有再没有对象引用的时候调用，如果listeners从finalize()方法中去除了，被finalize的对象将不会在垃圾收集中去除。         public void finalize () throws Throwable {
        bButton.removeActionListener (act);  
    }

(7) 不要显式的调用finalize ()方法    虽然显式的调用这个方法可以使你确保你的调用，但是当这个方法收集了以后垃圾收集会再收集一次。

public class T7 {

public void finalize() throws Throwable {

close_resources ();

super.finalize ();

}

public void close_resources() {}

}

 

class Test {

void cleanup () throws Throwable {

t71.finalize();  // 调用

t71 = null;

}

private t71 = new T7 ();

}

对于这样的调用我们应该自己创建一个释放的方法，做最初finalize ()所作的事情，当你每次想显式的调用finalize ()的时候实际上调用了释放方法。然后再使用一个判断字段来确保这个方法只执行一次，以后再调用就没关系了。

public class T7 {

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 {

t71 .release ();  // FIXED

t71  = null;

}

private T7 t71  = new T7 ();

}

 

(8)不要使用不推荐的API
  尽量使用JDK1.3推荐的API。在类和方法或者java组件里有很多方法是陈旧的或者是可以选择的。有一些方法SUN用了"deprecated“标记。最好不要使用例如：    private List t_list = new List ();
   t_list.addItem (str);  
  如果查一下javadoc的话，会发现建议用add()来代替addItem()。

（9）为所有序列化的类创建一个'serialVersionUID'
  可以避免从你各种不同的类破坏序列的兼容性。如果你不特别制订一个UID的话，那么系统为自动产生一个UID（根据类的内容）。如果UID在你新版本的类中改变了，即使那个被序列化的类没改变，你也不能反序列化老的版本了。

public class DUID implements java.io.Serializable {

public void method () {}

}

在里面加一个UID，当这个类的序列化形式改变的时候，你也改变这个UID就可以了。

public class DUIDFixed implements java.io.Serializable {

public void method () {}

private static final long serialVersionUID = 1;

}

(10) 对于private常量的定义 比较好的做法是对于这样的常量，加上final标记，这样的常量从初始化到最后结束值都不会改变。 private int size = 5;  
改变后的做法是：   private final int size = 5;  

(11)避免把方法本地变量和参数定义成和类变量相同的名字。    这样容易引起混扰，建议把任何的变量字都定义成唯一的。这样看来，SCJP里的那些题目在现实中就用不到了：）

public void method (int j) {

final int i = 5;  // VIOLATION

}

private int j = 2;

   
建议：

public void method (int j1) {

final int i = 5;  // VIOLATION

}

private int j = 2;

JAVA规则 中级篇

（1）    在finally方法里关掉input或者output 资源 再方法体里面定义了input或者output流的话，需要在finally里面把它关掉。 以下这几种调用不需要遵守这条规则，因为colse()方法不起作用：） java.io.StringWriter     java.io.ByteArrayOutputStream    java.io.ByteArrayInputStream
如 果再方法返回的时候没有调用close()方法来释放input()和output()的资源的话，会导致一个系统资源泄漏。而且在任何情况下都要确定在 返回全调用了close() 方法，包括出现异常的时候。所以需要在finally方法里面加入这个方法。这样就保证了在任何情况下都会关闭资源。  错误示例： public class CIO {
    public void method (java.io.File f) {
    java.io.FileInputStream fis = null;
        try {
            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");
        }
        // 如果出现异常，这里就不能保证关闭资源。     }
}
修正后的代码： public class CIOFixed {
    public void method (java.io.File f) {
    java.io.FileInputStream fis = null;
        try {
            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 {
        if (fis != null) {
        try {
fis.close ();  
                       } catch (java.io.IOException e) { 
            System.out.println("I/O Exception");
                }
            }
        }
    }
}

 

（2）   不要把方法定义成main().
在java里，main()方法是一个特别的方法。所以在自己定义方法的时候不要定义这样的名字，以免引起混扰。

(3)     不要直接或者间接的定义'Error'和'Throwable'的子类 'java.lang.Error'只在JVM出现反常的时候覆盖这个方法，如果你定义了直接或者不直接的类继承了类'Error'，也就指出了这个错误是JVM内部的，而不是这个类的。所以对于java编译器来说是不可见的，这样就不能检查错误的异常处理了。   'java.lang.Throwable'是'java.lang.Exception'和'java.lang.Error'的上级类，用户如果象定义异常类的话应该继承'java.lang.Exception'。 错误示例：public class ABC extends Error
正确：public class ABC extends Exception

（4）建议不要使用'System.getenv ()'
不建议使用'System.getenv ()'，这个方法看起来很好用，不过并不是所有的系统都有环境变量的。不用这个方法也可能带来一些不方便。  错误示例：    void method (String name) {
        System.getenv (name);  // 可以用其他方法来代替     }
如果不用这个方法，我们可以用其它的方法来代替。比如：'System.getProperty ()’，'getTypeName ()'等，这也可以找到java的系统属性。

（5）不要使用’n’或者'r'来分行  这两个标记看来很普遍，特别是’n’。我们经常用来作为分行用。但是不同的系统用不同的分行字符，所以这些字符在某些意义上违背了java的平台无关性。  错误示例： System.out.println("Hello/n" + name);  
我们可以用其它的一些方法来代替，比如println()，这个方法在不同的系统平台上都起到相同的作用。后者推荐大家用这个方法：System.getProperty("line.separator")

(6) 使所有的内部类"private".
Java允许一个类包含另外一个类，带是Java byte code没有这个概念。类被编译器解释成package-private类。从更深的程度来说，包含类的任何内部私有对象能被内部类访问的也能被同一个包内的其他类访问。 错误示例： public class INNER {
    class INNER_Class {  
        void setValue(int i) {
            _value = i;  // 现在包就可以访问了         }
    }
    private int _value;
}
所以需要加上private class INNER_Class

（7）不要使接口序列化  如果一个字节数组包含了一个被序列化的对象。攻击者就能读到这个对象的内部状态合字段（包括private的）。 错误示例： public interface sample extends java.io.Serializable