JAVAGUIDE(学习笔记1)

Javaコーディングガイドライン

1：Private,Public使用恰当。

2：原始和参照型的区别：

①原始型（byte,boolen等）实例化的时候不要分配内存空间，所以速度和内存使用上比参照型要好。

　  ②原始型的默认值是根据类型而定，而参照型的默认值是NULL。

    ③原始型保存时他的值，而惨参照型保存的是他的地址，所以下面两段程序的含义不一样

int i = 5;

int j = i;

由于保存的是值，所以I的改变不会影响到j

Integer k = new Integer(5);

Integet l = k;

保存的是地址，k的改变会影响到l

④所以在函数当参数传递的时候要特别注意。

import java.awt.Point;
  
  

class BadSample {
  
  

    void modifyValue(int value, Point point){
  
  

        value = 10;
  
  

        point.setLocation(55, 77);
  
  

    }
  
  

    void printValue(int value, Point point){
  
  

        StringBuffer buffer = new StringBuffer();
  
  

        buffer.append(value);
  
  

        buffer.append(" : ");
  
  

        buffer.append(point);
  
  

        System.out.println(buffer);
  
  

    }
  
  

    public static void main(String[] args){
  
  

        int intValue = 0;
  
  

        Point point = new Point(0, 0);
  
  

        BadSample sample = new BadSample ();
  
  

        sample.printValue(intValue, point);
  
  

        sample.modifyValue(intValue, point);
  
  

        sample.printValue(intValue, point);
  
  

    }
  
  

}
  
  

【実行結果】
  
  

0 : java.awt.Point[x=0,y=0]
  
  

0 : java.awt.Point[x=55,y=77]
  
  

    可以看出，modifyValue（）中对value的改变并没有改变main中的intValue的值。对于原始型参数的传递，可以看成是传递的是值得拷贝，对于参照型参数的传递，函数内的改变会影响到他的值。
  
  

3：尽量使用本地变量
  
  

    访问本地变量比访问类变量更节约时间。
  
  

class BadSample {
  
  

    private int result;
  
  

    void sum(int[] values) {
  
  

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

            result += values[i];    //違反
  
  

        }
  
  

    }
  
  

}
  
  

class FixedSample {
  
  

    private int result;
  
  

    void sum(int[] values) {
  
  

        int sum = result;  
  
  

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

            sum += values[i];
   
   

        }
  
  

        result = sum;
   
   

    }
   
   

}
  
  

4：用equals（）比较object的相等。

   特别注意String，我曾经犯过，很难查错。

5：不使用的变量及时负值null，避免浪费空间。

class BadSample {
  
  

    public static void main(String[] args){
  
  

        TestClass test = new TestClass();
  
  

        String firstString = “first”;
   
   

        test.method(firstString);
  
  

        ・・・
  
  

        String secondString = “second”;
  
  

        test.method(secondString);
  
  

        ・・・
  
  

        String thirdString = “third”;
  
  

        test.method(thirdString);
  
  

        ・・・　　　　　　　　　　　　　　　　　　//違反
  
  

    }
  
  

}

 

class FixedSample {
  
  

    public static void main(String[] args){
  
  

        TestClass test = new TestClass();
  
  

        String firstString = “first”;
   
   

        test.method(firstString);
  
  

        ・・・
  
  

        firstString = null;
  
  

        String secondString = “second”;
  
  

        test.method(secondString);
  
  

        ・・・
  
  

        secondString = null;
  
  

        String thirdString = “third”;
  
  

        test.method(thirdString);
  
  

        ・・・
  
  

        thirdString = null;         //修正済み
  
  

    }
  
  

}

4：常量的使用场合

class FixedSample {
  
  

    private static final int ARRAY_SIZE = 1000;
   
   

    int[] getArray() {
  
  

        return new int [ARRAY_SIZE];  //修正済み
  
  

    }
  
  

private static final String START = “start”;

 

System.out.println( START );

 

public static final String LINE_SEPARATOR =

System.getProperty(“line.separator”);

