作為程式設計師在程式開發的過程中難免的要出現一些不是自己水平問題二出現的一些常見的錯誤。本文就為大家介紹一些常見在Java開發過程中遇見的一些常見的錯誤。

一、常見錯誤1：多次拷貝字串

測試所不能發現的一個錯誤是生成不可變(immutable)物件的多份拷貝。不可變物件是不可改變的，因此不需要拷貝它。最常用的不可變物件是String。

如果你必須改變一個String物件的內容，你應該使用StringBuffer。下面的程式碼會正常工作：

1. String s = new String ("Text here"); 

但是，這段程式碼效能差，而且沒有必要這麼複雜。你還可以用以下的方式來重寫上面的程式碼：

1. String temp = "Text here";  
2. String s = new String (temp); 

但是這段程式碼包含額外的String，並非完全必要。更好的程式碼為：

1. String s = "Text here"; 

二、常見錯誤2：沒有克隆(clone)返回的物件

封裝(encapsulation)是面向物件程式設計的重要概念。不幸的是，Java為不小心打破封裝提供了方便——Java允許返回私有資料的引用(reference)。下面的程式碼揭示了這一點：

1. import java.awt.Dimension;  
2. /** *//***Example class.The x and y values should never*be negative.*/
3. publicclass Example...{  
4. private Dimension d = new Dimension (0, 0);  
5. public Example ()...{ }  
6. /** *//*** Set height and width. Both height and width must be nonnegative * or an exception is thrown.*/
7. publicsynchronizedvoid setValues (int height,int width) throws IllegalArgumentException...{  
8. if (height <
   0 || width <0)  
9. thrownew IllegalArgumentException();  
10. d.height = height;  
11. d.width = width;  
12. }  
13. publicsynchronized Dimension getValues()...{  
14. // Ooops! Breaks encapsulation
15. return d;  
16. }  
17. } 

Example類保證了它所儲存的height和width值永遠非負數，試圖使用setValues()方法來設定負值會觸發異常。不幸的是，由於getValues()返回d的引用，而不是d的拷貝，你可以編寫如下的破壞性程式碼：

1. Example ex = new Example();  
2. Dimension d = ex.getValues();  
3. d.height = -5;  
4. d.width = -10; 

現在，Example物件擁有負值了!如果getValues() 的呼叫者永遠也不設定返回的Dimension物件的width 和height值，那麼僅憑測試是不可能檢測到這類的錯誤。

不幸的是，隨著時間的推移，客戶程式碼可能會改變返回的Dimension物件的值，這個時候，追尋錯誤的根源是件枯燥且費時的事情，尤其是在多執行緒環境中。

更好的方式是讓getValues()返回拷貝：

1. publicsynchronized Dimension getValues()...{  
2. returnnew Dimension (d.x, d.y);  
3. 　} 

現在，Example物件的內部狀態就安全了。呼叫者可以根據需要改變它所得到的拷貝的狀態，但是要修改Example物件的內部狀態，必須通過setValues()才可以。

三、常見錯誤3：不必要的克隆

我們現在知道了get方法應該返回內部資料物件的拷貝，而不是引用。但是，事情沒有絕對：

1. /** *//*** Example class.The value should never * be negative.*/
2. publicclass Example...{  
3. private Integer i = new Integer (0);  
4. public Example ()...{ }  
5. /** *//*** Set x. x must be nonnegative* or an exception will be thrown*/
6. publicsynchronizedvoid setValues (int x) throws IllegalArgumentException...{  
7. if (x <0)  
8. thrownew IllegalArgumentException();  
9. i = new Integer (x);  
10. }  
11. publicsynchronized Integer getValue()...{  
12. // We can’t clone Integers so we makea copy this way.
13. returnnew Integer (i.intValue());  
14. }  
15. } 

這段程式碼是安全的，但是就象在錯誤1#那樣，又作了多餘的工作。Integer物件，就象String物件那樣，一旦被建立就是不可變的。因此，返回內部Integer物件，而不是它的拷貝，也是安全的。

方法getValue()應該被寫為：

1. publicsynchronized Integer getValue()...{  
2. // ’i’ is immutable, so it is safe to return it instead of a copy.
3. return i;  
4. } 

Java程式比C++程式包含更多的不可變物件。JDK 所提供的若干不可變類包括：

1. ·Boolean  
2. ·Byte  
3. ·Character  
4. ·Class  
5. ·Double  
6. ·Float  
7. ·Integer  
8. ·Long  
9. ·Short  
10. ·String  
11. ·大部分的Exception的子類 

四、常見錯誤4：自編程式碼來拷貝陣列

Java允許你克隆陣列，但是開發者通常會錯誤地編寫如下的程式碼，問題在於如下的迴圈用三行做的事情，如果採用Object的clone方法用一行就可以完成：

