Java編程開發(fā)規(guī)范及其技巧？
在用Java進行開發(fā)前，一定要牢牢遵守Java的開發(fā)規(guī)范，只有這樣你的Java開發(fā)之路才能更加順暢。而掌握相應(yīng)的Java開發(fā)技巧，凳塌局則可以讓你工作起來事半功倍。那在編寫代碼時有什么開發(fā)規(guī)范和技巧呢？電腦培訓給你詳細介紹一下吧。
1、代碼編寫規(guī)范：
代碼編寫遵守Java通用開發(fā)規(guī)范和必聯(lián)代碼開發(fā)規(guī)范；
每個類及方法都要有合理的注釋，并且對注釋要持續(xù)維護；
根據(jù)接口需求編寫單元測試用例，再編寫實現(xiàn)類使得單元測試通過，如此循環(huán)往復以使得所有的單元測試通過；
要求每個Java方法的代碼行數(shù)不能超過100行；
代碼編寫按照功能劃分，一個接口分為多個方法，每一個方法做什么事情，做到思路清晰；
接口設(shè)計盡量做到多兼容性，方便后期開發(fā)。
2、數(shù)據(jù)庫設(shè)計及SQL規(guī)范
不使用MySQL數(shù)據(jù)庫外鍵約束，通過應(yīng)用程序棗讓邏輯實現(xiàn)關(guān)聯(lián)約束；
適當建立索引，經(jīng)常作為查詢條件的字段、*性程度高、長度不是很長的、數(shù)量不宜太多，一般一個表的索引數(shù)目在5個以內(nèi)；
表名長度不能超過30個字符，表名*選擇一個單詞，能夠準確清晰明了地表衫源示實體含義，若必須多個單詞則以下劃線“_”分隔，單詞所有字母均小寫；
北大青鳥java培訓：如何規(guī)范自己的代碼編輯方式？
對于程序員來說，養(yǎng)成良好的代碼寫作能力是非常重要的。
今天，我們就一起來了解一下，規(guī)范化的代碼編寫都有哪些要求。
希望通過對本文的閱讀，能夠提高大家對于代碼規(guī)范的認識。
1.保證代碼壓縮后不出錯對于大型的JSP項目，一般會在產(chǎn)品發(fā)布時對項目包含的所有JSP文件進行壓縮處理，比如可以利用對代碼進行壓縮，新版jQuery已改用這一工具對代碼進行壓縮，這一般會去掉開發(fā)時寫的注釋，除去所有空格和換行，甚至可以把原來較長的變量名替換成短且無意義的變量名，這樣做的目的是加快文件的下載速度，同時也減小網(wǎng)站訪問帶來的額外數(shù)據(jù)流量，另外在代碼保護上也起到了一點點作用，至少壓縮后的代碼即使被還原還是沒那么容易一下讀懂的。
要想代碼能正確通過壓縮，一般要求語句都要以分號正常旦饑結(jié)束，大括號也要嚴格結(jié)束等，具體還要看壓縮工具的要求。
所以如果一開始沒有按標準來做，等壓縮出錯后再回去找錯誤那是浪費時間。
2.保證代碼能通過特定IDE的自動格式化功能一般較為完善的開發(fā)工具(比如)都有代碼"自動格式"化功能，這一功能幫助實現(xiàn)統(tǒng)一換行、縮進、空格等代碼編排，你可以設(shè)置自己喜歡的格式標準，比如左大括號{是否另起一行模核返。
達到這個要求的目的在于方便你的開發(fā)團隊成員拿你代碼的一個副本用IDE自動格式化成他喜歡或熟悉的風格進行閱讀。
你同事需要閱讀你的代碼，可能是因為你寫的是通用方法，他在其它模塊開發(fā)過程中也要使用到，閱讀你的代碼能深入了解方法調(diào)用和實現(xiàn)的細節(jié)，這是簡單API文檔不能達到的效果。
3.使用標準的文檔注釋這一要求算是基本的，這有利于在方法調(diào)用處看到方法的具體傳參提示，也可以利用配套文檔工具生成html或其它格式的開發(fā)文檔供其他團隊成員閱讀，你可以嘗試使用jsdoc-toolkit。
如果你自動生成的API是出自一個開放平臺，就像facebook.com應(yīng)用，那么你的文檔是給天下所有開發(fā)者看的。
另外編寫完整注釋，也更方便團隊成員閱讀你的代碼，通過你的參數(shù)描述，團隊成員可以很容易知道你編寫的方法傳參與實現(xiàn)細節(jié)。
當然也方便日后代碼維護，這樣即使再大的項目，過了很長時間后，回去改點東西也就不至于自己都忘記了當時自己寫的代碼是怎么一回事了。
4.使用規(guī)范有意義的變量名使用規(guī)范有意義的變量名可以提高代碼的可讀性，作為大項目開發(fā)成員，自己寫的代碼不僅僅要讓別人容易看懂。
電腦培訓 的語法與 C++ 及為相似，那么，你知道 Java 的注釋有幾種嗎？是兩種？
// 注釋一行
/* ...... */ 注釋若干行
不完全對，除了以上兩種之外，還有第三種，文檔注釋：
/** ...... */ 注釋若干行，并寫入 javadoc 文檔
注釋要簡單明了。
String userName = null; //用戶名
邊寫代碼邊注釋，修改代碼同時修改相應(yīng)的注釋，以保證注釋與代碼的一致性。
在必要的地方注釋，注釋量要適中。注釋的內(nèi)容要清楚、明了，含義準確，防止注釋二義性。
保持注釋與其描述的代碼相鄰，即注釋的就近原則。
對代碼的注釋應(yīng)放在其上方相鄰位置，不可放在下面。對數(shù)據(jù)結(jié)構(gòu)的注釋應(yīng)放在其上方相鄰位置，不可放在下面；對結(jié)構(gòu)中的每個域的注搭櫻釋應(yīng)放在此域的右方；
同一結(jié)構(gòu)中不同域的注釋要對齊。
變量、常量的注釋應(yīng)放在其上方相鄰位置或右方。
全局變量要有較詳細的注釋，包括對其功能、取值范圍、哪些函數(shù)或過程存取它以及存取時注意事項等的說明。
在每個源文件的頭部要有必要的注釋信息，包括：文件名；版本號；作者；生成日期；模塊功能描述（如功能、主要算法、內(nèi)部各部分之間的關(guān)系、該文件與其它文件關(guān)系等）；主要函數(shù)或過程清單及本文件歷史修改記錄等。
/**
* Copy Right : Neusoft IIT
* Project : eTrain
* JDK version used : jdk1.3.1
* Comments : config path
* Version : 1.01
* history :2003.5.1
* Sr Date Modified By Why & What is modified
* 1. 2003.5.2 Kevin Gao new
**/
在每個函數(shù)或過程的前面要有必要的注釋信息，包括：函知伍叢數(shù)或過程名稱；功能描述；輸入、輸出及返回值說明；調(diào)用關(guān)系及被調(diào)用關(guān)系說明等
/**
* :checkout 提款
* @param Hashtable cart info
* @param OrderBean order info
* @return String
*/
public String checkout(Hashtable htCart,
OrderBean orderBean)
throws Exception{
}
javadoc注釋標簽語法
@author 對類的說明 標明開發(fā)該類模塊的作者
@version 對類的說明 標明該類模塊的版本
@see 對類、屬性、方法的說明 參考轉(zhuǎn)向，也就是相關(guān)主題
@param 對方法的說明 對方法中某參數(shù)的說明
@return 對方法的說明 對方法返回值的說明
@exception 對方法的說明 對方法可能拋出的異常進行說明
3、命名規(guī)范
定義這個規(guī)范的目的是讓項目中所有的文檔都看起來像一個人寫的，增加可讀性，減少項目組中因為換人而帶來的損失。（這些規(guī)范并不是一定要絕對遵守，但是一定要讓程序有良好的可讀性）較短的單詞可通過去掉元音形成縮寫；要不然*自己寫的代碼自己都看不懂了，那可不行。
較長的單詞可取單詞的頭幾發(fā)符的優(yōu)先級，并用括號明確表達式的操作順序，避免使用默認優(yōu)先級。
使用匈牙利表橘芹示法
Package 的命名
Package 的名字應(yīng)該都是由一個小寫單詞組成。
package com.neu.util
Class 的命名
Class 的名字必須由大寫字母開頭而其他字母都小寫的單詞組成,對于所有標識符，其中包含的所有單詞都應(yīng)緊靠在一起，而且大寫中間單詞的首字母。
public class {}
Class 變量的命名
變量的名字必須用一個小寫字母開頭。后面的單詞用大寫字母開頭
userName ,
Static Final 變量的命名
static Final 變量的名字應(yīng)該都大寫，并且指出完整含義。
/**
*DBConfig PATH
**/
public static final String
DB_CONFIG_FILE_PATH =com.neu.etrain.dbconfig;
參數(shù)的命名
參數(shù)的名字必須和變量的命名規(guī)范一致。
數(shù)組的命名
數(shù)組應(yīng)該總是用下面的方式來命名：
byte[] buffer;
而不是：
byte buffer[];
方法的參數(shù)
使用有意義的參數(shù)命名，如果可能的話，使用和要賦值的字段一樣的名字：
(int size){
this.size = size;
}
4、文件樣式
所有的 Java(*.java) 文件都必須遵守如下的樣式規(guī)則：
版權(quán)信息
版權(quán)信息必須在 java 文件的開頭，比如：
/*
* Copyright ? 2000 Shanghai XXX Co. Ltd.
* All right reserved.
*/
其他不需要出現(xiàn)在 javadoc 的信息也可以包含在這里。
Package/Imports
package 行要在 import 行之前，import 中標準的包名要在本地的包名之前，而且按照字母
順序排列。如果 import 行中包含了同一個包中的不同子目錄，則應(yīng)該用 * 來處理。
package hotlava.net.stats;
import java io.*;
import java.util.;
import hotlava.util.;
這里 java。io.* 使用來代替 and 的。
Class
接下來的是類的注釋，一般是用來解釋類的。
/**
* A class a set of packet and byte counters
* It is to allow it to be watched, but only
* reports changes when the current set is complete
*/
接下來是類定義，包含了在不同的行的 extends 和
public class
extends
Cloneable
Class Fields
接下來是類的成員變量：
/**
* Packet counters
*/
protected int[] packets;
public 的成員變量必須生成文檔（JavaDoc）。proceted、private和 package 定義的成
員變量如果名字含義明確的話，可以沒有注釋。
存取方法
接下來是類變量的存取的方法。它只是簡單的用來將類的變量賦值獲取值的話，可以簡單的
寫在一行上。
/**
* Get the counters
* @return an array the data. This array has been
* freshly allocated and can be modified by the caller.
*/
public int[] () { return copyArray(packets, offset); }
public int[] getBytes() { return copyArray(bytes, offset); }
public int[] () { return packets; }
public void (int[] packets) { this.packets = packets; }
其它的方法不要寫在一行上
構(gòu)造函數(shù)
接下來是構(gòu)造函數(shù)，它應(yīng)該用遞增的方式寫（比如：參數(shù)多的寫在后面）。
訪問類型 (public, private 等.) 和 任何 static, final 或 應(yīng)該在一行
中，并且方法和參數(shù)另寫一行，這樣可以使方法和參數(shù)更易讀。
public
(int size){
this.size = size;
}
克隆方法
如果這個類是可以被克隆的，那么下一步就是 clone 方法：
public
Object clone() {
try {
obj = ()super.clone();
obj.packets = (int[])packets.clone();
obj.size = size;
return obj;
}catch( e) {
throw new ( : +
e.());
}
}
類方法
下面開始寫類的方法：
/**
* Set the packet counters
* (such as when restoring from a database)
*/
protected final
void setArray(int[] r1, int[] r2, int[] r3, int[] r4)
throws
{
//
// Ensure the arrays are of equal size
//
if (r1.length != r2.length || r1.length != r3.length || r1.length != r4.length)
throw new (Arrays must be of the same size);
System.arraycopy(r1, 0, r3, 0, r1.length);
System.arraycopy(r2, 0, r4, 0, r1.length);
}
toString 方法
無論如何，每一個類都應(yīng)該定義 toString 方法：
public
String toString() {
String retval = : ;
for (int i = 0; i < data.length(); i++) {
retval += data.bytes.toString();
retval += data.packets.toString();
}
return retval;
}
}
main 方法
如果main(String[]) 方法已經(jīng)定義了, 那么它應(yīng)該寫在類的底部.
5、代碼可讀性
避免使用不易理解的數(shù)字，用有意義的標識來替代。
不要使用難懂的技巧性很高的語句。
源程序中關(guān)系較為緊密的代碼應(yīng)盡可能相鄰。
6、代碼性能
在寫代碼的時候，從頭至尾都應(yīng)該考慮性能問題。這不是說時間都應(yīng)該浪費在優(yōu)化代碼上，而是我們時刻應(yīng)該提醒自己要注意代碼的效率。比如：如果沒有時間來實現(xiàn)一個高效的算法，那么我們應(yīng)該在文檔中記錄下來，以便在以后有空的時候再來實現(xiàn)她。
不是所有的人都同意在寫代碼的時候應(yīng)該優(yōu)化性能這個觀點的，他們認為性能優(yōu)化的問題應(yīng)該在項目的后期再去考慮，也就是在程序的輪廓已經(jīng)實現(xiàn)了以后。
不必要的對象構(gòu)造
不要在循環(huán)中構(gòu)造和釋放對象
使用 對象
在處理 String 的時候要盡量使用 類， 類是構(gòu)成 String 類的基礎(chǔ)。
String 類將 類封裝了起來，（以花費更多時間為代價）為開發(fā)人員提供了一個安全的接口。當我們在構(gòu)造字符串的時候，我們應(yīng)該用 來實現(xiàn)大部分的工作，當工作完成后將 對象再轉(zhuǎn)換為需要的 String 對象。比如：如果有一個字符串必須不斷地在其后添加許多字符來完成構(gòu)造，那么我們應(yīng)該使用 對象和她的 append() 方法。如果我們用 String 對象代替 對象的話，會花費許多不必要的創(chuàng)建和釋放對象的 CPU 時間。大家可以來安安DIY創(chuàng)作室一起討論。
避免太多的使用 關(guān)鍵字避免不必要的使用關(guān)鍵字 ，應(yīng)該在必要的時候再使用她，這是一個避免死鎖的好方法。
7、編程技巧
byte 數(shù)組轉(zhuǎn)換到
為了將 byte 數(shù)組轉(zhuǎn)換到 ，你可以這么做：
Hello world!.getBytes();
Utility 類
Utility 類（僅僅提供方法的類）應(yīng)該被申明為抽象的來防止被繼承或被初始化。
初始化
下面的代碼是一種很好的初始化數(shù)組的方法：
= new Object[] { arguments };
枚舉類型
JAVA 對枚舉的支持不好，但是下面的代碼是一種很有用的模板：
class Colour {
public static final Colour BLACK = new Colour(0, 0, 0);
public static final Colour RED = new Colour(0xFF, 0, 0);
public static final Colour GREEN = new Colour(0, 0xFF, 0);
public static final Colour BLUE = new Colour(0, 0, 0xFF);
public static final Colour WHITE = new Colour(0xFF, 0xFF, 0xFF);
}
這種技術(shù)實現(xiàn)了RED, GREEN, BLUE 等可以象其他語言的枚舉類型一樣使用的常量。
他們可以用 '==' 操作符來比較。
但是這樣使用有一個缺陷：如果一個用戶用這樣的方法來創(chuàng)建顏色 BLACK new Colour(0,0,0)
那么這就是另外一個對象，'=='操作符就會產(chǎn)生錯誤。她的 equal() 方法仍然有效。由于這個原因，這個技術(shù)的缺陷*注明在文檔中，或者只在自己的包中使用。
8、編寫格式
代碼樣式
代碼應(yīng)該用 unix 的格式，而不是 windows 的（比如：回車變成回車+換行）
文檔化
必須用 javadoc 來為類生成文檔。不僅因為它是標準，這也是被各種 java 編譯器都認可的方法。使用 @author 標記是不被推薦的，因為代碼不應(yīng)該是被個人擁有的。
縮進
縮進應(yīng)該是每行2個空格. 不要在源文件中保存Tab字符. 在使用不同的源代碼管理工具時Tab字符將因為用戶設(shè)置的不同而擴展為不同的寬度.如果你使用 UltrEdit 作為你的 Java 源代碼編輯器的話，你可以通過如下操作來禁止保存Tab字符, 方法是通過 UltrEdit中先設(shè)定 Tab 使用的長度室2個空格，然后用 Format|Tabs to Spaces 菜單將 Tab 轉(zhuǎn)換為空格。
頁寬
頁寬應(yīng)該設(shè)置為80字符. 源代碼一般不會超過這個寬度, 并導致無法完整顯示, 但這一設(shè)置也可以靈活調(diào)整. 在任何情況下, 超長的語句應(yīng)該在一個逗號或者一個操作符后折行. 一條語句折行后, 應(yīng)該比原來的語句再縮進2個字符.
{} 對
{} 中的語句應(yīng)該單獨作為一行. 例如, 下面的第1行是錯誤的, 第2行是正確的:
if (i>0) { i ++ }; // 錯誤, { 和 } 在同一行
if (i>0) {
i ++
}; // 正確, { 單獨作為一行
} 語句永遠單獨作為一行.如果 } 語句應(yīng)該縮進到與其相對應(yīng)的 { 那一行相對齊的位置。
括號
左括號和后一個字符之間不應(yīng)該出現(xiàn)空格, 同樣, 右括號和前一個字符之間也不應(yīng)該出現(xiàn)空格. 下面的例子說明括號和空格的錯誤及正確使用:
CallProc( ); // 錯誤
CallProc(); // 正確
不要在語句中使用無意義的括號. 括號只應(yīng)該為達到某種目的而出現(xiàn)在源代碼中。下面的例子說明錯誤和正確的用法:
if ((I) = 42) { // 錯誤 - 括號毫無意義
if (I == 42) or (J == 42) then // 正確 - 的確需要括號
9、代碼編譯
1.編寫代碼時要注意隨時保存，并定期備份，防止由于斷電、硬盤損壞等原因造成代碼丟失。
2.同一項目組內(nèi)，*使用相同的編輯器，并使用相同的設(shè)置選項。
3.合理地設(shè)計軟件系統(tǒng)目錄，方便開發(fā)人員使用。
4.打開編譯器的所有告警開關(guān)對程序進行編譯。
5.在同一項目組或產(chǎn)品組中，要統(tǒng)一編譯開關(guān)選項。
6.使用工具軟件（如Visual ）對代碼版本進行維護。如果大家有不明白的可以到安安DIY創(chuàng)作室留言。
10、可移植性
Borland Jbulider 不喜歡 這個關(guān)鍵字，如果你的斷點設(shè)在這些關(guān)鍵字的作用域內(nèi)的話，調(diào)試的時候你會發(fā)現(xiàn)的斷點會到處亂跳，讓你不知所措。除非必須，盡量不要使用。
換行
如果需要換行的話，盡量用 println 來代替在字符串中使用n。
你不要這樣：
System.out.print(Hello,world!n);
要這樣：
System.out.println(Hello,world!);
或者你構(gòu)造一個帶換行符的字符串，至少要象這樣：
String newline = System.(line.separator);
System.out.println(Hello world + newline);
已經(jīng)被不贊成（）使用，用 來代替它。
為什么要遵守Java代碼規(guī)范？
在進行Java代碼敲寫的時候，我們知道是有很多裂早的Java代碼規(guī)范是需要遵守的，但是有的Java學員就老是忘記，還有的Java學員是不屑遵守的，內(nèi)心想著是只要我的Java代碼OK，遵不遵守Java代碼規(guī)范，有什么問題呢?其實是存在問題的，為什么要遵守Java代碼規(guī)范?
為什么要遵守Java代碼規(guī)范?當你*次接觸到Java代碼規(guī)范的時候，你是不是覺得很麻煩呢?比如關(guān)于統(tǒng)一的原則，一再的強調(diào)，但是你一再的忘記，或者壓根就不想照做，會出現(xiàn)什么樣的后果呢?今天回龍觀java培訓將借Java代碼規(guī)范中的統(tǒng)一來說說，自己對為什么要遵守Java代碼規(guī)范，發(fā)表自己簡單的看法。
Java代碼規(guī)范中的統(tǒng)一是指，對于同一個概念，在程序中用同一種表示方法，比如對于供應(yīng)商，既可以用supplier，也可以用provider，但是我們只能選定一個使用，至少在一個Java項目中保持統(tǒng)一。統(tǒng)一是作為重要的，如果對同一概念有不同的表示方法，會使代碼混亂難以理解。即使不能取得好的名稱，但是只要統(tǒng)一，閱讀起來也不會太困難，因為閱讀者只要理解一次。
而如果你在一個項目中不遵守已經(jīng)制定好的統(tǒng)一規(guī)范，那么不僅是給自己帶來麻煩，也是給其他工作人員帶來不便，在要進行整理陪搭的時候，你的不同，會帶來不必要的交流麻煩。作為一個Java程序員，你一般是屬于團隊中的一員，你不遵蘆源拿守制定好的Java代碼規(guī)范，其他人也不遵守那么你們的團隊就得亂套了，所以面對Java代碼規(guī)范的學習，不要覺得無趣，還是得用心記住，并且予以遵守。
java編程規(guī)范！?。?/h3>名稱 Java語言編碼規(guī)范(Java Code )
簡介 本文檔講述了Java語言的編碼規(guī)范，較之陳世忠先生《c++編碼規(guī)范》的浩繁詳盡，此文當屬短小精悍了。而其中所列之各項條款，從編碼風格，到注意事項，不單只Java，對于其他語言，也都很有借鑒意義。因為簡短，所以易記，大家不妨將此作為handbook，常備案頭，逐一對驗。
1 介紹
1.1 為什么要有編碼規(guī)范
1.2 版權(quán)聲明
2 文件名
2.1 文件后綴
2.2 常用文件名
3 文件組織
3.1 Java源文件
3.1.1 開頭注釋
3.1.2 包和引入語句
3.1.3 類和接口聲明
4 縮進排版
4.1 行長度
4.2 換行
5 注釋
5.1 實現(xiàn)注釋的格式
5.1.1 塊注釋
5.1.2 單行注釋
5.1.3 尾端注釋
5.1.4 行末注釋
5.2 文擋注釋
6 聲明
6.1 每行聲明變量的數(shù)量
6.2 初始化
6.3 布局
6.4 類和接口的聲明
7 語句
7.1 簡單語句
7.2 復合語句
7.3 返回語句
7.4 if，if-else，if else-if else語句
7.5 for語句
7.6 while語句
7.7 do-while語句
7.8 switch語句
7.9 try-catch語句
8 空白
8.1 空行
8.2 空格
9 命名規(guī)范
10 編程慣例
10.1 提供對實例以及類變量的訪問控制
10.2 引用類變量和類方法
10.3 常量
10.4 變量賦值
10.5 其它慣例
10.5.1 圓括號
10.5.2 返回值
10.5.3 條件運算符"?"前的表達式"?"前的表達式
10.5.4 特殊注釋
11 代碼范例
11.1 Java源文件范例
1 介紹()
1.1 為什么要有編碼規(guī)范(Why Have Code )
編碼規(guī)范對于程序員而言尤為重要，有以下幾個原因：
- 一個軟件的生命周期中，80%的花費在于維護
- 幾乎沒有任何一個軟件，在其整個生命周期中，均由最初的開發(fā)人員來維護
- 編碼規(guī)范可以改善軟件的可讀性，可以讓程序員盡快而徹底地理解新的代碼
- 如果你將源碼作為產(chǎn)品發(fā)布，就需要確任它是否被很好的打包并且清晰無誤，一如你已構(gòu)建的其它任何產(chǎn)品
為了執(zhí)行規(guī)范，每個軟件開發(fā)人員必須一致遵守編碼規(guī)范。每個人。
1.2 版權(quán)聲明()
本文檔反映的是Sun 公司，Java語言規(guī)范中的編碼標準部盯咐分。主要凱野純貢獻者包括：Peter King，Patrick Naughton，Mike DeMoney，Jonni Kanerva，Kathy Walrath以及Scott Hommel。
本文檔現(xiàn)由Scott Hommel維護，有關(guān)評論意見請發(fā)至shommel@eng.sun.com
2 文件名(File Names)
這部分列出了常用的文件名及其后綴。
2.1 文件后綴(File Suffixes)
Java程序使用下列文件后綴：
文件類別 文件后綴
Java源文件 .java
Java字節(jié)碼文件 .class
2.2 常用文件名(Common File Names)
常用的文件名包括：
文件名 用途
makefiles的*文件名。我們采用gnumake來創(chuàng)建（build）軟件。
README 概述特定目錄下所含內(nèi)容的文件的*文件名
3 文件組織(File )
一個文件由被空行分割而成的段落以及標識每個段落的可選注釋共同組成。超過2000行的程序難以閱讀，應(yīng)該盡量避免。"Java源文件范例"提供了一個布局合理的Java程序范例。
3.1 Java源文件(Java Source Files)
每個Java源文件都包含一個單一的公共類或接口。若私有類和接口與一個公共類相關(guān)聯(lián)，可以將它們和公共類放入同一個源文件。公共脊昌類必須是這個文件中的*個類或接口。
Java源文件還遵循以下規(guī)則：
- 開頭注釋（參見"開頭注釋"）
- 包和引入語句（參見"包和引入語句"）
- 類和接口聲明（參見"類和接口聲明"）
3.1.1 開頭注釋(Beginning Comments)
所有的源文件都應(yīng)該在開頭有一個C語言風格的注釋，其中列出類名、版本信息、日期和版權(quán)聲明：
/*
* Classname
*
* Version
*
* Date
*
* Copyright notice
*/
3.1.2 包和引入語句(Package and Import )
在多數(shù)Java源文件中，*個非注釋行是包語句。在它之后可以跟引入語句。例如：
package java.awt;
import java.awt.peer.;
3.1.3 類和接口聲明(Class and Interface )
下表描述了類和接口聲明的各個部分以及它們出現(xiàn)的先后次序。參見"Java源文件范例"中一個包含注釋的例子。
類/接口聲明的各部分 注解
1 類/接口文檔注釋(/**……*/) 該注釋中所需包含的信息，參見"文檔注釋"
2 類或接口的聲明
3 類/接口實現(xiàn)的注釋(/*……*/)如果有必要的話 該注釋應(yīng)包含任何有關(guān)整個類或接口的信息，而這些信息又不適合作為類/接口文檔注釋。
4 類的(靜態(tài))變量 首先是類的公共變量，隨后是保護變量，再后是包一級別的變量(沒有訪問修飾符，access modifier)，*是私有變量。
5 實例變量 首先是公共級別的，隨后是保護級別的，再后是包一級別的(沒有訪問修飾符)，*是私有級別的。
6 構(gòu)造器
7 方法 這些方法應(yīng)該按功能，而非作用域或訪問權(quán)限，分組。例如，一個私有的類方法可以置于兩個公有的實例方法之間。其目的是為了更便于閱讀和理解代碼。
4 縮進排版()
4個空格常被作為縮進排版的一個單位?？s進的確切解釋并未詳細指定(空格 vs. 制表符)。一個制表符等于8個空格(而非4個)。
4.1 行長度(Line Length)
盡量避免一行的長度超過80個字符，因為很多終端和工具不能很好處理之。
注意：用于文檔中的例子應(yīng)該使用更短的行長，長度一般不超過70個字符。
4.2 換行(Wrapping Lines)
當一個表達式無法容納在一行內(nèi)時，可以依據(jù)如下一般規(guī)則斷開之：
- 在一個逗號后面斷開
- 在一個操作符前面斷開
- 寧可選擇較高級別(higher-level)的斷開，而非較低級別(lower-level)的斷開
- 新的一行應(yīng)該與上一行同一級別表達式的開頭處對齊
- 如果以上規(guī)則導致你的代碼混亂或者使你的代碼都堆擠在右邊，那就代之以縮進8個空格。
以下是斷開方法調(diào)用的一些例子：
(, , ,
, );
var = (,
(,
));
以下是兩個斷開算術(shù)表達式的例子。前者更好，因為斷開處位于括號表達式的外邊，這是個較高級別的斷開。
longName1 = longName2 * (longName3 + longName4 - longName5)
+ 4 * longname6; //PREFFER
longName1 = longName2 * (longName3 + longName4
- longName5) + 4 * longname6; //AVOID
以下是兩個縮進方法聲明的例子。前者是常規(guī)情形。后者若使用常規(guī)的縮進方式將會使第二行和第三行移得很靠右，所以代之以縮進8個空格
//
(int anArg, Object , String ,
Object ) {
...
}
//INDENT 8 SPACES TO AVOID VERY DEEP INDENTS
private static (int anArg,
Object , String ,
Object ) {
...
}
if語句的換行通常使用8個空格的規(guī)則，因為常規(guī)縮進(4個空格)會使語句體看起來比較費勁。比如：
//DON’T USE THIS
if (( && )
|| ( && )
||!( && )) { //BAD WRAPS
(); //MAKE THIS LINE EASY TO MISS
}
//USE THIS INSTEAD
if (( && )
|| ( && )
||!( && )) {
();
}
//OR USE THIS
if (( && ) || ( && )
||!( && )) {
();
}
這里有三種可行的方法用于處理三元運算表達式：
alpha = () ? beta : gamma;
alpha = () ? beta
: gamma;
alpha = ()
? beta
: gamma;
5 注釋(Comments)
Java程序有兩類注釋：實現(xiàn)注釋( comments)和文檔注釋(document comments)。實現(xiàn)注釋是那些在C++中見過的，使用/*...*/和//界定的注釋。文檔注釋(被稱為"doc comments")是Java獨有的，并由/**...*/界定。文檔注釋可以通過javadoc工具轉(zhuǎn)換成HTML文件。
實現(xiàn)注釋用以注釋代碼或者實現(xiàn)細節(jié)。文檔注釋從實現(xiàn)自由(-free)的角度描述代碼的規(guī)范。它可以被那些手頭沒有源碼的開發(fā)人員讀懂。
注釋應(yīng)被用來給出代碼的總括，并提供代碼自身沒有提供的附加信息。注釋應(yīng)該僅包含與閱讀和理解程序有關(guān)的信息。例如，相應(yīng)的包如何被建立或位于哪個目錄下之類的信息不應(yīng)包括在注釋中。
在注釋里，對設(shè)計決策中重要的或者不是顯而易見的地方進行說明是可以的，但應(yīng)避免提供代碼中己清晰表達出來的重復信息。多余的的注釋很容易過時。通常應(yīng)避免那些代碼更新就可能過時的注釋。
注意：頻繁的注釋有時反映出代碼的低質(zhì)量。當你覺得被迫要加注釋的時候，考慮一下重寫代碼使其更清晰。
注釋不應(yīng)寫在用星號或其他字符畫出來的大框里。注釋不應(yīng)包括諸如制表符和回退符之類的特殊字符。
5.1 實現(xiàn)注釋的格式( Comment Formats)
程序可以有4種實現(xiàn)注釋的風格：塊(block)、單行(single-line)、尾端(trailing)和行末(end-of-line)。
5.1.1 塊注釋(Block Comments)
塊注釋通常用于提供對文件，方法，數(shù)據(jù)結(jié)構(gòu)和算法的描述。塊注釋被置于每個文件的開始處以及每個方法之前。它們也可以被用于其他地方，比如方法內(nèi)部。在功能和方法內(nèi)部的塊注釋應(yīng)該和它們所描述的代碼具有一樣的縮進格式。
塊注釋之首應(yīng)該有一個空行，用于把塊注釋和代碼分割開來，比如：
/*
* Here is a block comment.
*/
塊注釋可以以/*-開頭，這樣indent(1)就可以將之識別為一個代碼塊的開始，而不會重排它。
/*-
* Here is a block comment with some very special
* that I want indent(1) to ignore.
*
* one
* two
* three
*/
注意：如果你不使用indent(1)，就不必在代碼中使用/*-，或為他人可能對你的代碼運行indent(1)作讓步。
參見"文檔注釋"
5.1.2 單行注釋(Single-Line Comments)
短注釋可以顯示在一行內(nèi)，并與其后的代碼具有一樣的縮進層級。如果一個注釋不能在一行內(nèi)寫完，就該采用塊注釋(參見"塊注釋")。單行注釋之前應(yīng)該有一個空行。以下是一個Java代碼中單行注釋的例子：
if (condition) {
/* Handle the condition. */
...
}
5.1.3 尾端注釋(Trailing Comments)
極短的注釋可以與它們所要描述的代碼位于同一行，但是應(yīng)該有足夠的空白來分開代碼和注釋。若有多個短注釋出現(xiàn)于大段代碼中，它們應(yīng)該具有相同的縮進。
以下是一個Java代碼中尾端注釋的例子：
if (a == 2) {
return TRUE; /* special case */
} else {
return isPrime(a); /* works only for odd a */
}
5.1.4 行末注釋(End-Of-Line Comments)
注釋界定符"http://"，可以注釋掉整行或者一行中的一部分。它一般不用于連續(xù)多行的注釋文本；然而，它可以用來注釋掉連續(xù)多行的代碼段。以下是所有三種風格的例子：
if (foo > 1) {
// Do a double-flip.
...
}
else {
return false; // Explain why here.
}
//if (bar > 1) {
//
// // Do a triple-flip.
// ...
//}
//else {
// return false;
//}
5.2 文檔注釋( Comments)
注意：此處描述的注釋格式之范例，參見"Java源文件范例"
若想了解更多，參見"How to Write Doc Comments for Javadoc"，其中包含了有關(guān)文檔注釋標記的信息(@return, @param, @see)：
* The Example class provides ...
*/
public class Example { ...
注意頂層(top-level)的類和接口是不縮進的，而其成員是縮進的。描述類和接口的文檔注釋的*行(/**)不需縮進；隨后的文檔注釋每行都縮進1格(使星號縱向?qū)R)。成員，包括構(gòu)造函數(shù)在內(nèi)，其文檔注釋的*行縮進4格，隨后每行都縮進5格。
若你想給出有關(guān)類、接口、變量或方法的信息，而這些信息又不適合寫在文檔中，則可使用實現(xiàn)塊注釋(見5.1.1)或緊跟在聲明后面的單行注釋(見5.1.2)。例如，有關(guān)一個類實現(xiàn)的細節(jié)，應(yīng)放入緊跟在類聲明后面的實現(xiàn)塊注釋中，而不是放在文檔注釋中。
文檔注釋不能放在一個方法或構(gòu)造器的定義塊中，因為Java會將位于文檔注釋之后的*個聲明與其相關(guān)聯(lián)。
6 聲明()
6.1 每行聲明變量的數(shù)量(Number Per Line)
推薦一行一個聲明，因為這樣以利于寫注釋。亦即，
int level; // level
int size; // size of table
要優(yōu)于，
int level, size;
不要將不同類型變量的聲明放在同一行，例如：
int foo, fooarray[]; //WRONG!
注意：上面的例子中，在類型和標識符之間放了一個空格，另一種被允許的替代方式是使用制表符：
int level; // level
int size; // size of table
Object ; // currently selected table entry
6.2 初始化()
盡量在聲明局部變量的同時初始化。*不這么做的理由是變量的初始值依賴于某些先前發(fā)生的計算。
6.3 布局(Placement)
只在代碼塊的開始處聲明變量。（一個塊是指任何被包含在大括號"{"和"}"中間的代碼。）不要在首次用到該變量時才聲明之。這會把注意力不集中的程序員搞糊涂，同時會妨礙代碼在該作用域內(nèi)的可移植性。
void myMethod() {
int int1 = 0; // beginning of method block
if (condition) {
int int2 = 0; // beginning of "if" block
...
}
}
該規(guī)則的一個例外是for循環(huán)的索引變量
for (int i = 0; i < maxLoops; i++) { ... }
避免聲明的局部變量覆蓋上一級聲明的變量。例如，不要在內(nèi)部代碼塊中聲明相同的變量名：
int count;
...
myMethod() {
if (condition) {
int count = 0; // AVOID!
...
}
...
}
6.4 類和接口的聲明(Class and Interface )
當編寫類和接口是，應(yīng)該遵守以下格式規(guī)則：
- 在方法名與其參數(shù)列表之前的左括號"("間不要有空格
- 左大括號"{"位于聲明語句同行的末尾
- 右大括號"}"另起一行，與相應(yīng)的聲明語句對齊，除非是一個空語句，"}"應(yīng)緊跟在"{"之后
class Sample extends Object {
int ivar1;
int ivar2;
Sample(int i, int j) {
ivar1 = i;
ivar2 = j;
}
int () {}
...
}
- 方法與方法之間以空行分隔
7 語句()
7.1 簡單語句(Simple )
每行至多包含一條語句，例如：
argv++; // Correct
argc--; // Correct
argv++; argc--; // AVOID!
7.2 復合語句(Compound )
復合語句是包含在大括號中的語句序列，形如"{ 語句 }"。例如下面各段。
- 被括其中的語句應(yīng)該較之復合語句縮進一個層次
- 左大括號"{"應(yīng)位于復合語句起始行的行尾；右大括號"}"應(yīng)另起一行并與復合語句首行對齊。
- 大括號可以被用于所有語句，包括單個語句，只要這些語句是諸如if-else或for控制結(jié)構(gòu)的一部分。這樣便于添加語句而無需擔心由于忘了加括號而引入bug。
7.3 返回語句(return )
一個帶返回值的return語句不使用小括號"()"，除非它們以某種方式使返回值更為顯見。例如：
return;
return myDisk.size();
return (size ? size : );
7.4 if，if-else，if else-if else語句(if, if-else, if else-if else )
if-else語句應(yīng)該具有如下格式：
if (condition) {
;
}
if (condition) {
;
} else {
;
}
if (condition) {
;
} else if (condition) {
;
} else{
;
}
注意：if語句總是用"{"和"}"括起來，避免使用如下容易引起錯誤的格式：
if (condition) //AVOID! THIS OMITS THE BRACES {}!
statement;
7.5 for語句(for )
一個for語句應(yīng)該具有如下格式：
for (; condition; update) {
;
}
一個空的for語句(所有工作都在初始化，條件判斷，更新子句中完成）應(yīng)該具有如下格式：
for (; condition; update);
當在for語句的初始化或更新子句中使用逗號時，避免因使用三個以上變量，而導致復雜度提高。若需要，可以在for循環(huán)之前(為初始化子句)或for循環(huán)末尾(為更新子句)使用單獨的語句。
7.6 while語句(while )
一個while語句應(yīng)該具有如下格式
while (condition) {
;
}
一個空的while語句應(yīng)該具有如下格式：
while (condition);
7.7 do-while語句(do-while )
一個do-while語句應(yīng)該具有如下格式：
do {
;
} while (condition);
7.8 switch語句(switch )
一個switch語句應(yīng)該具有如下格式：
switch (condition) {
case ABC:
;
/* falls through */
case DEF:
;
break;
case XYZ:
;
break;
default:
;
break;
}
每當一個case順著往下執(zhí)行時(因為沒有break語句)，通常應(yīng)在break語句的位置添加注釋。上面的示例代碼中就包含注釋/* falls through */。
7.9 try-catch語句(try-catch )
一個try-catch語句應(yīng)該具有如下格式：
try {
;
} catch ( e) {
;
}
一個try-catch語句后面也可能跟著一個finally語句，不論try代碼塊是否順利執(zhí)行完，它都會被執(zhí)行。
try {
;
} catch ( e) {
;
} finally {
;
}
8 空白(White Space)
8.1 空行(Blank Lines)
空行將邏輯相關(guān)的代碼段分隔開，以提高可讀性。
下列情況應(yīng)該總是使用兩個空行：
- 一個源文件的兩個片段(section)之間
- 類聲明和接口聲明之間
下列情況應(yīng)該總是使用一個空行：
- 兩個方法之間
- 方法內(nèi)的局部變量和方法的*條語句之間
- 塊注釋（參見"5.1.1"）或單行注釋（參見"5.1.2"）之前
- 一個方法內(nèi)的兩個邏輯段之間，用以提高可讀性
8.2 空格(Blank Spaces)
下列情況應(yīng)該使用空格：
- 一個緊跟著括號的關(guān)鍵字應(yīng)該被空格分開，例如：
while (true) {
...
}
注意：空格不應(yīng)該置于方法名與其左括號之間。這將有助于區(qū)分關(guān)鍵字和方法調(diào)用。
- 空白應(yīng)該位于參數(shù)列表中逗號的后面
- 所有的二元運算符，除了"."，應(yīng)該使用空格將之與操作數(shù)分開。一元操作符和操作數(shù)之間不因該加空格，比如：負號("-")、自增("++")和自減("--")。例如：
a += c + d;
a = (a + b) / (c * d);
while (d++ = s++) {
n++;
}
printSize("size is " + foo + "n");
- for語句中的表達式應(yīng)該被空格分開，例如：
for (expr1; expr2; expr3)
- 強制轉(zhuǎn)型后應(yīng)該跟一個空格，例如：
myMethod((byte) aNum, (Object) x);
myMethod((int) (cp + 5), ((int) (i + 3)) + 1);
9 命名規(guī)范(Naming )
命名規(guī)范使程序更易讀，從而更易于理解。它們也可以提供一些有關(guān)標識符功能的信息，以助于理解代碼，例如，不論它是一個常量，包，還是類。
標識符類型 命名規(guī)則 例子
包(Packages) 一個*包名的前綴總是全部小寫的ASCII字母并且是一個頂級域名，通常是com，edu，gov，mil，net，org，或1981年ISO 3166標準所指定的標識*的英文雙字符代碼。包名的后續(xù)部分根據(jù)不同機構(gòu)各自內(nèi)部的命名規(guī)范而不盡相同。這類命名規(guī)范可能以特定目錄名的組成來區(qū)分*()，項目(project)，機器(machine)，或注冊名(login names)。 com.sun.eng
com.apple.quicktime.v2
edu.cmu.cs.bovik.cheese
類(Classes) 命名規(guī)則：類名是個一名詞，采用大小寫混合的方式，每個單詞的首字母大寫。盡量使你的類名簡潔而富于描述。使用完整單詞，避免縮寫詞(除非該縮寫詞被更廣泛使用，像URL，HTML) class Raster;
class ;
接口() 命名規(guī)則：大小寫規(guī)則與類名相似 interface ;
interface Storing;
方法(Methods) 方法名是一個動詞，采用大小寫混合的方式，*個單詞的首字母小寫，其后單詞的首字母大寫。 run();
runFast();
();
變量(Variables) 除了變量名外，所有實例，包括類，類常量，均采用大小寫混合的方式，*個單詞的首字母小寫，其后單詞的首字母大寫。變量名不應(yīng)以下劃線或美元符號開頭，盡管這在語法上是允許的。
變量名應(yīng)簡短且富于描述。變量名的選用應(yīng)該易于記憶，即，能夠指出其用途。盡量避免單個字符的變量名，除非是一次性的臨時變量。臨時變量通常被取名為i，j，k，m和n，它們一般用于整型；c，d，e，它們一般用于字符型。 char c;
int i;
float myWidth;
實例變量(Instance Variables) 大小寫規(guī)則和變量名相似，除了前面需要一個下劃線 int _;
String _name;
Customer _customer;
常量(Constants) 類常量和ANSI常量的聲明，應(yīng)該全部大寫，單詞間用下劃線隔開。(盡量避免ANSI常量，容易引起錯誤) static final int MIN_WIDTH = 4;
static final int MAX_WIDTH = 999;
static final int GET_THE_CPU = 1;
10 編程慣例( Practices)
10.1 提供對實例以及類變量的訪問控制(Providing Access to Instance and Class Variables)
若沒有足夠理由，不要把實例或類變量聲明為公有。通常，實例變量無需顯式的設(shè)置(set)和獲取(gotten)，通常這作為方法調(diào)用的邊緣效應(yīng) (side effect)而產(chǎn)生。
一個具有公有實例變量的恰當例子，是類僅作為數(shù)據(jù)結(jié)構(gòu)，沒有行為。亦即，若你要使用一個結(jié)構(gòu)(struct)而非一個類(如果java支持結(jié)構(gòu)的話)，那么把類的實例變量聲明為公有是合適的。java編碼規(guī)范有哪些？
JAVA代碼規(guī)范：
(1) 類名首字母應(yīng)該大寫。字段、方法以及對象（句柄）的首字母應(yīng)小寫。對于旅羨所有標識符，其中包含的所有單詞都應(yīng)緊靠在一起，而且大寫中間單詞的首字母。例如：
若在定義中出現(xiàn)了常數(shù)初始化字符，則大寫static final基本類型標識符中的所有字母。這樣便可標志出它們屬于編譯期的常數(shù)。
Java包（Package）屬于一種特殊情況：它們?nèi)际切懽帜?，即便中間的單詞亦是如此。對于域名擴展名稱，如com，org，net或者edu等，全部都應(yīng)小寫（這也是Java 1.1和Java 1.2的區(qū)別之一）。
(2) 為了常規(guī)用途而創(chuàng)建一個類時，請采取"經(jīng)典形式"，并包含對下述元素的定義：
equals()
hashCode()
toString()
clone()（implement Cloneable）
implement
(3) 對于自己創(chuàng)建的每一個類，都考慮置入一個main()，其中包含了用于測試那個類的代碼。為使用一個項目中的類，我們沒必要刪除測試代碼。若進行了任何形式的改動，可方便地返回測試。這些代碼也可作為如何使用類的一個示例使用。
(4) 應(yīng)將方法含消設(shè)計成簡要的、功能性單元，用它描述和實現(xiàn)一個不連續(xù)的類接口部分。理想情況下，方法應(yīng)簡明扼要。若長度很大，可考慮通過某種方式將其分割成較短的幾個方法。這樣做也便于類內(nèi)代碼的重復使用（有些時候，方法必須非常大，但它們?nèi)詰?yīng)只做同樣的一件事情）。
(5) 設(shè)計一個類時，請設(shè)身處地為客戶程序員考慮一下（類的使用方法應(yīng)該是非常明確的）。然后，再設(shè)身處地為管理代碼的人考慮一下（預(yù)計有可能進行哪些形式的修改，想想用什么方法可把它們變得更簡單）。
(6) 使類盡可能短小精悍，而且只解決一個特定的問題。下面是對類設(shè)計的一些建議：
■一個復雜的開關(guān)語句：考慮采用"多形"機制
■數(shù)量眾多的方法涉及到類型差別極大的操作：考慮用幾個類來分別實現(xiàn)
■許多成員變量在特征上有很大的差別：考慮使用幾個類
(7) 讓一切東西都盡可能地"私有"--private?？墒箮斓哪骋徊糠?公共化"（一個方法、類或者一個字段等等），就永遠不能把它拿出。若強行拿出，就可能破壞其他人現(xiàn)有的代碼，使他們不得不重新編寫和設(shè)計。若只公布自己必須公布的，就可放心大膽地改變其他任何東西。在多線程環(huán)境中，隱私是特別重要的一個因素--只有private字段才能在非同步使用的情況下受拆老拍到保護。
(8) 謹惕"巨大對象綜合癥"。對一些習慣于順序編程思維、且初涉OOP領(lǐng)域的新手，往往喜歡先寫一個順序執(zhí)行的程序，再把它嵌入一個或兩個巨大的對象里。根據(jù)編程原理，對象表達的應(yīng)該是應(yīng)用程序的概念，而非應(yīng)用程序本身。
(9) 若不得已進行一些不太雅觀的編程，至少應(yīng)該把那些代碼置于一個類的內(nèi)部。
(10) 任何時候只要發(fā)現(xiàn)類與類之間結(jié)合得非常緊密，就需要考慮是否采用內(nèi)部類，從而改善編碼及維護工作（參見第14章14.1.2小節(jié)的"用內(nèi)部類改進代碼"）。
(11) 盡可能細致地加上注釋，并用javadoc注釋文檔語法生成自己的程序文檔。
(12) 避免使用"魔術(shù)數(shù)字"，這些數(shù)字很難與代碼很好地配合。如以后需要修改它，無疑會成為一場噩夢，因為根本不知道"100"到底是指"數(shù)組大小"還是"其他全然不同的東西"。所以，我們應(yīng)創(chuàng)建一個常數(shù)，并為其使用具有說服力的描述性名稱，并在整個程序中都采用常數(shù)標識符。這樣可使程序更易理解以及更易維護。
(13) 涉及構(gòu)建器和異常的時候，通常希望重新丟棄在構(gòu)建器中捕獲的任何異常--如果它造成了那個對象的創(chuàng)建失敗。這樣一來，調(diào)用者就不會以為那個對象已正確地創(chuàng)建，從而盲目地繼續(xù)。
(14) 當客戶程序員用完對象以后，若你的類要求進行任何清除工作，可考慮將清除代碼置于一個良好定義的方法里，采用類似于cleanup()這樣的名字，明確表明自己的用途。除此以外，可在類內(nèi)放置一個boolean（布爾）標記，指出對象是否已被清除。在類的finalize()方法里，請確定對象已被清除，并已丟棄了從繼承的一個類（如果還沒有的話），從而指出一個編程錯誤。在采取象這樣的方案之前，請確定finalize()能夠在自己的系統(tǒng)中工作（可能需要調(diào)用System.(true)，從而確保這一行為）。
(15) 在一個特定的作用域內(nèi)，若一個對象必須清除（非由垃圾收集機制處理），請采用下述方法：初始化對象；若成功，則立即進入一個含有finally從句的try塊，開始清除工作。
(16) 若在初始化過程中需要覆蓋（取消）finalize()，請記住調(diào)用super.finalize()（若Object屬于我們的直接超類，則無此必要）。在對finalize()進行覆蓋的過程中，對super.finalize()的調(diào)用應(yīng)屬于*一個行動，而不應(yīng)是*個行動，這樣可確保在需要基礎(chǔ)類組件的時候它們依然有效。
(17) 創(chuàng)建大小固定的對象集合時，請將它們傳輸至一個數(shù)組（若準備從一個方法里返回這個集合，更應(yīng)如此操作）。這樣一來，我們就可享受到數(shù)組在編譯期進行類型檢查的好處。此外，為使用它們，數(shù)組的接收者也許并不需要將對象"造型"到數(shù)組里。
(18) 盡量使用，不要使用abstract類。若已知某樣東西準備成為一個基礎(chǔ)類，那么*個選擇應(yīng)是將其變成一個interface（接口）。只有在不得不使用方法定義或者成員變量的時候，才需要將其變成一個abstract（抽象）類。接口主要描述了客戶希望做什么事情，而一個類則致力于（或允許）具體的實施細節(jié)。
(19) 在構(gòu)建器內(nèi)部，只進行那些將對象設(shè)為正確狀態(tài)所需的工作。盡可能地避免調(diào)用其他方法，因為那些方法可能被其他人覆蓋或取消，從而在構(gòu)建過程中產(chǎn)生不可預(yù)知的結(jié)果（參見第7章的詳細說明）。
(20) 對象不應(yīng)只是簡單地容納一些數(shù)據(jù)；它們的行為也應(yīng)得到良好的定義。
(21) 在現(xiàn)成類的基礎(chǔ)上創(chuàng)建新類時，請首先選擇"新建"或"創(chuàng)作"。只有自己的設(shè)計要求必須繼承時，才應(yīng)考慮這方面的問題。若在本來允許新建的場合使用了繼承，則整個設(shè)計會變得沒有必要地復雜。
(22) 用繼承及方法覆蓋來表示行為間的差異，而用字段表示狀態(tài)間的區(qū)別。一個非常極端的例子是通過對不同類的繼承來表示顏色，這是絕對應(yīng)該避免的：應(yīng)直接使用一個"顏色"字段。
(23) 為避免編程時遇到麻煩，請保證在自己類路徑指到的任何地方，每個名字都僅對應(yīng)一個類。否則，編譯器可能先找到同名的另一個類，并報告出錯消息。若懷疑自己碰到了類路徑問題，請試試在類路徑的每一個起點，搜索一下同名的.class文件。
(24) 在Java 1.1 AWT中使用事件"適配器"時，特別容易碰到一個陷阱。若覆蓋了某個適配器方法，同時拼寫方法沒有特別講究，*的結(jié)果就是新添加一個方法，而不是覆蓋現(xiàn)成方法。然而，由于這樣做是完全合法的，所以不會從編譯器或運行期系統(tǒng)獲得任何出錯提示--只不過代碼的工作就變得不正常了。
(25) 用合理的設(shè)計方案消除"偽功能"。也就是說，假若只需要創(chuàng)建類的一個對象，就不要提前限制自己使用應(yīng)用程序，并加上一條"只生成其中一個"注釋。請考慮將其封裝成一個"獨生子"的形式。若在主程序里有大量散亂的代碼，用于創(chuàng)建自己的對象，請考慮采納一種創(chuàng)造性的方案，將些代碼封裝起來。
(26) 警惕"分析癱瘓"。請記住，無論如何都要提前了解整個項目的狀況，再去考察其中的細節(jié)。由于把握了全局，可快速認識自己未知的一些因素，防止在考察細節(jié)的時候陷入"死邏輯"中。
(27) 警惕"過早優(yōu)化"。首先讓它運行起來，再考慮變得更快--但只有在自己必須這樣做、而且經(jīng)證實在某部分代碼中的確存在一個性能瓶頸的時候，才應(yīng)進行優(yōu)化。除非用專門的工具分析瓶頸，否則很有可能是在浪費自己的時間。性能提升的隱含代價是自己的代碼變得難于理解，而且難于維護。
(28) 請記住，閱讀代碼的時間比寫代碼的時間多得多。思路清晰的設(shè)計可獲得易于理解的程序，但注釋、細致的解釋以及一些示例往往具有不可估量的價值。無論對你自己，還是對后來的人，它們都是相當重要的。如對此仍有懷疑，那么請試想自己試圖從聯(lián)機Java文檔里找出有用信息時碰到的挫折，這樣或許能將你說服。
(29) 如認為自己已進行了良好的分析、設(shè)計或者實施，那么請稍微更換一下思維角度。試試邀請一些外來人士--并不一定是專家，但可以是來自本公司其他*的人。請他們用完全新鮮的眼光考察你的工作，看看是否能找出你一度熟視無睹的問題。采取這種方式，往往能在最適合修改的階段找出一些關(guān)鍵性的問題，避免產(chǎn)品發(fā)行后再解決問題而造成的金錢及精力方面的損失。
(30) 良好的設(shè)計能帶來*的回報。簡言之，對于一個特定的問題，通常會花較長的時間才能找到一種最恰當?shù)慕鉀Q方案。但一旦找到了正確的方法，以后的工作就輕松多了，再也不用經(jīng)歷數(shù)小時、數(shù)天或者數(shù)月的痛苦掙扎。我們的努力工作會帶來*的回報（甚至無可估量）。而且由于自己傾注了大量心血，最終獲得一個出色的設(shè)計方案，成功的快感也是令人心動的。堅持****草草完工的誘惑--那樣做往往得不償失Java項目開發(fā)標準
你可以看一個東西，叫做cmmi。
CMMI全稱是 Maturity Model ，鏈清即能力成熟度模型集成（也有稱為：軟件能力成熟度集成模型），是美國國防部的一個設(shè)想，1994年由美國國防部（United States of Defense）與卡內(nèi)基-梅隆*（Carnegie-Mellon ）下的軟件工程研究中心（Software Institute，SEISM）以及美國國防工業(yè)協(xié)會（National Defense ）共同開發(fā)和研制的，他們計劃把現(xiàn)在所有現(xiàn)存實施的與即將被發(fā)展出棚友前來的各種能力成熟度模型，集成到一個框架中去，申請此認證的前提條件是該企業(yè)具有有效的軟件企業(yè)認定證書。
其目的是幫助軟件企業(yè)對軟件工程過程進行管理和改進，增強開發(fā)與改進能力，從而能按時地、不超預(yù)算地開發(fā)出高質(zhì)量的軟件。其告含所依據(jù)的想法是：只要集中精力持續(xù)努力去建立有效的軟件工程過程的基礎(chǔ)結(jié)構(gòu)，不斷進行管理的實踐和過程的改進，就可以克服軟件開發(fā)中的困難。CMMI為改進一個組織的各種過程提供了一個單一的集成化框架，新的集成模型框架消除了各個模型的不一致性，減少了模型間的重復，增加透明度和理解，建立了一個自動的、可擴展的框架。因而能夠從總體上改進組織的質(zhì)量和效率。CMMI主要關(guān)注點就是成本效益、明確重點、過程集中和靈活性四個方面。
CMMI 是現(xiàn)在來說最為規(guī)范的項目開發(fā)標準。一般上點規(guī)模的公司都起碼要過cmmi3級才行。自學Java開發(fā)要注意什么？
隨著Java行業(yè)發(fā)展的越來越好，學Java的朋友也越來越多，很多人不甘落后，按捺不住自己想學Java的心，于是開始捉摸怎么學Java。目前*效的學習Java的方式就是參加Java培訓，但是自己不想?yún)⒓覬ava培訓，想自學Java該怎么辦呢?別急，沙河電腦培訓這就為你支招。
想自學Java該怎么辦?
1.制定Java學習計劃
自學Java首先就得有個Java學習計劃，不然靠今天看看這個Java知識點，明天看看哪個Java知識點，永遠也別想學好Java。至于Java學習計劃怎么制定，因人而異，不過你先對Java知識體系有個大致的了解，然后按照你的學習時間來行橋洞安排Java的學習計劃，Java學習計劃自然是越詳細越好。
2.保持良好的Java學習習慣
在學Java中必須保持一些良好的學習習慣，比如你需要有做筆記的習慣，這樣你有哪些不懂還沒掌握的，日后翻到了，你還可以看看自己會不會解了，進行查漏補缺。檔枯比如你還必須遵守，Java代碼中各種各樣的編程規(guī)范，你才能夠在日后寫出高質(zhì)量的Java代碼，才能備受企業(yè)喜愛。
3.學會與人進行溝通Java技術(shù)
Java技術(shù)的學習，如果你一個人關(guān)門造車，那么你的Java技術(shù)沒有對比，你也不知道自己到底掌握的怎么樣了，跟人交流Java技術(shù)特別的有必要，日后你會知道技術(shù)知識的交流不僅僅消老在于程序員之間，也會直面客戶，不管你跟誰溝通的好，你的未來發(fā)展就會比較好，至少你的人脈資源不會很差。
J2SE簡介
多數(shù)編程語言都有預(yù)選編譯好的類庫以支持各種特定的功能 在Java中 類庫以包（package）的形式提供 不同版本的Java提供不同的包 以面向特定的應(yīng)用
Java 平臺包括 標準版（J SE） 企業(yè)版（J EE）和微縮版（J ME）三個版本 J SE J ME和J EE 這也就是SunONE（Open ）體系 J SE就是Java 的標準版 主要用于桌面應(yīng)用軟件的編程 J ME主要應(yīng)用于嵌入是系統(tǒng)開發(fā) 如手機和PDA的編程 J EE是Java 的企業(yè)版 主要用于分布式的網(wǎng)絡(luò)程序的開發(fā) 如電子商務(wù)網(wǎng)站和ERP系統(tǒng)
Standard Edition（標準版） J SE 包含那些構(gòu)成Java語言核心的類 比如 數(shù)據(jù)庫連接 接口定義 輸入/輸出 網(wǎng)絡(luò)編程
Edition（企業(yè)版） J EE 包含J SE 中的類 并且還包含用于開發(fā)企業(yè)級應(yīng)用的類 比如 EJB servlet JSP XML 事務(wù)控制
Micro Edition（微縮版） J ME 包含J SE中一部分類 用于消費類電子產(chǎn)品的軟件開發(fā) 比如 呼機 智能卡 手機 PDA 機頂盒
簡單講就是
j se java simple edtion 小型程序用
j ee java edtion 大型程序用
j me java micro editon 手機上用
他們的范圍是 J SE包含于J EE中 J ME包乎閉含了J SE的核心類 但新添加了一些專有類應(yīng)用場合 API的覆蓋范圍各不相同
籠統(tǒng)的講 可以這樣理解 J SE是基礎(chǔ) 壓縮一點 再增加一些CLDC等方面的特性就是J ME 擴充一點 再增加一些EJB等企業(yè)應(yīng)用方面的特性就是J EE
補充一點J EE更恰當?shù)恼f 應(yīng)該是JAVA 企業(yè)開發(fā)的技術(shù)規(guī)范 不僅僅是比標準版多了一些類 J EE又包括許多組件 如Jsp Servlet JavaBean EJB JDBC JavaMail等
J SE商業(yè)版本 標準版本 （Java Standard Edition） 定位在客戶端 主要用于桌面應(yīng)用軟件的歲毀裂編程
J SE 包含那些構(gòu)成Java語言核心的類
比如 數(shù)據(jù)庫連接 接口定義 輸入/輸出 網(wǎng)絡(luò)編程
Java 代碼簽名證書主要用于證明軟件開發(fā)者開發(fā)的軟件代碼符合 Sun Java 規(guī)范 您可以使用Java 代碼余彎簽名證書來為您的 Java 代碼進行數(shù)字簽名 以便通過互聯(lián)網(wǎng)安全分發(fā) 使得最終用戶能確信您的代碼已經(jīng)通過權(quán)威的第三方認證 而且沒有在傳輸過程中被非法篡改和被破壞
Java 代碼簽名證書可以用于數(shù)字簽名運行J ME MIDlet（MIDP ）代碼 支持諾基亞和索愛等手機的MIDlet應(yīng)用軟件 運行簽名后的MIDlet Suite就會顯示軟件發(fā)行商名稱 否則會顯示讓用戶不敢下載的警告 應(yīng)用軟件來源未知 繼續(xù)？ 同時 簽名后訪問網(wǎng)絡(luò)等都不會彈出煩人的警告框了 讓手機應(yīng)用更加安全 更有利于軟件開發(fā)商推廣其應(yīng)用軟件 如果需要簽名J SE的 Jar代碼 則推薦您購買Thawte Java代碼簽名證書 因為其價格比VeriSign的便宜 如果您希望有比Thawte Java代碼簽名證書更便宜的Java代碼簽名證書 則您可以選購 WoSign Java代碼簽名證書 但請注意 WoSign Java代碼簽名證書只支持Java J SE 版本或以上版本
J SE是J EE的基礎(chǔ) 他大量的JDK代碼庫是每個要學習J EE的編程人員必須掌握的
/Article/program/Java/JSP/201311/19755
如何寫出好的Java代碼
如何寫出好的Java代碼
1． 優(yōu)雅需要付出代價。
從短期利益來看，對某個問題提出優(yōu)雅的解決方法，似乎可能花你更多的時間。但當它終于能夠正確執(zhí)行并可輕易套用于新案例中，不需要花上數(shù)以時計，甚至以天計或以月計的辛苦代價時，你會看得到先前所花功夫的回報（即使沒有人可以衡量這一點）。這不僅給你一個可更容易開發(fā)和調(diào)試的程序，也更易于理解和維護。這正是它在金錢上的價值所在。這一點有賴某種人生經(jīng)驗才能夠了解，因為當你努力讓某一段程序代碼變得比較優(yōu)雅時，你并不是處于一種具生產(chǎn)力的狀態(tài)下。但是，請抗拒那些催促你趕工的人們，因為那么做只會減緩你的速度罷了。
2． 先求能動，再求快。
即使你已確定某段程序代碼極為重要，而且是系統(tǒng)的重要瓶頸，這個準則依然成立。盡可能簡化設(shè)計，讓系統(tǒng)能夠先正確動作。如果程序的執(zhí)行不夠快，再量測其效能。幾乎你總是會發(fā)現(xiàn)，你所認為的”瓶頸”其實都不是問題所在。把你擾返的時間花在刀口上吧。
3． 記住”各個擊破”的原理。
如果你所探討的問題過于混雜，試著想像該問題的基本動作會是什么，并假設(shè)這一小塊東西能夠神奇地處理掉最難的部分。這”一小塊”東西其實就是對象–請撰寫運用該對象的程序代碼，然后檢視對象，并將其中困難的部分再包裝成其他對象，依此類推。
4． 區(qū)分class開發(fā)者和class使用者（使用端程序員）。
Class 使用者扮演著”客戶”角色，不需要（也不知道）class的底層運作方式。Class開發(fā)者必須是class設(shè)計專家，并撰寫class，使它能夠盡可能被大多數(shù)新手程序員所用，而且在程序中能夠穩(wěn)當執(zhí)行。一套程序庫只有在具備通透性的情況下，使用起來才會容易。
5．當你撰寫class時，試著給予明了易懂的名稱，減少不必要的注解。
你給客戶端程序員的接口，應(yīng)該保持概念上的單純性。不了這個目的，當函數(shù)的重載（）適合制作出直覺、易用的接口時，請善加使用。
6． 也必你的分析和設(shè)計必須讓系統(tǒng)中的classes保持最少，須讓其Public 保持最少，以及讓這些classes和其他classes之間的關(guān)聯(lián)性（ 尤其是base classes）保持最少。
如果你的設(shè)計所得結(jié)果更甚于此，請問問自己，是否其中每一樣東西在整個程序生命期中都饒富價值？如果并非如此，那么，維護它們會使你付出代價。開發(fā)團隊的成員都有不維護”無益于生產(chǎn)力提升”的任何東西的傾向；這是許多設(shè)計方法無法解釋的現(xiàn)象。
7． 讓所有東西盡謹李坦量自動化。先撰寫測試用的程序代碼（在你撰寫class之前），并讓它和class結(jié)合在一起。請祥桐使用makefile或類似工具，自動進行測試動作。
通過這種方式，只要執(zhí)行測試程序，所有的程序變動就可以自動獲得驗證，而且可以立即發(fā)現(xiàn)錯誤。由于你知道的測試架構(gòu)所具備的安全性，所以當你發(fā)現(xiàn)新的需求時，你會更勇于進行全面修改。請記住，程序語言*的改進，是來自型別檢查、異常處理等機制所賦予的內(nèi)置測試動作。但這些功能只能協(xié)助你到達某種程度。開發(fā)一個穩(wěn)固系統(tǒng)時，你得自己驗證自己的classes或程序的性質(zhì)。
8． 在你撰寫class之前先寫測試碼，以便驗證你的class 是否設(shè)計完備。如果你無法撰寫測試碼，你便無法知道你的class 的可能長相。撰寫測試碼通常能夠顯現(xiàn)出額外的特性（features）或限制 ( )__它們并不一定總是能夠在分析和設(shè)計過程中出現(xiàn)。測試碼也可做為展示class 用法的示例程序。
9． 所有軟件設(shè)計上的問題，都可以通過”引入額外的概念性間接層（ ）”加以簡化。這個軟件工程上的基礎(chǔ)法則是抽象化概念的根據(jù)，而抽象化概念正是面向?qū)ο蟪绦蛟O(shè)計的主要性質(zhì)。
10． 間接層()應(yīng)該要有意義（和準則-9致）。
這里所指的意義可以像”將共用程序代碼置于惟一函數(shù)”這么簡單。如果你加入的間接層（或抽象化、或封裝等等）不具意義，它可能就和沒有適當?shù)拈g接層一樣糟糕。
11． 讓class盡可能微小而無法切割（atomic）。
賦予每個class單一而清楚的用途。如果你的classes或你的系統(tǒng)成長得過于復雜，請將復雜的classes切割成比較簡單的幾個classes。最明顯的一個判斷指針就是class的大小：如果它很大，那么它工作量過多的機會就可能很高，那就應(yīng)該被切割。重新設(shè)計class的建議線索是：
1） 復雜的switch語句：請考慮運用多態(tài)（）。
2） 許多函數(shù)各自處理類型極為不同的動作：請考慮切割為多個不同的（classes）。
12． 小心冗長的引數(shù)列（argument lists）。
冗長的引數(shù)列會使函數(shù)的調(diào)用動作不易撰寫、閱讀、維護。你應(yīng)該試著將函數(shù)搬移到更適當?shù)腸lass中，并盡量以對象為引數(shù)。
13． 不要一再重復。
如果某段程序代碼不斷出現(xiàn)于許多derived class函數(shù)中，請將該段程序代碼置于某個base class 函數(shù)內(nèi)，然后在derived class函數(shù)中調(diào)用。這么做不僅可以省下程序代碼空間，也可以讓修改該段程序代碼動作更易于進行。有時候找出此種共通程序代碼還可以為接口增加實用功能。
14． 小心switch語句或成串的if-else 子句。
通常這種情況代表所謂的”type-check coding”。也就是說究竟會執(zhí)行哪一段程序代碼，乃是依據(jù)某種型別信息來做抉擇（最初，確切型別可能不十分明顯）。你通?？梢允褂美^承和多態(tài)來取代此類程序代碼； method （多態(tài)函數(shù)）的調(diào)用會自動執(zhí)行此類型別檢驗，并提供更可靠更容易的擴充性。
15． 從設(shè)計觀點來看，請找出變動的事物，并使它和不變的事物分離。
也就是說，找出系統(tǒng)中可能被你改變的元素，將它們封裝于classes中。你可以在《Thinking in Patterns with Java》（可免費下載于 www. . Com）大量學習到這種觀念。
16． 不要利用來擴充基礎(chǔ)功能。
如果某個接口元素對class而言極重要，它應(yīng)該被放在base class 里頭，而不是直到衍生（）時才被加入。如果你在繼承過程中加入了函數(shù)，或許你應(yīng)該重新思考整個設(shè)計。
17． 少就是多。
從class 的最小接口開始妨展，盡可能在解決問題的前提下讓它保持既小又單純。不要預(yù)先考量你的class被使用的所有可能方式。一旦class被實際運用，你自然會知道你得如何擴充接口。不過，一旦class被使用后，你就無法在不影響客戶程序代碼的情況下縮減其接口。如果你要加入更多函數(shù)倒是沒有問題–不會影響既有的客戶程序代碼，它們只需重新編譯即可。但即使新函數(shù)取代了舊函數(shù)的功能，也請你保留既有接口。如果你得通過”加入更多引數(shù)”的方式來擴充既有函數(shù)的接口，請你以新引數(shù)寫出一個重載化的函數(shù)；通過 這種方式就不會影響既有函數(shù)的任何客戶了。
18． 大聲念出你的classes,確認它們符合邏輯。
請base class和derived class 之間的關(guān)系是”is-a”(是一種)，讓class和成員對象之間的關(guān)系是”has-a”(有一個)。
19． 當你猶豫不決于繼承（）或合成（組合，）時，請你問問自己，是否需要向上轉(zhuǎn)型（upcast）為基礎(chǔ)型別。
如果不需要，請優(yōu)先選擇合成（也就是是使用成員對象）。這種作法可以消除”過多基礎(chǔ)型別”。如果你采用繼承，使用者會認為他們應(yīng)該可以向上轉(zhuǎn)型。
20． 運用數(shù)據(jù)成員來表示數(shù)值的變化，運用經(jīng)過覆寫的函數(shù)（overrided method）來代表行為的變化 。
也就是說，如果你找到了某個 class, 帶有一些狀態(tài)變量，而其函數(shù)會依據(jù)這些變量值切換不同的行為，那么你或許就應(yīng)該重新設(shè)計，在 和覆寫后的函數(shù)（overrided methods）中展現(xiàn)行為止的差異。
21． 小心重載（）。
函數(shù)不應(yīng)該依據(jù)引數(shù)值條件式地選擇執(zhí)行某一段程序代碼。這種情況下你應(yīng)該撰寫兩個或更多個重載函數(shù)（ methods）
22． 使用異常體系（exception ）
*是從Java標準異常體系中衍生特定的classes, 那么，捕捉異常的人便可以捕捉特定異常，之后才捕捉基本異常。如果你加入新的衍生異常，原有的客戶端程序仍能通過其基礎(chǔ)型別來捕捉它。
23． 有時候簡單的聚合（）就夠了。
飛機上的”旅客舒適系統(tǒng)”包括數(shù)個分離的元素：座椅、空調(diào)、視訊設(shè)備等等，你會需要在飛機上產(chǎn)生許多這樣的東西。你會將它們聲明為Private成員并開發(fā)出一個全新的接口嗎？不會的，在這個例子中，元素也是Public接口的一部分，所以仍然是安全的。當然啦，簡單聚合并不是一個常被運用的解法，但有時候的確是。
24． 試著從客戶程序員和程序維護的角度思考。
你的class應(yīng)該設(shè)計得盡可能容易使用。你應(yīng)該預(yù)先考量可能性有的變動，并針對這些 可能的變動進行設(shè)計，使這些變動日后可輕易完成。
25． 小心”巨大對象并發(fā)癥”。
這往往是剛踏OOP領(lǐng)域的過程式（）程序員的一個苦惱，因為他們往往最終還是寫出一個過程式程序，并將它們擺放到一個或兩個巨大對象中。注意，除了 framework (應(yīng)用程序框架，譯注：一種很特殊的、大型OO程序庫，幫你架構(gòu)程序本體)之外，對象代表的是程序中的觀念，而不是程序本身。
26． 如果你得用某種丑陋的方式來達成某個動作，請將丑陋的部分局限在某個class里頭。
27． 如果你得用某種不可移植方式來達成某個動作，請將它抽象化并局限于某個class里頭。這樣一個”額外間接層”能夠防止不可移植的部分擴散到整個程序。這種作法的具體呈現(xiàn)便是Bridge設(shè)計模式（design pattern）。
28． 對象不應(yīng)僅僅只用來持有數(shù)據(jù)。
對象也應(yīng)該具有定義明確界限清楚的行為。有時候使用”數(shù)據(jù)對象”是適當?shù)?，但只有在通用形容器不適用時，才適合刻意以數(shù)據(jù)對象來包裝、傳輸一群數(shù)據(jù)項。
29． 欲從既有的classes身上產(chǎn)生新的classes時，請以組合()為優(yōu)先考量。
你應(yīng)該只在必要時才使用繼承。如果在組合適用之處你卻選擇了繼承，你的設(shè)計就滲雜了非必要的復雜性。
30． 運用繼承和函數(shù)覆寫機制來展現(xiàn)行為上的差異，運用fields(數(shù)據(jù)成員)來展現(xiàn)狀態(tài)上的差異。
這句話的極端例子，就是繼承出不同的classes表現(xiàn)各種不同的顏色，而不使用”color”field.
31． 當心變異性（variance）。
語意相異的兩個對象擁有相同的動作（或說責任）是可能的。OO世界中存在著一種天生的引誘，讓人想要從某個class繼承出另一個subclass,為的是獲得繼承帶來的福利。這便是所謂”變異性”。但是，沒有任何正當理由足以讓我們強迫制造出某個其實并不存在的/subclass關(guān)系。比較好的解決方式是寫出一個共用的base class,它為兩個derived classes制作出共用接口–這種方式會耗用更多空間，但你可以如你所盼望地從繼承機制獲得好處，而且或許能夠在設(shè)計上獲得重大發(fā)現(xiàn)。
32． 注意繼承上的限制。
最清晰易懂的設(shè)計是將功能加到繼承得來的class里頭；繼承過程中拿掉舊功能（而非增加新功能）則是一種可疑的設(shè)計。不過，規(guī)則可以打破。如果你所處理的是舊有的class程序庫，那么在某個class的subclass限制功能，可能會比重新制定整個結(jié)構(gòu)（俾使新class得以良好地相稱于舊 class）有效率得多。
33． 使用設(shè)計模式（design patterns）來減少”赤裸裸無加掩飾的機能（naked ）”。
舉個例子，如果你的class只應(yīng)該產(chǎn)出惟一一個對象，那么請不要以加思索毫無設(shè)計的手法來完成它，然后撰寫”只該產(chǎn)生一份對象”這樣的注解就拍拍屁股走人。請將它包裝成singleton（譯注：一個有名的設(shè)計模式，可譯為”單件”）。如果主程序中有多而混亂的”用以產(chǎn)生對象”的程序代碼，請找出類似 factory method這樣的生成模式（ patterns），使價錢可用以封裝生成動作減少”赤裸裸無加掩飾的機能”（naked ）不僅可以讓你的程序更易理解和維護，也可以阻止出于好意卻帶來意外的維護者。
34． 當心”因分析而導致的癱瘓（analysis paralysis）”。
請記住，你往往必須在獲得所有信息之前讓項目繼續(xù)前進。而且理解未知部分的*也最快的方式，通常就是實際前進一步而不只是紙上談兵。除非找到解決辦法，否則無法知道解決辦法。Java擁有內(nèi)置的防火墻，請讓它們發(fā)揮作用。你在單一class或一組classes中所犯的錯誤，并不會傷害整個系統(tǒng)的完整性。
35． 當你認為你已經(jīng)獲得一份優(yōu)秀的分析、設(shè)計或?qū)崿F(xiàn)時，請試著加以演練。
將團隊以外的某些人帶進來-他不必非得是個顧問不可，他可以是公司其他團隊的成員。請那個人以新鮮的姿態(tài)審視你們的成果，這樣可以在尚可輕易修改的階段找出問題，其收獲會比因演練而付出的時間和金錢代價來得高。實現(xiàn) （）
36. 一般來說，請遵守Sun的程序編寫習慣。
價錢可以在以下網(wǎng)址找到相關(guān)文檔：java.sun.com/docs/codeconv/idex.html。本書盡可能遵守這些習慣。眾多Java程序員看到的程序代碼，都有是由這些習慣構(gòu)成的。如果你固執(zhí)地停留在過去的編寫風格中，你的（程序代碼）讀者會比較辛苦。不論你決定采用什么編寫習慣，請在整個程序中保持一致。你可以在home.wtal.de/software-solutions/jindent上找到一個用來重排Java程序的免費工具。
37. 無論使用何種編寫風格，如果你的團隊（或整個公司，那就更好了）能夠加以標準化，那么的確會帶來顯著效果。這代表每個人都可以在其他人不遵守編寫風格修改其作品，這是個公平的游戲。標準化的價值在于，分析程序代碼時所花的腦力較小，因而可以專心于程序代碼的實質(zhì)意義。
38. 遵守標準的大小寫規(guī)范。
將 class名稱的*個字母應(yīng)為大寫。數(shù)據(jù)成員、函數(shù)、對象（）的*個字母應(yīng)為小寫。所有識別名稱的每個字都應(yīng)該連在一塊兒，所有非首字的*個字母都應(yīng)該大寫。例如： 如果你在static final 基本型別的定義處指定了常量初始式（constant ）,那么該識別名稱應(yīng)該全為大寫，代表一個編譯期常量。 Packages是個特例，其名稱皆為小寫，即使非首字的字母亦是如此。域名（org, net, edu 等等）皆應(yīng)為小寫。（這是Java 1.1遷移至Java 2時的一項改變） 。
39、不要自己發(fā)明”裝飾用的”Private數(shù)據(jù)成員名稱。
通常這種的形式是在最前端加上底線和其他字符，匈牙利命名法（Hungarian notation）是其中最差的示范。在這種命名法中，你得加入額外字符來表示數(shù)據(jù)的型別、用途、位置等等。仿佛你用的是匯編語言（assembly language）而編譯器沒有提供任何協(xié)肋似的。這樣的命名方式容易讓人混淆又難以閱讀，也不易推行和維護。就讓classes和packages來進行”名稱上的范
圍制定（name scoping）”吧。
40、當你擬定通用性的class時，請遵守正規(guī)形式（canonical form）。
包括equals( )、hashCode( )、clone( ) ( 實現(xiàn)出Cloneable),并實現(xiàn)出和等等。
41、對于那些”取得或改變Private數(shù)據(jù)值”的函數(shù)，請使用Java Beans 的”get”、”set”、”is”等命名習慣，即使你當時不認為自己正在撰寫Java Bean。這么做不僅可以輕易以Bean的運用方式來運用你的class,也是對此類函數(shù)的一種標準命名方式，使讀者更易于理解。
42、對于你所擬定的每一個class，請考慮為它加入static public test( )，其中含有class功能測試碼。
你不需要移除該測試就可將程序納入項目。而且如果有所變動，你可以輕易重新執(zhí)行測試。這段程序代碼也可以做為class的使用示例。
43、有時候你需要通過繼承，才得以訪問base class的protected成員。
這可能會引發(fā)對多重基類（multiple base types）的認識需求。如果你不需要向上轉(zhuǎn)型，你可以先衍生新的class發(fā)便執(zhí)行protected訪問動作，然后在”需要用到上述 protected成員”的所有classes中，將新class聲明為成員對象，而非直接繼承。
44、避免純粹為了效率考量而使用final函數(shù)。
只有在程序能動但執(zhí)行不夠快時，而且效能量測工具（profiler）顯示某個函數(shù)的調(diào)用動作成為瓶頸時，才使用final函數(shù)。
45、如果兩個classes因某種功能性原因而產(chǎn)生了關(guān)聯(lián)（例如容器和迭代器iterators）,那么請試著讓其中某個class成為另一個class 的內(nèi)隱類（inner class）。
這不僅強調(diào)二者間的關(guān)聯(lián)，也是通過”將class名稱嵌套置于另一個class 內(nèi)”而使同一個class 名稱在單一Package中可被重復使用。Java 容器庫在每個容器類中都定義了一個內(nèi)隱的（inner）Iterator class,因而能夠提供容器一份共通接口。運用內(nèi)隱類的另一個原因是讓它成為private實現(xiàn)物的一部分。在這里，內(nèi)隱類會為信息隱藏帶來好處，而不是對上述的class關(guān)聯(lián)性提供肋益，也不是為了防止命名空間污染問題(namespace pollution)。
46、任何時候你都要注意那些高度耦合（coupling）的 classes.請考慮內(nèi)隱類（inner classes）為程序擬定和維護帶來的好處。內(nèi)隱類的使用并不是要去除classes間的耦合，而是要讓耦合關(guān)系更明顯也更便利。
47、不要成為”過早*化”的犧牲品。
那會讓人神經(jīng)錯亂。尤其在系統(tǒng)建構(gòu)初期，先別煩惱究竟要不要撰寫（或避免）原生函數(shù)（native methods）、要不要將某些數(shù)聲明為final、要不要調(diào)校程序代碼效率等等。你的主要問題應(yīng)該是先證明設(shè)計的正確性，除非設(shè)計本身需要某種程度的效率。
48、讓范圍（作用域，scope）盡可能愈小愈好，這么一來對象的可視范圍和壽命都將盡可能地小。
這種作法可降低”對象被用于錯誤場所，因而隱藏難以察覺的臭蟲”的機會。假設(shè)你有個容器，以及一段走訪該容器的程序片段。如果你復制該段程序代碼，將它用于新的容器身上，你可能會不小心以舊容器的大小做為新容器的走訪上限值。如果舊容器已不在訪問范圍內(nèi)，那么編譯期便可找出這樣的錯誤。
49、使用Java 標準程序庫提供的容器。
請熟悉他們的用法。你將因此大幅提升你的生產(chǎn)力。請優(yōu)先選擇ArrayList來處理序列（sequences），選擇HashSet來處理集合（sets）、選擇HashMap來處理關(guān)聯(lián)式數(shù)組（ arrays），選擇 (而不是Stack) 來處理 shacks和queues。
50、對一個強固的（robust）程序而言，每一個組成都必須強固。
請在你所撰寫的每個class中運用Java 提供的所有強固提升工具：訪問權(quán)限、異常、型別檢驗等等。通過這種方式，你可以在建構(gòu)系統(tǒng)時安全地移往抽象化的下一個層次。
51、寧可在編譯期發(fā)生錯誤，也不要在執(zhí)行期發(fā)生錯誤。
試著在最靠近問題發(fā)生點的地方處理問題。請優(yōu)先在”擲出異常之處”處理問題，并在擁有足夠信息以處理異常的最接近處理函數(shù)（handler）中捕捉異常。請進行現(xiàn)階段你能夠?qū)υ摦惓Ｋ龅奶幚?；如果你無法解決問題，應(yīng)該再次擲出異常。
52、當心冗長的函數(shù)定義。
函數(shù)應(yīng)該是一種簡短的、”描述并實現(xiàn)class接口中某個可分離部分”的功能單元。過長且復雜的函數(shù)不僅難以維護，維護代價也高?；蛟S它嘗試做太多事情了。如果你發(fā)現(xiàn)這一類函數(shù)，代表它應(yīng)該被切割成多相函數(shù)。這種函數(shù)也提醒你或許得撰寫新的class。小型函數(shù)同樣能夠在你的class中被重復運用。（有時候函數(shù)必須很大才行，但它們應(yīng)該只做一件事情。）
53、盡可能保持”Private”。
一旦你對外公開了程序庫的概況（method、Class 或field）。你便再也無法移除它們。因為如果移除它們，便會破壞某個現(xiàn)有的程序代碼，使得它們必須重新被編寫或重新設(shè)計。如果你只公開必要部分，那么你便可以改變其他東西而不造成傷害。設(shè)計總是會演化，所以這是個十分重要的自由度。通過這種方式，實現(xiàn)碼的更動對derived class 造成的沖擊會降*。在多線程環(huán)境下，私密性格外重要-只有private數(shù)據(jù)可受保護而不被un-（未受同步控制）的運用所破壞。
54、大量運用注解，并使用javadoc的”注解文檔語法”來產(chǎn)生程序的說明文檔。
不過注解應(yīng)該賦予程序代碼真正的意義；如果只是重申程序代碼已經(jīng)明確表示的內(nèi)容，那是很煩人的。請注意，通常Java class和其函數(shù)的名稱都很長，為的便是降低注解量。
55、避免使用”魔術(shù)數(shù)字”，也就是那種寫死在程序代碼里頭的數(shù)字–如果你想改變它們，它們就會成為你的惡夢，因為你永遠都沒有辦法知道”100″究竟代表” 數(shù)組大小”或其他東西。你應(yīng)該產(chǎn)生具描述性的常量度名稱，并在程序中使用該常量名稱。這使程序更易于理解也更易于維護。
56、撰寫構(gòu)造函數(shù)時，請考慮異常狀態(tài)。*情境下，構(gòu)造函數(shù)不執(zhí)行任何會擲出異常的動作。
次佳情境下，class 只繼承自（或合成自）強固的（robust）classes，所以如有任何異常被擲出，并不需要清理。其他情況下，你就得在finally子句清理合成后的classes。如果某個構(gòu)造函數(shù)一定會失敗，適當?shù)膭幼骶褪菙S出異常，使調(diào)用者不至于盲目認為對象已被正確產(chǎn)生而繼續(xù)執(zhí)行。
57、如果你的class需要在”客戶程序員用完對象”后進行清理動作，請將清理動作，放到單一而定義明確的函數(shù)中。*令其名稱為cleanup() 以便能夠?qū)⒂猛靖嬖V他人。此外請將boolean旗標放到class中，用以代表對象是否已被清理，使finalize()得以檢驗其死亡條件（請參考第 4章）。
58、finalize() 只可用于對象死亡條件的檢驗（請參考4章），俾有益于調(diào)試。
特殊情況下可能需要釋放一些不會被垃圾回收的內(nèi)存。因為垃圾回收器可能不會被喚起處理你的對象，所以你無法使用finalize()執(zhí)行必要的清理動作?；谶@個原因，你得擬定自己的”清理用”函數(shù)。在class finalize()中，請檢查確認對象的確已被清理，并在對象尚未被清理時，擲出衍生自Runtime Exception 的異常。使用這種架構(gòu)前，請先確認finalize()在你的系統(tǒng)上可正常動作（這可能需要調(diào)用System.gc()來確認）。
59、如果某個對象在某個特定范圍（scope）內(nèi)必須被清理（cleaned up）,而不是被垃圾回收機制收回，請使用以下方法；將對象初始化，成功后立刻進入擁有finally子句的一個try區(qū)段內(nèi)。Finally子句會引發(fā)清理動作。
60、當你在繼承過程中覆寫了finalize(),請記得調(diào)用super. Finalize()。
但如果你的”直接上一層”是Object，，就不需要這個動作。你應(yīng)該讓super.finalize() 成為被覆寫（）之finalize()的*一個動作而不是*個動作，用以確保base class的組件在你需要它們的時候仍然可用。
61、當你撰寫固定大小的對象容器，請將它們轉(zhuǎn)換為數(shù)組–尤其是從某個函數(shù)返回此一容器時。
通過這種方式，你可以獲得數(shù)組的”編譯期型別檢驗”的好處，而且數(shù)組接收者可能不需要”先將數(shù)組中的對象加以轉(zhuǎn)型”便能加以使用。請注意，容器庫的base class (Java. Util. ) 具有兩個toArray()，能夠達到這個目的。
62、在interface(接口)和abstract class(抽象類)之間，優(yōu)先選擇前者。
如果你知道某些東西即將被設(shè)計為一個base class,你的*選擇應(yīng)該是讓它成為interface;只有在一定得放進函數(shù)或數(shù)據(jù)成員時，才應(yīng)該將它改為abstract class. Interface只和”客戶端想進行什么動作”有關(guān)，class則比較把重心放在實現(xiàn)細節(jié)上。
63、在構(gòu)造函數(shù)中只做惟一必要動作：將對象設(shè)定至適當狀態(tài)。
避免調(diào)用其他函數(shù)（除了final函數(shù)），因為這些函數(shù)可能會被其他人覆寫因而使你在建構(gòu)過程中得不可預(yù)期的結(jié)果（請參考第7章以取得更詳細的信息）。小型而簡單的構(gòu)造函數(shù)比較不可能擲出異常或引發(fā)問題。
64、為了避免一個十分令人泄氣的經(jīng)驗，請確認你的classpath中的每個名稱，都只有一個未被放到packages里頭class。否則編譯器會先找到另一個名稱相同的class，并回報錯誤消息。如果你懷疑你的classpath出了問題，試著從classpath中的每個起點查找同名的.class文件。*還是將所有classes都放到packages里頭。
65、留意一不小心犯下的重載（）錯誤。
如果你覆寫base class 函數(shù)時沒有正確拼寫其名稱，那么便會增加一個新的函數(shù)，而不是覆寫原有的函數(shù)。但是情況完全合法，所以你不會從編譯器或執(zhí)行期系統(tǒng)得到任何錯誤消息–你的程序代碼只是無法正確作用，如此而已。
66、當心過早*化。
先讓程序動起來，再讓它快–但只有在你必須（也就是說只有在程序被證明在某段程序代碼上遭遇效能瓶頸）時才這么做。除非你已經(jīng)使用效能量測工具（profiler）找出瓶頸所在，否則你可能性只是在浪費你的時間。效能調(diào)校的”隱藏成本”便是讓你的程序代碼變得更不可讀、更難維持。
67、記住，程序代碼被閱讀的時間多于它被撰寫的時間。
清晰的設(shè)計能夠制作出去易懂的程序。注解、細節(jié)說明、示例都是無價的。這些東西能夠幫助你和你的后繼者。如果沒有其他信息，那么Java 線上文檔找出一些有用的信息時，你所遭遇的挫敗應(yīng)該足以讓你相信這一點。