                       　　：

System.out.println( “改行” + LINE_SEPARATOR );

}
  
  

5：变量初期化的时候附初值。
  
  

6：对list做循环的时候，用Iterator，效率比较高。
  
  

    public void doXXX(List l) {
  
  

   for (Iterator i  = l.iterator(); i.hasNext();) {
   
   

        User u = (User) i.next();
   
   

}
   
   

}
  
  

7：不要在for循环中改变循环子。
  
  

public class BadSample{
  
  

     int badSampleMethod(){
  
  

         int sum = 0;
  
  

         for (int i = 0; i < 100; i++){
  
  

             i += 3;  // 違反
  
  

             sum += i;
  
  

         }
  
  

     }
  
  

 }
  
  

public class FixedSample{

     int fixedSampleMethod(){

         int sum = 0;

         // 修正済み

         for (int i = 0; i < 100; i += 4){

             sum += i;

         }

         return sum;

     }

 }
  
  

8：如果一个实例变量在程序中不会改变其值，尽量定义为final，因为final是同步的，编译效率比较高。
  
  

9：在循环中尽量不要New一个OBJ，那样会不停的分配资源。
  
  

public class BadSample {
  
  

     public void badSampleMethod(int max){
  
  

         for (int i = 0; i < max; i++) {
  
  

             StringBuffer sampleBuffer = 
   
   

                           new StringBuffer();  
  
  

// 違反
  
  

             sampleBuffer.append(“loop: “);
  
  

             sampleBuffer.append(i);
  
  

             System.out.println(
  
  

                    sampleBuffer.toString());
  
  

         }
  
  

     }
  
  

 }
  
  

public class FixedSample {
  
  

     public void fixedSampleMethod(int max){
  
  

         StringBuffer sampleBuffer = 
  
  

                             new StringBuffer();  
  
  

// 修正済み
  
  

         for (int i = 0; i < max; i++) {
  
  

             sampleBuffer.append(“loop: “);
  
  

             sampleBuffer.append(i);
  
  

             System.out.println(
  
  

                     sampleBuffer.toString());
  
  

             sampleBuffer.setLength(0);  
  
  

// 初期状態に戻す
  
  

         }
  
  

     }
  
  

 }
  
  

10：equals()和hashCode()要同时覆盖
  
  

public final class IDNumber {

    private final int id;

    public IDNumber(int id){

        this.id = id;

    }

 

    public boolean equals(Object object){

        boolean isEqual = false;

        if (object == this) {

            isEqual = true;

        } else if (object instanceof IDNumber){

            IDNumber idNum = (IDNumber)object;

            if (idNum.id == this.id) {  // idの値が等しければtrueを返す

                isEqual = true;

            }

        }

 

        return isEqual;

    }

}
  
  

  public int hashCode() {

      int result = 17;

      result = 37*result + id;  // id属性を利用しているので、同じidであれば同じ値が返る

      return result;

  }
  
  

11：调用一个class的clone方法，该class必须要实现cloneable类。覆盖clone方法的时候，一定要调super的clone方法。

12：覆盖finalize方法时，一定要调super的finalize方法。

13：数组复制用System.arraycopy()。

public class FixedSample{

     int[] copyArray(int[] array){

         int length = array.length;

         int[] copy = new int[length];

         System.arraycopy(array, 0,

                          copy, 0, length); // 修正済み

         return copy;
  
  

     }

 }

14：由于interface可以实现多重继承，而抽象类不可以，所以建议尽量使用interface。

15：定义一个默认的构造函数，这样可以用Class.newInstance()动态的生成一个对象。

16：避免if（method（）==true）；直接写if（method（））效率比较高。

17：尽量不要在方法内改变或返回参数，因为可能改变外部参数本身的值，最好在方法中new一个obj返回。

18：尽可能的重载toString方法，可以使程序的调试更方便。

19：不想被覆盖的方法写成final，这样别人就不能对其进行覆盖了。