1. publicclass Example...{  
2. privateint[] copy;  
3. /** *//*** Save a copy of ’data’. ’data’ cannot be null.*/
4. publicvoid saveCopy (int[] data)...{  
5. copy = newint[data.length];  
6. for (int i = 0; i  
7. copy[i] = data[i];  
8. }  
9. } 

這段程式碼是正確的，但卻不必要地複雜。saveCopy()的一個更好的實現是：

1. void saveCopy (int[] data)...{  
2. try...{  
3. copy = (int[])data.clone();  
4. }catch (CloneNotSupportedException e)...{  
5. // Can’t get here.
6. }  
7. } 

如果你經常克隆陣列，編寫如下的一個工具方法會是個好主意：

1. staticint[] cloneArray (int[] data)...{  
2. try...{  
3. return(int[])data.clone();  
4. }catch(CloneNotSupportedException e)...{  
5. // Can’t get here.
6. }  
7. } 

這樣的話，我們的saveCopy看起來就更簡潔了：

1. void saveCopy (int[] data)...{  
2. 　copy = cloneArray ( data);  
3. 　} 

五、常見錯誤5：拷貝錯誤的資料

有時候程式設計師知道必須返回一個拷貝，但是卻不小心拷貝了錯誤的資料。由於僅僅做了部分的資料拷貝工作，下面的程式碼與程式設計師的意圖有偏差：

1. import java.awt.Dimension;  
2. /** *//*** Example class. The height and width values should never * be  
3. negative. */
4. publicclass Example...{  
5. staticfinalpublicint TOTAL_VALUES = 10;  
6. private Dimension[] d = new Dimension[TOTAL_VALUES];  
7. public Example ()...{ }  
8. /** *//*** Set height and width. Both height and width must be nonnegative * or an exception will be thrown. */
9. publicsynchronizedvoid setValues (int index, int height, int width) throws IllegalArgumentException...{  
10. if (height <0 || width <0)  
11. thrownew IllegalArgumentException();  
12. if (d[index] == null)  
13. d[index] = new Dimension();  
14. d[index].height = height;  
15. d[index].width = width;  
16. }  
17. publicsynchronized Dimension[] getValues()  
18. throws CloneNotSupportedException...{  
19. return (Dimension[])d.clone();  
20. }  
21. } 

這兒的問題在於getValues()方法僅僅克隆了陣列，而沒有克隆陣列中包含的Dimension物件，因此，雖然呼叫者無法改變內部的陣列使其元素指向不同的Dimension物件，但是呼叫者卻可以改變內部的陣列元素(也就是Dimension物件)的內容。方法getValues()的更好版本為：

1. publicsynchronized Dimension[] getValues() throws CloneNotSupportedException...{  
2. Dimension[] copy = (Dimension[])d.clone();  
3. for (int i = 0; i  
4. // NOTE: Dimension isn’t cloneable.
5. if (d != null)  
6. copy[i] = new Dimension (d[i].height, d[i].width);  
7. }  
8. return copy;  
9. } 

在克隆原子型別資料的多維陣列的時候，也會犯類似的錯誤。原子型別包括int,float等。簡單的克隆int型的一維陣列是正確的，如下所示：

1. publicvoid store (int[] data) throws CloneNotSupportedException...{  
2. this.data = (int[])data.clone();  
3. // OK
4. } 

拷貝int型的二維陣列更復雜些。Java沒有int型的二維陣列，因此一個int型的二維陣列實際上是一個這樣的一維陣列：它的型別為int[]。簡單的克隆int[][]型的陣列會犯與上面例子中getValues()方法第一版本同樣的錯誤，因此應該避免這麼做。下面的例子演示了在克隆int型二維陣列時錯誤的和正確的做法：

1. publicvoid wrongStore (int[][] data) throws CloneNotSupportedException...{  
2. this.data = (int[][])data.clone(); // Not OK!
3. }  
4. publicvoid rightStore (int[][] data)...{  
5. // OK!
6. this.data = (int[][])data.clone();  
7. for (int i = 0; i  
8. if (data != null)  
9. this.data[i] = (int[])data[i].clone();  
10. }  
11. } 

六、常見錯誤6：檢查new 操作的結果是否為null

Java程式設計新手有時候會檢查new操作的結果是否為null。可能的檢查程式碼為：

1. Integer i = new Integer (400);  
2. if (i == null)  
3. thrownew NullPointerException(); 

檢查當然沒什麼錯誤，但卻不必要，if和throw這兩行程式碼完全是浪費，他們的唯一功用是讓整個程式更臃腫，執行更慢。

C/C++程式設計師在開始寫java程式的時候常常會這麼做，這是由於檢查C中malloc()的返回結果是必要的，不這樣做就可能產生錯誤。檢查C++中new操作的結果可能是一個好的程式設計行為，這依賴於異常是否被使能(許多編譯器允許異常被禁止，在這種情況下new操作失敗就會返回null)。在java 中，new 操作不允許返回null，如果真的返回null，很可能是虛擬機器崩潰了，這時候即便檢查返回結果也無濟於事。

七、常見錯誤7：用== 替代.equals

在Java中，有兩種方式檢查兩個資料是否相等：通過使用==操作符，或者使用所有物件都實現的.equals方法。原子型別(int, flosat, char 等)不是物件，因此他們只能使用==操作符，如下所示：

1. int x = 4;  
2. int y = 5;  
3. if (x == y)  
4. 　System.out.println ("Hi");  
5. // This ’if’ test won’t compile.
6. if (x.equals (y))  
7. 　System.out.println ("Hi"); 

物件更復雜些，==操作符檢查兩個引用是否指向同一個物件，而equals方法則實現更專門的相等性檢查。

更顯得混亂的是由java.lang.Object 所提供的預設的equals方法的實現使用==來簡單的判斷被比較的兩個物件是否為同一個。

許多類覆蓋了預設的equals方法以便更有用些，比如String類，它的equals方法檢查兩個String物件是否包含同樣的字串，而Integer的equals方法檢查所包含的int值是否相等。

大部分時候，在檢查兩個物件是否相等的時候你應該使用equals方法，而對於原子型別的資料，你用該使用==操作符

Java保證讀和寫32位數或者更小的值是原子操作，也就是說可以在一步完成，因而不可能被打斷，因此這樣的讀和寫不需要同步。以下的程式碼是執行緒安全(thread safe)的：

1. publicclass Example...{  
2. privateint value; // More code here...
3. publicvoid set (int x)...{  
4. // NOTE: No synchronized keyword
5. this.value = x;  
6. }  
7. } 

不過，這個保證僅限於讀和寫，下面的程式碼不是執行緒安全的：

1. publicvoid increment ()...{  
2. // This is effectively two or three instructions:
3. // 1) Read current setting of ’value’.
4. // 2) Increment that setting.
5. // 3) Write the new setting back.
6. ++this.value;  
7. } 

在測試的時候，你可能不會捕獲到這個錯誤。首先，測試與執行緒有關的錯誤是很難的，而且很耗時間。其次，在有些機器上，這些程式碼可能會被翻譯成一條指令，因此工作正常，只有當在其它的虛擬機器上測試的時候這個錯誤才可能顯現。因此最好在開始的時候就正確地同步程式碼：

1. publicsynchronizedvoid increment ()...{  
2. 　++this.value;  
3. 　} 

九、常見錯誤9：在catch 塊中作清除工作

一段在catch塊中作清除工作的程式碼如下所示：

1. OutputStream os = null;  
2. try...{  
3. os = new OutputStream ();  
4. // Do something with os here.
5. os.close();  
6. }catch (Exception e)...{  
7. if (os != null)  
8. os.close();  
9. } 

儘管這段程式碼在幾個方面都是有問題的，但是在測試中很容易漏掉這個錯誤。下面列出了這段程式碼所存在的三個問題：

1.語句os.close()在兩處出現，多此一舉，而且會帶來維護方面的麻煩。

2.上面的程式碼僅僅處理了Exception，而沒有涉及到Error。但是當try塊執行出現了Error，流也應該被關閉。

3.close()可能會丟擲異常。

上面程式碼的一個更優版本為：

1. OutputStream os = null;  
2. try...{  
3. os = new OutputStream ();  
4. // Do something with os here.
5. }finally...{  
6. if (os != null)  
7. os.close();  
8. } 

這個版本消除了上面所提到的兩個問題：程式碼不再重複，Error也可以被正確處理了。但是沒有好的方法來處理第三個問題，也許最好的方法是把close()語句單獨放在一個try/catch塊中。

十、常見錯誤10： 增加不必要的catch 塊

一些開發者聽到try/catch塊這個名字後，就會想當然的以為所有的try塊必須要有與之匹配的catch塊。

C++程式設計師尤其是會這樣想，因為在C++中不存在finally塊的概念，而且try塊存在的唯一理由只不過是為了與catch塊相配對。

增加不必要的catch塊的程式碼就象下面的樣子，捕獲到的異常又立即被丟擲：

1. try...{  
2. // Nifty code here
3.      }catch(Exception e)...  
4.        {  
5. throw e;  
6.       }finally...{  
7. // Cleanup code here
8.       } 

不必要的catch塊被刪除後，上面的程式碼就縮短為：

1. try...{  
2. // Nifty code here
3. }finally...{  
4. // Cleanup code here
5. } 

在本文中我為大家分享了十個常見的在Java開發中常見的易發的錯誤，希望大家有了這方面的哈東東以後多多分享。