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，这样别人就不能对其进行覆盖了。
