編輯距離java

⑴ java實現輸入兩個XML文檔,輸出它們的相似度

publicclasstest{

/**
*我們把兩個字元串的相似度定義為：將一個字元串轉換成另外一個字元串的代價（轉換的方法可能不唯一），轉換的代價越高則說明兩個字元串的相似度越低。比如兩個字元串：「SNOWY」和「SUNNY」，下面給出兩種將「SNOWY」轉換成「SUNNY」的方法：
變換1：
S-NOWY
SUNN-Y
Cost=3（插入U、替換O、刪除W）
變換2：
-SNOW-Y
SUN--NY
Cost=5（插入S、替換S、刪除O、刪除W、插入N）
用d[i,j]表示source[1..i]到target[1..j]之間的最小編輯距離，則計算d[i,j]的遞推關系可以這樣計算出來：
如果source[i]等於target[j]，則：
d[i,j]=d[i,j]+0（遞推式1）
如果source[i]不等於target[j]，則根據插入、刪除和替換三個策略，分別計算出使用三種策略得到的編輯距離，然後取最小的一個：
d[i,j]=min(d[i,j-1]+1，d[i-1,j]+1，d[i-1,j-1]+1)（遞推式2）
d[i,j-1]+1表示對source[i]執行插入操作後計算最小編輯距離
d[i-1,j]+1表示對source[i]執行刪除操作後計算最小編輯距離
d[i-1,j-1]+1表示對source[i]替換成target[i]操作後計算最小編輯距離
*@paramargs
*/
publicstaticvoidmain(String[]args){
//TODOAuto-generatedmethodstub
Stringsource="SUNNY";
Stringtarget="hgjdSUN";
inti=0;

//i=EditDistanceChange(source,target);
i=EditDistance(source,target);
System.out.println("需要"+i+"次");
}

//動態規劃法
privatestaticintEditDistance(Stringsource,Stringtarget)
{
char[]s=source.toCharArray();
char[]t=target.toCharArray();
intslen=source.length();
inttlen=target.length();
intd[][]=newint[slen+1][tlen+1];
for(inti=0;i<=slen;i++)
{
d[i][0]=i;
}
for(inti=0;i<=tlen;i++)
{
d[0][i]=i;
}
for(inti=1;i<=slen;i++)
{
for(intj=1;j<=tlen;j++)
{
if(s[i-1]==t[j-1])
{
d[i][j]=d[i-1][j-1];
}else{
intinsert=d[i][j-1]+1;
intdel=d[i-1][j]+1;
intupdate=d[i-1][j-1]+1;
d[i][j]=Math.min(insert,del)>Math.min(del,update)?Math.min(del,update):Math.min(insert,del);
}
}
}
returnd[slen][tlen];
}//遞歸實現---窮舉法（枚舉法）
(Stringsource,Stringtarget){
if(target.length()!=0&&source.length()==0)
{
returnEditDistanceChange(source,target.substring(1))+1;
}elseif(target.length()==0&&source.length()!=0)
{
returnEditDistanceChange(source.substring(1),target)+1;
}elseif(target.length()!=0&&source.length()!=0){
//當源字元第一個值和目標字元第一個值相同時
if(source.charAt(0)==target.charAt(0))
{
returnEditDistanceChange(source.substring(1),target.substring(1));
}else{
intinsert=EditDistanceChange(source.substring(1),target)+1;
intdel=EditDistanceChange(source,target.substring(1))+1;
intupdate=EditDistanceChange(source.substring(1),target.substring(1))+1;
returnMath.min(insert,del)>Math.min(del,update)?Math.min(del,update):Math.min(insert,del);
}
}else{
return0;
}
}
}

⑵ 用java語言， 如何實現為圖片添加邊框素材，就是把圖片和邊框素材（圖片）結合

用FrontPage2002來做吧，你點點下面的連接：

具體是：
Web頁面可用預定義模板來創建，也可不採用模板而在空白頁上自己進行設計。創建新頁面的步驟如下：
在網頁視圖下，選擇「文件」菜單中的「新建」命令，再從其子菜單中選擇「網頁」命令，將彈出「新建」對話框，如圖所示。

若用戶要新建的網頁是框架，則從「框架網頁」選項卡中選擇某種框架樣式；否則，從「常規」選項卡中選擇一種所需樣式，然後單擊「確定」按鈕。若想建立一空白網頁，可在對話框的「常規」選項卡中選擇Normal Page項，或直接單擊常用工具欄的「新建網頁」按鈕。
建議逐一試用FrontPage提供的各種模板以便熟悉它們，日後你就可以自如地利用模板創建常規Web頁面，能夠節省許多時間。
1．在網頁中插入圖形
圖片往往比大量的文字講述更具吸引力和說服力，在web頁面中適當地添加圖片會使網頁豐富多彩，但過多地加入圖片將降低頁面的下載速度，特別是對通過數據機訪問web頁的用戶。大多數圖形都是採用壓縮格式，有的數據機不具有壓縮功能，這種數據機速度更慢。因此用戶在加入圖片時，應認真選擇和進行規劃。雖然圖形可使web頁更有趣味，但應適度使用（使用較少顏色，縮小高度和寬度或裁剪圖形、降低圖形的解析度，盡可能地減少圖形文件大小，如用壓縮格式的文件類型）。
Web頁面所使用的兩種圖片格式分別為GIF和JPEG，用戶可選擇「插入」菜單中的「圖片」命令，再從其子菜單中選擇「來自文件」命令，打開「圖片」對話框，「圖片」對話框提供了「掃描」、「使用您的web例覽器來選擇網頁或文件」、「剪貼畫」和「在您的計算機上選擇一個文件」四種途徑插入圖片。
對於一些非GIF和JPEC格式的圖片，FrontPage可以自動地將這些文件轉換成GIF或JPEG格式。

2．在網頁中插入水平線

水平線可以在網頁上清晰地劃分界限，而且對用戶網頁的布局起著重要的作用。添加一條水平線，可以通過「插入」菜單中選擇「水平線」命令添加。在默認狀態下水平線是灰色的，用戶可以像改變文本顏色一樣改變水平線的顏色。改變水平線的顏色有兩種方法（必須在不加主題的情況下）：
（1）雙擊該水平線，將顯示「水平線屬性」對話框。在對話框的「顏色」項，選擇下拉列表，從中選擇合適的顏色，單擊「確定」按鈕。
（2）用滑鼠右鍵單擊這條水平線，從快捷菜單中選擇「水平線屬性」命令，再從對話框中選擇一個合適的顏色。
使用框架
--------------------------------------------------------------------------------

框架是把Web瀏覽器的視窗分成幾個部分，每個部分都是獨立的Web頁面，這樣便可同時顯示多個頁面。
可以很容易地用FrontPage創建一個多框架的web頁面。為了創建具有框架的Web頁面，可從「文件」菜單的「新建」子菜單中選擇「網頁」命令，彈出「新建」對話框，選擇「框架網頁」選項卡。
在左邊的列表中可選擇不同類型的框架模板，選定模板後，按「確定」按鈕即可創建一個具有框架的網頁。
在創建有框架的Web頁面時，應注意有些web瀏覽器不支持框架。雖然使用不能顯示框架的瀏覽器的用戶已很少，為確保這些用戶仍然能夠瀏覽到Web站點上的內容，可以填上要告訴那些低版本瀏覽器的使用者的話，例如請對方更換瀏覽器等。
在新建的框架的窗口中，單擊「設置初始頁」按鈕將會彈出「創建超鏈接」對話框，可以鏈接到一個指定頁面；單擊「新建網頁」按鈕將創建一個新頁面，然後在該頁面內對該頁進行編輯。在編輯頁面時，若感覺頁面被放在一個狹窄的框架中太擁擠，可選擇「框架」菜單中的「在新窗口中打開網頁」命令，這樣便打開一個新的滿屏窗口，可以自由地在頁面中增加內容。
利用FrontPage的框架頁面模板在Web頁面上引入了框架布局，我們還可以在此基礎上，根據需要進行進一步的設計。
1、增加新框架

要給框架頁面增加新框架，就是像拆分表格的單元格一樣，把一個框架分為兩個框架。 其操作如下：
（1）按住Ctrl鍵，將滑鼠放在框架邊框上，當滑鼠變為上下箭頭時，可把邊框拖到一個新位置，當松開滑鼠按鈕時，一個新的空白內容的框架就形成了。
（2）也可以通過命令來操作：首先單擊要拆分的框架內部，選「框架」菜單中的「拆分框架」命令，在彈出的「拆分框架」對話框中單擊「拆分成列」或「拆分成行」單選按鈕，單擊「確定」按鈕即可。

2．刪除框架

若框架頁面看起來太亂，可刪除某些框架。要刪除一個框架，可先單擊該框架選擇它，再選擇「框架」菜單中的「刪除框架」命令即可。

3．改變框架屬性

在設置好框架的整體布局後，我們還可以對每一框架的具體屬性進行設置，操作如下：
（1）單擊需設置屬性的框架，選擇「框架」菜單中的「框架屬性」，則彈出「框架屬性」對活框。

（2）在對話框的「名稱」文本框中可輸入框架名，這樣便於識別不同的框架；在「選項」區域中，若選中「在例覽器中可以調大小」復選框，則客戶在瀏覽站點時，可重新定義框架尺寸，通過在「顯示滾動條」下拉列表框中選擇不同的描述項，可設置讓滾動條是否出現。
（3）在「框架大小」區域中，可設置框架大小，可以定義一個絕對像素值或相對於瀏覽器窗口的百分比，若要用瀏覽器來設置相對於該頁面中框架的尺寸，可選「相對」；在「邊距」區域中，可設置內容頁面與框架邊框分隔的像素數值。
（4）要改變開始頁面，可以在「初始網頁」文本框中輸入一個新的頁面名字或URL。
（5）單擊「框架網頁」按鈕，則彈出「網頁屬性」對話框。
（6）在該對話框的「框架」選項卡中，在「框架間距」文本框中，可輸入以像素為單位的邊框寬度；若要使框架邊框消失，則不要選中「顯示邊框」復選框。
（7）單擊「確定」按鈕，關閉「網頁屬性」對話框，再單擊「確定」按鈕，關閉「框架屬件」對話框，完成框架屬性設置。
動態網頁

--------------------------------------------------------------------------------

DHTML是動態網頁的意思，它其實並不是一個標準的術語。事實上沒有一種技術叫作DHTML。DHTML是利用CSS(層疊樣式表)，JavaScript，HTML等技術而建立的能與訪問者產生互動的網頁。比如在動態網頁里，當訪問者單擊了某一張圖片後，這張圖片會自動的移動，這就是DHTML效果。也就是說，當網頁下載完畢後，它無需再與伺服器連接就能產生變化了。FrontPage2000提供了一套容易製作動態網頁的方法，你可以建立起屬於自己特色的動態網頁。

1、使用DHTML的基本步驟

1).在頁面點選需要使用DHTML的對象，比如文本，圖片。對於文本需要拖曳滑鼠選定；

2).在DHTML工具欄，選擇通過開啟的下拉列表選擇一種事件，文本和圖片所具有的事件是不同的；接下來再應用下拉列表選擇一種效果；最後選擇該效果的的實現方法；

3).當你為對象使用了DHTML後，保存該頁面並預覽，你會發現你選定的對象按照你設置的DHTML的效果出現；

4).如果想刪除某一個對象的DHTML效果，先選定該對象，然後單擊DHTML工具欄上的刪除效果圖標即可。

2、DHTML的事件

在DHTML製作中，我們聽得最多的是「事件」這個術語。什麼是「事件」呢，顧名思義，就是發生的一件事情，比如你用手打開門，那麼這就是一個事件。換到網頁製作中，開門變成了單擊，也就是說，訪問者單擊了一個鏈接，那麼出現了事件的結果，門被打開了。

在FrontPage2000中，當我們打開DHTML效果工具欄後，點選文本或者圖片會產生不同事件。但它們的施用方法是一樣的，下面我們以文本舉例：

我們先在編輯器里輸入一段文本，比如：網頁陶吧，然後繼續下面的三個步驟：

選定一段需要產生DHTML效果的文本，這里是：網頁陶吧。從DHTML效果工具欄的開啟下拉列表選擇一個事件。這里對於文本我們只有「網頁載入」這個事件。「網頁載入」就是當網頁第一次裝入的時侯發生的事件，它不需要用戶利用滑鼠去觸發它，而只需要訪問者利用瀏覽器打開它的時侯就會產生預設的動態效果。

選擇好事件後，我們要在應用下拉列表裡選擇一個該事件的應用效果。在該列表下有七種可以採用的效果，我們選擇飛入。

對於應用效果會有不同的方法產生。比如當你選擇的應用效果是「飛入」的時侯，文本可以從底部飛入，可以從左邊飛入，也可以從右邊飛入，這些就是方法。在這個下拉列表裡並沒有註明這個術語。有的應用效果是沒有方法的，比如波動。我們這里選擇從底部飛入。

最後保存該頁面並預覽，你會發現網頁陶吧這個四個字在網頁第一次載入後從底部飛入。當然，你也可以嘗試其它DHTML效果。對於選定圖片，你會在DHTML效果工具欄的開啟下拉列表看到新的事件，單擊和滑鼠懸停，它們會有各自的應用效果和實現方法。你可以每一個嘗試一下，這樣你就能明白這些事件和應用效果和方法之間的關系。

3、DHTML的小技巧

DHTML兼容性

利用FrontPage2000製作的DHTML網頁只能被InternetExplorer4.0或以上版本完全正常瀏覽。對於圖片的DHTML效果，Netscape Communicator 4.0或以上版本也可以瀏覽。

禁止DHTML

如果想禁用DHTML效果，點選菜單工具/網頁選項，在打開的對話框里選擇兼容性標簽，取消動態HTML前的復選框里勾，這樣DHTM效果被禁用。

快速使用DHTML

一般情況，在你沒有選定某一個對象的情況下，你只需要把滑鼠移動到對象的左邊或者右邊單擊一下就可以使用DHTML效果了。

4、網頁過渡

網頁過渡是指當你進入或者離開一個網頁的時侯所產生的效果的這個過程。比如你從某一頁進入另一頁，你會發現當前頁慢慢向中間合攏，同時出現了另一個新的頁面，直到當前頁合攏消失而最後出現新的頁面。如果你想使用網頁過渡，可以按照以下步驟：

1).打開想使用過渡效果的頁面，或者新建立一個頁面。點選菜單格式/網頁過渡，打開網頁過渡對話框；

2).在事件下拉列表裡選擇一個事件，我們選擇進入網頁。大家要注意，當你為某頁和站點都設置了過渡效果時，網頁將比站點過渡效果優先；

3).在周期文本框里輸入持續的時間，然後在過渡效果列表框里點選一個效果，單擊確定。利用瀏覽器打開該頁面，因為我們選擇的網頁過渡是進入網頁，所以當你打開該頁時你就能看到過渡效果了。

利用DHTML效果的確是吸引訪問者的有力利器，但如果你不願意和復雜的代碼打交道，那麼FrontPage2000為你預設了許多DHTML的效果。你要做的僅僅是選定需要動態效果的對象，比如文字，圖片，然後利用「傻瓜」式的操作就可以讓你的網頁動起來。
Web頁有自己的一組屬性，通過選擇「文件」菜單中的「屬性」或通過滑鼠右鍵單擊頁內任何位置，選擇快捷菜單中的「網頁屬性」命令，可以打開「網頁屬性」對話框，在「常規」選項卡中，各項設置含義如下：

·位置：指出頁的完整URL。

·標題：顯示的頁標題，即在HIML中顯示在<head>元素中的<tit1e>標簽內。

·基位置：在此位置可輸入一個URL，可將這頁中使用的相對URL的超鏈接總指向同一正確的目標，通過對一個URL的說明，可以在不移動相對URL中所有目標的情況下，移動這個頁。

·默認的目標框架：定義不規定框架的頁中所有超鏈接的默認框架。

·背景音樂：加入背景音樂，當瀏覽器打開該頁時，會同時播放音樂。

在其它選項卡中還可對頁邊距、語言等系統參數進行設置。
建立超鏈接

--------------------------------------------------------------------------------

超鏈接（HyperLink）的出現使網上瀏覽變得更加便捷，只須用滑鼠輕輕點擊，便能輕松地從一個頁面跳轉到另一個頁面，從一個Web站點跳到另一個Web站點，從一個國家跳到另一個國家。超鏈接就是一些特殊的文本或圖像，是其它頁面的入口。
1．與當前web站點的頁面建立超鏈接
（1）在FrontPage中打開要建立超鏈接的頁面（若是新建頁面，則要肯定該頁面己被保存），選中超鏈接源，超鏈接源可以是一個字元、一個單詞、一句話或一幅圖片等。
（2）選擇「插入」菜單中的「超鏈接」命令，或單擊「常用」工具欄的「超鏈接」按鈕，則彈出「創建超鏈接」對話框（如圖），在該對話框中列出了當前FrontPage中打開的Web站點中的文件夾和文件。

（3）在該對話框的文件列表中，選擇要建立鏈接的目標文件。
（4）單擊「確定」按鈕，超鏈接建成。

2．與本機中的其它文件建立超鍵接
（1）選擇超鏈接源，打開「創建超鏈接」對話框。
（2）在該對話框中單擊「製作一個鏈接到您計算機上文件的超鏈接」按鈕，然後從彈出的對話框中找到自己所要鏈接的文件，選中它。
（3）單擊「確定」按鈕，超鏈接建成。

3．與world wide web上某一站點建立超鏈接
（1）在FrontPage中打開欲建超鏈接的頁面，選定超鏈接源。
（2）選「插入」菜單中的「超鏈接」或單擊常用工具欄的「超鏈接」按鈕，彈出「創建超鏈接」對話框。
（3）在「URL」文本框中，輸入超鏈接目標的URL。
（4）單擊「確定」按鈕。
格式化文本

--------------------------------------------------------------------------------

1．輸入文本
從總體而言，文本仍是網頁中的主體內容，在FrontPage中輸入文本與在Word中輸入文本非常類似。
(1).需要加入空行或換段時才使用Enter鍵，當輸入文本達到所定義的右邊界時，將自動換行。若錄入文字有錯可按Backspace鍵清除錯誤，重新錄入。
(2).可在文本中任意位置處插入新文本內容，操作時把滑鼠指針定位到欲加文本處即可添加文本。
(3).可進行覆蓋式錄入，即先用滑鼠選中要替換的文本，然後直接錄入文本。
(4).可通過單擊常用工具欄的「顯示所有」按鈕，讓段落標記在屏幕上顯示或隱藏，藉助段落標記可清楚地看到段與段之間的空行。

2．文本的選擇

(1).選擇一個單詞或多個單詞：選擇一個單詞只需在該單詞上雙擊滑鼠即可，按住滑鼠左鍵在要選單詞上拖動即可選擇多個單詞。選擇字與選擇多個單詞的方法相同。
(2).選擇一行文字：一行文字就是在屏幕上占據一行空間的文本。將滑鼠箭頭移到行的最左邊，當游標箭頭變為指向左邊時，單擊滑鼠左鍵，便可選擇該行。
(3).選擇一個段落：將滑鼠箭頭移到該段落的最左邊，當游標箭頭變為指向左邊時，雙擊滑鼠左鍵，或按下ALT鍵，再用滑鼠單擊想要選擇的段落，即可選擇該段落。

3．刪除、拷貝和移動文本或圖片

(1).刪除：刪除插入點左側的一個字元，按Backspace鍵；刪除插入點右側的一個字元，按Delete鍵；刪除插入點右側的一個單詞，按Ctrl＋De1ete鍵；剪切所選內容並保行到「剪貼板」，按Ctrl＋X鍵；刪除所選內容按De1e1e鍵或選擇「編輯」菜單中的「刪除」命令。
(2).拷貝：拷貝所選文本或圖形到剪貼板，方法是：選中文本或圖形，然後按Ctrl+C鍵或從菜單上選擇「編輯」菜單中的「復制」菜單命令，也可直接單擊工具欄中的「復制」按鈕。
(3).移動文本或圖片：選擇想要移動的文本或圖片，再拖曳到要插入的位置，釋放滑鼠，所選對象就移到目的地。如果先將選擇的文本或圖片「剪切」，然後再「粘貼」到指定區域，也可將其移動。
(4).通過「撤銷」取消誤操作：如果用戶在不小心的情況下錯誤地執行操作，單擊工具欄上的「撤銷」命令按鈕，可以取消用戶執行過的操作，或從菜單欄選擇「編輯」菜單中的「撤銷」菜單命令，或按Cir1＋Z鍵。

4．加入標題

出於頁面內容層次的需要，有時在頁面中要加入一些小標題。 HTML語言規范採用6級標題，各級標題採用文字不同字型大小來區分，其中標題1為大標題，其它依次為中小標題。要設定某一級標題，可以在FrontPage格式工具欄中的「樣式」下拉列表中選中一個標題等級，然後在游標處輸入標題文字即可；或者先輸入文字，並選定該文字，然後在「樣式」下拉列表中選定某一級標題。標題結束後，將下拉列表中的格式改回原來的「普通」，再進行其它內容的輸入。

5．改變字體及設置字體效果
FrontPage在通常情況下，字體為「Times New Roman」。若用戶的操作系統是中文Windows95／98或Windows NT，中文默認字體為「宋體」，文字大小採用默認的字型大小。若要設定不同的字體，可先選擇要改變的文字，然後在格式工具欄里的「字體」下拉菜單中選擇一種字體，或從菜單欄選擇「格式」菜單中的「字體」菜單命令，通過「字體」對話框來設置，並可設定字體樣式、大小等。當字體改變後，形式將一直保持，直到用戶又重新設置新的字體為止。
(1).設置字體顏色：選中文字，單擊格式工具欄上的「文本顏色」按鈕的下拉箭頭，就會彈出其下拉列表，在「標准顏色」中選擇所需顏色；若沒有，可選擇「更多的顏色」命令，然後從彈出的對話框中選擇。
(2).設置字體樣式：要對需要的文字進行粗體、斜體和下劃線處理，只要選擇要處理的文字，從格式工具欄上單擊「加粗」、「斜體」或「下劃線」按鈕即可。想解除此效果，可以選中文字，再次按相應的按鈕就可以解除效果，恢復到正常字體。在製作網頁時，一般不採用「下劃線」效果，因為下劃線在一些網頁中都表示有超鏈接。
(3).字體加線效果：共有兩種:「下劃線」可以在選中的文字下面劃一條線；「刪除線」在文字中間貫穿劃一條線。
(4).特殊的文字風格：當選中的文字需要使用某些特殊風格，如「閃爍」風格，可通過選擇「字體」對話框中「字體」選項卡（如圖）的「效果」區域的所需選項，但有的文字特殊效果只有在瀏覽器中才能體現出來。

6．文本的縮進
文本的縮進就是使文本左邊、右邊顯示空白，這種效果有利於對關鍵段落加強說明。要對一個已有的段落運用縮進的方式，首先選中段落，然後在格式工具欄上單擊「增加縮進」按鈕，段落左邊和右邊分別縮進一段距離，連續按「增加縮進」按鈕，縮進將進一步加大。這種在文字兩邊同時縮進的方式也稱之為雙向縮進。若縮進的空間太大，可以通過單擊「減少縮進」按鈕來減少縮進的空間。

7．文本對齊方式
若輸入的文字是從該頁的左邊距開始，並逐漸向右延伸，且到了行滿以後又折回下行左邊（左邊距處）重新開始，這就是左對齊。有些文字需要居中方式，比如標題之類的文字；而有些文字需要放到右邊，這些可通過格式工具欄上的「向左對齊」、「居中」和「向右對齊」按鈕來實現：，不同的對齊方式可以使文本呈現不同的顯示樣式，而且可以清楚地表明用戶想要說明的問題，使網頁整體保持協調。 要設定文本的居中、左齊或右齊方式，須先選擇好要設置的文本，再單擊相應按鈕即可。如果用戶想回到原始狀態的對齊的方式，應先選定該文本，再單擊格式工具欄上相應的對齊按鈕。

8、加入項目符號或列表編號

有一些列表前面有加圓點的符號，說明一條條的列表內容，這在專業排版中稱為項目符號，在Web頁面中加入項目符號或列表編號可使內容有條理、更清楚，可以通過列表把大量內容簡要地描述出來，便於讀者抓住重點。還有另外一種形式即列表編號，可以用來描述一個問題的處理步驟和順序，這兩種處理形式在FrontPage中運用起來很方便。
加入項目符號或列表編號與在Word中的操作很類似。先選定文本，用戶可以在格式工具欄按相應的按鈕，或選「格式」菜單中的「項目符號和編號方式」命令，打開項目符號和編號方式對話框（如圖），從中選定不同格式的列表項目。

在FrontPage中新建的兩個文本行之間都有一個空行，如果用戶在輸入或添加項目時不想每兩行之間都出現一個空行，可以在格式工具欄上單擊「項目符號」或「編號方式」按鈕。該按鈕為下凹狀後同時出現第一個項目符號，輸入需要的文字後，按「回車」鍵，然後在自動出現的下一個項目符號後繼續輸入。
FrontPage還可以通過提供列表編號或項目符號的方式對列表項進行排列。操作方法與上一段所述相同。
如果在所有項目輸入完畢後，以下的內容不再希望添加編號或項目符號，可兩次回車，則停止編號或停止添加項目符號。若想改變編號的形式或不想從1開始，可通過在列表符號上單擊滑鼠右鍵，在彈出的快捷菜單上選擇「列表屬性」命令，在彈出的「列表屬性」對話框中選擇「號碼」選項卡，選擇所需的編號風格，再在右邊的「初始號碼」微調器中調整起始編號，在調好之後單擊「確定」按鈕即可。

⑶ 如何在php中使用用JAVA實現的演算法

PHP也有很多自帶的函數啊，下載一本手冊來查一查唄。明白了演算法，換一種語言來實現還是不太困難的

⑷ Java程序員的職業規劃是什麼

如果你是在校學生，務必要在學好基礎（比如計算機系統、演算法、編譯原理等等）的前提下，再考慮去進行下面的學習。第一部分：對於尚未做過Java工作的同學，包括一些在校生以及剛准備轉行Java的同學。

一、Java基礎首先去找一個Java的基礎教程學一下，這里可以推薦一個地址，或者你也可以參照這個地址上去找相應的視頻。學習Java基礎的時候，應該盡量多動手，很多時候，你想當然的事情，等你寫出來運行一下，你就會發現不是這么回事兒，不信你就試試。學完以上內容以後，你應該對Java有一個基本的了解了，你可以用Java語言寫出一些簡單的程序，並且你用的是最簡單的編輯器，比如記事本。這個時候，不要急於進入下一部分，留下幾天好好寫一些程序，盡可能熟悉這些基礎內容。

二、Web開發等你寫上幾天程序以後，你往往會比較迷茫，因為你寫的東西似乎看起來毫無用處，比如實現一個簡單的計算器，讀取一個文件等。這個時候你就應該去學著寫一些讓你覺得有意思的東西了，所以你應該學習更多的知識。這些內容主要是Web開發相關的內容，包括HTML/CSS/JS（前端頁面）、Servlet/JSP（J2EE）以及Mysql（資料庫）相關的知識。它們的學習順序應該是從前到後，因此最先學習的應該是HTML/CSS/JS（前端頁面），這部分內容你可以去上面的那個runoob網站上找。

你可以試著自己寫一些頁面，當然，你可以盡你最大的努力讓它變得最漂亮。這部分內容對於後端Java來說，理論上不是特別重要，但至少要達到可以自己寫出一些簡單頁面的水平。接下來，你需要學習的是Servlet/JSP（J2EE）部分，這部分是Java後端開發必須非常精通的部分，因此這部分是這三部分中最需要花精力的，而且這個時候，你要學會使用開發工具，而不能再使用記事本了，可以選擇eclipse。當你下載安裝好eclipse以後，請視頻中的教程一步一步去學習，一定要多動手。關於Servlet/Jsp部分視頻的選擇，業界比較認可馬士兵的視頻，因此推薦給大家。

當然了，我本人並沒有看過他的視頻，所以不好說的太絕對，如果大家自己有更好的選擇，可以堅持自己的，不要被我干擾。原本我也是打算出教學視頻的，但是由於時間問題，還是決定放棄了。但是如果你看視頻的過程中遇到了問題，歡迎來我的交流群提問，或者去斗魚觀看我的直播提出你的問題，直播地址和群號都在我的個人博客左側。最後一步，你需要學會使用資料庫，mysql是個不錯的入門選擇，而且Java領域里主流的關系型資料庫就是mysql。這部分一般在你學習Servlet/Jsp的時候，就會接觸到的，其中的JDBC部分就是資料庫相關的部分。你不僅要學會使用JDBC操作資料庫，還要學會使用資料庫客戶端工具，比如navicat，sqlyog，二選一即可。

三、開發框架當你學會以上內容以後，這個時候你還不足以參加工作，你還需要繼續深造。公司里為了提高開發的效率，會使用一些Java Web框架，因此你還需要學習一些開發框架。目前比較主流的是SSM框架，即spring、springmvc、mybatis。你需要學會這三個框架的搭建，並用它們做出一個簡單的增刪改查的Web項目。你可以不理解那些配置都是什麼含義，以及為什麼要這么做，這些留著後面你去了解。

但你一定要可以快速的利用它們三個搭建出一個Web框架，你可以記錄下你第一次搭建的過程，相信我，你一定會用到的。還要提一句的是，你在搭建SSM的過程中，可能會經常接觸到一個叫maven的工具。這個工具也是你以後工作當中幾乎是必須要使用的工具，所以你在搭建SSM的過程中，也可以順便了解一下maven的知識。在你目前這個階段，你只需要在網路上了解一下maven基本的使用方法即可，一些高端的用法隨著你工作經驗的增加，會逐漸接觸到的。

關於學習SSM框架的地址給大家推薦一個，這裡面有視頻，大家可以去觀看。四、找工作當你完成開發框架的學習以後，你就該找工作了，在校的找實習，畢業的找全職。與此同時，在找工作的同時，你不應該停下你的學習，准確的說，是你在以後都不能停下學習。上面這些內容你只是囫圇吞棗的學會了使用，你可以逐步嘗試著去了解更多的東西，網路是你最重要的老師。

第二部分：對於參加工作一年以內的同學。恭喜你，這個時候，你已經擁有了一份Java的工作。這個階段是你成長極快的階段，而且你可能會經常加班。但是加班不代表你就可以鬆懈了，永遠記得我說的那句話，從你入行那一刻起，你就要不停的學習。在這一年裡，你至少需要看完《Java編程思想》這本書。這本書的內容是幫助你對於Java有一個更加深入的了解，是Java基礎的升級版。這本書很厚，當初看這本書，我花了整整三個月。正常速度的話，應該可以在半年左右看完。我這里不要求過高，只要你在一年以內把這本書看完即可。當然了，我所說的看完，是充分吸收，而不是讀一遍就完事了，因此有些內容你可能會看不止一遍。總而言之，這個階段的核心學習思想就是，在工作中實踐，並且更加深入的了解Java基礎。

第二部分：對於參加工作1年到2年的同學。這部分時間段的同學，已經對Java有了一個更加深入的了解。但是對於面向對象的體會可能還不夠深刻，編程的時候還停留在完成功能的層次，很少會去考慮設計的問題。於是這個時候，設計模式就來了。我當時看的是《大話設計模式》這本書，並且寫了完整版的設計模式博客。因此，我要求大家，最多在你工作一年的時候，必須開始寫博客，而設計模式就是你博客的開端。

請記住，我所提的基本都是最低要求，因此不要有任何鬆懈的心理，否則五年後，你不要去羨慕別人高於你的工資，也不要去羨慕別人進入了某公司。這一年，你必須對於設計模式了如指掌，《大話設計模式》可以作為你的開端。此外，設計模式並不是你這一年唯一的任務，你還需要看一些關於代碼編寫優化的書。比如《重構 改善既有代碼的設計》，《effective java》。總而言之，這個階段，你的核心任務就是提高你的代碼能力，要能寫出一手優雅的代碼。

第三部分：對於參加工作2年到3年的同學有的同學在這個時候覺得自己已經很牛逼了，於是忍不住開始慢慢鬆懈。請記住，你還嫩的多。這個階段，有一本書是你必須看的，它叫做《深入理解Java虛擬機》。這本書絕對是Java開發者最重要的書，沒有之一。在我眼裡，這本書的重要性還要高於《Java編程思想》。這本書的內容是幫助你全面的了解Java虛擬機，在這個階段，你一定已經知道Java是運行在JVM之上的。所以，對於JVM，你沒有任何理由不了解它。

另外，在過去2年的工作當中，你肯定或多或少接觸過並發。這個時候，你應該去更加深入的了解並發相關的知識，而這部分內容，我比較推薦《Java並發編程實戰》這本書。只要你把這本書啃下來了，並發的部分基本已經了解了十之六七。與此同時，這個階段你要做的事情還遠不止如此。這個時候，你應該對於你所使用的框架應該有了更深入的了解，對於Java的類庫也有了更深入的了解。

因此，你需要去看一些JDK中的類的源碼，也包括你所使用的框架的源碼。這些源碼能看懂的前提是，你必須對設計模式非常了解。否則的話，你看源碼的過程中，永遠會有這樣那樣的疑問，這段代碼為什麼要這么寫？為什麼要定義這個介面，它看起來好像很多餘？由此也可以看出，這些學習的過程是環環相扣的，如果你任何一個階段拉下來了，那麼你就真的跟不上了，或者說是一步慢步步慢。而且我很負責的告訴你，我在這個階段的時候，所學習的東西遠多於這里所羅列出來的。

因此千萬不要覺得你已經學的很多了，我所說的這些都只是最低要求，不光是我，很多人在這個時間段所學習的內容都遠超本文的范圍。如果你不能跟上節奏的話，若干年後，如果不是程序猿市場還不錯的話，你很可能不僅僅是工資比別人低，公司沒別人好，而是根本就找不到工作。總而言之，這個階段，你需要做的是深入了解Java底層和Java類庫（比如並發那本書就是Java並發包java.concurrent的內容），也就是JVM和JDK的相關內容。而且還要更深入的去了解你所使用的框架，方式比較推薦看源碼或者看官方文檔。另外，還有一種學習的方式，在2年這個階段，也應該啟用了，那就是造輪子。不要聽信那套「不要重復造輪子」的論調，那是公司為了節省時間成本編造出來的。重復造輪子或許對別人沒有價值，因為你造的輪子可能早就有了，而且一般情況下你造出來的輪子還沒有現存的好。

但是對別人沒有價值，不代表對你自己沒有價值。一個造輪子的過程，是一個從無到有的過程。這個過程可以對你進行系統的鍛煉，它不僅考察你的編碼能力，還考察你的框架設計能力，你需要讓你的輪子擁有足夠好的擴展性、健壯性。而且在造輪子的過程中，你會遇到各種各樣的難題，這些難題往往又是你學習的契機。當你把輪子造好的時候，你一定會發現，其實你自己收獲了很多。所以，這個階段，除了上面提到的了解JVM、JDK和框架源碼以外，也請你根據別人優秀的源碼，去造一個任何你能夠想像出來的輪子。

第四部分：參加工作3年到4年的同學這個階段的同學，提升已經是很難了，而且這個階段的學習往往會比較多樣化。因為在前3年的過程中，你肯定或多或少接觸過一些其它的技術，比如大數據、分布式緩存、分布式消息服務、分布式計算、軟負載均衡等等。這些技術，你能精通任何一項，都將是你未來面試時巨大的優勢，因此如果你對某一項技術感興趣的話，

這個時候可以深入去研究一下。這項技術不一定是你工作所用到的，但一定是相關的。而且在研究一門新技術時，切忌朝三暮四。有的同學今天去整整大數據，搞搞Hadoop、hbase一類的東西。過不了一段時間，就覺得沒意思，又去研究分布式緩存，比如redis。然後又過不了一段時間，又去研究分布式計算，比如整整Maprece或者storm。結果到最後，搞得自己好像什麼都會一樣，在簡歷上大言不慚的寫上大數據、分布式緩存、分布式計算都了解，其實任何一個都只是浮於表面。到時候面試官隨便一問，就把你給識破了。

一定要記住，作為一個程序猿，平日里所接觸的技術可能會很多，但是想要讓一門技術成為你的優勢，那麼一定是你對這門技術的了解強過絕大多數人才行。因此在這個階段，你就不能再簡單的去學習前3年的內容了，雖然前面的學習如果還不夠深入的話依舊要繼續，但這個時候你應該更多的考慮建立你的優勢，也可以稱為差異性。差異性相信不難理解，就是讓你自己變得與眾不同。你前面三年的學習足夠你成為一名基本合格的Java開發者，但你離成為一名優秀的Java開發者還有很大的距離。

所謂優秀，即能別人所不能。而你前三年所學習的內容，是很多做過幾年的Java開發都能夠掌握的。那麼為了讓自己有差異性，你就需要另闢蹊徑，找一個方向深入研究下去，以期在將來，你能夠成為這個領域的專家，比如分布式計算領域的專家，大數據領域的專家，並發領域的專家等等。此外，你除了建立你的差異性之外，還要去彌補你基礎上的不足，直到現在，我都沒有提及基礎知識。原因是基礎是很枯燥無味的，學的太早不僅容易懵逼，而且懵逼的同時還容易產生心理陰影，以至於以後再不想去研究這些基礎。但基礎又是你深入研究一些領域時所必須掌握的，比如你去研究分布式計算，你不懂演算法你玩個毛毛？比如你去做分布式緩存，你對計算機系統的內存不了解，你如何去做緩存？

如果你的基礎本來就非常強，那麼恭喜你，相信你在之前的工作中已經充分體會到了這些基礎對你的幫助。但我相信大部分人的基礎都很薄弱，哪怕是科班畢業的人，很多人也不敢說自己當初的基礎學的多麼強大，比如演算法、計算機系統原理、編譯原理這些。但是每個人時間都是有限的，而且這些基礎的書籍每一本讀下來，沒個一年半載的，還真拿不下來，因此還是要有所抉擇的。雖然藝多不壓身，但問題是藝多是有代價的，是需要你付出時間和精力的，而我個人更贊成在同等代價的情況下獲取最大的收獲。

首先，我比較推崇的基礎書籍有三本，分別是《深入理解計算機系統》，《tcp/ip詳解 卷一、二、三》，《數據結構與演算法》。其中TCP/IP有三本書，但我們這里把這三本看成是一本大書。這三本分別適合三種人，《深入理解計算機系統》比較適合一直從事Java Web開發和APP後端開發工作的人群。《tcp/ip詳解 卷一、二、三》比較適合做網路編程的人群，比如你使用netty去開發的話，那麼就要對TCP/IP有更深入的了解。而《數據結構與演算法》這本書，則比較適合做計算研究工作的人，比如剛才提到的分布式計算。另外，我要強調的是，這里所說的適合，並不是其它兩本對你就沒有用。比如你做Java Web和APP後端開發，《tcp/ip詳解 卷一、二、三》這本書對你的作用也是很大的。這里只是分出個主次關系而已，你要是時間足夠的話，能把三本都精讀那當然最好不過了。

但如果時間有限的話，那麼就先挑對你幫助最大的書去讀。理論上來講，這一年你能把這三本其中一本精讀下來，就已經非常厲害了。有了基礎，有了前面的工作經驗，你就可以去開拓屬於你的領域了。在這一年裡，一定要規劃好自己的領域，建立好自己的優勢，製造出差異性。如果你對自己的領域不夠清晰的話，隨著你工作的時間日益增多，你接觸的技術會越來越多，這個時候，你很容易被淹死在技術的海洋里，看似接觸的技術越來越多，會用的也越來越多，但你毫無優勢。有的同學可能會問，「我，我也不知道我的領域是什麼啊？怎麼辦呢？」對於這種人，我只想說，「卧槽，這還問我？要不幹脆我替你學習得了，好不好？」

第五部分：參加工作4年到5年的同學經過前面一年的歷練，相信你在自己所鑽研的領域已經有了自己一定的見解，這個時候，技術上你應該已經遇到瓶頸了。這個時候不要著急提高自己的技術，已經是時候提高你的影響力了，你可以嘗試去一些知名的公司去提高你的背景，你可以發表一些文章去影響更多的人。當然，你也可以去Github創建一個屬於你的開源項目，去打造自己的產品。

這次的開源項目不同於之前的造輪子，你這個時候是真的要去盡量嘗試造出來真正對別人有價值的輪子。技術學到這個階段，很容易遇到瓶頸，而且往往達到一定程度後，你再深入下去的收效就真的微乎其微了，除非你是專門搞學術研究的。然而很可惜，大部分程序猿做不到這一步，那是科學家做的事情。這個時候提高影響力不僅僅是因為技術上容易遇到瓶頸，更多的是影響力可以給你創造更多的機會。程序猿在某種程度上和明星很像，一個好的電視劇和電影就可以成就一批明星，程序猿有的時候也是，一個好的項目就可以成就一群程序猿。比如國內幾個膾炙人口的項目，像淘寶、支付寶、QQ、網路、微信等等。這每一個項目，都成就了一批程序猿。我敢說，這裡面任何一個項目，如果你是它的核心開發，光是這樣一個Title，就已經是你非常大的優勢。更何況還不止如此，Title說到底也是個名頭，更重要的是，這種項目在做的時候，對你的歷練一定也是非常給力的。

而你如果想要參與這樣的項目，除了靠運氣之外，影響力也是很重要的一個手段。比如你在分布式計算領域有一定的影響力，那麼如果有什麼好的關於分布式計算的項目，對方就很可能會邀請你。就算人家不邀請你，你自己主動去面試的時候，對方如果知道你在這個領域的影響力，也肯定會起到很大的作用，而這個作用，甚至可能會超過你現在的技術能力。所以，在這個階段，你最大的任務是提高自己的影響力，為自己未來的十年工作生涯那一天做准備。如果你能夠靠你的影響力和以前積累的技術，參與到一個偉大的項目當中，那麼你後面的五年也就有著落了。當然了，我現在滿打滿算，做程序猿也就4年半不到，因此關於4年到5年這一部分，我的見解不一定是對的，就算是對的，也不一定是適合任何人的。

所以，希望大家自己有的判斷力，去決定到底該如何度過這一年。結語本文到此就基本結束了，整篇文章很長，但其實主要就說了兩部分內容，一個是社招面試的准備，一個是Java生涯的學習。關於這兩部分，我已經給出了自己的見解，但是還是那句話，每個人吸收知識的時候，都要有抽取精華，去除糟粕的能力。我所說的，可能有些是對的，有些是錯的，有些是適合你的，有些是不太適合你的，你要自己能夠判斷。其實你在生活和工作當中也是一樣的，你身邊的人形形色色，有的人你喜歡，有的人你很討厭。但其實你喜歡的人也有缺點，你討厭的人也有優點。你要學會從你討厭的人身上學會他的優點，千萬不要一棒子打死，這只會讓你失去很多學習成長的機會。好了，說了這么多了，就到此為止吧

⑸ 什麼是良好的編程風格（Java編程）

首先,編程風格並不同於其他的style，目的並不是形成自己獨樹一幟的風格，而是為了讓你的程序易讀,有利於團隊合作以及別人幫你改錯。

風格是通用的

C語言和C++語言的編程風格 （Java見下）

第一章:縮進格式
Tab是8個字元,於是縮進也是8個字元.有很多怪異的風格,他們將縮進格式定義為4個字元(設置為2個字元!)的深度,這就象試圖將PI定義為3一樣讓人難以接受.
理由是:縮進的大小是為了清楚的定義一個塊的開始和結束.特別是當你已經在計算機前面呆了20多個小時了以後,你會發現一個大的縮進格式使得你對程序的理解更容易.
現在,有一些人說,使用8個字元的縮進使得代碼離右邊很近,在80個字元寬度的終端屏幕上看程序很難受.回答是,但你的程序有3個以上的縮進的時候,你就應該修改你的程序.

總之,8個字元的縮進使得程序易讀,還有一個附加的好處,就是它能在你將程序變得嵌套層數太多的時候給你警告.這個時候,你應該修改你的程序.
第二章:大符號的位置
另外一個C程序編程風格的問題是對大括弧的處理.同縮進大小不同,幾乎沒有什麼理由去選擇一種而不選擇另外一種風格,但有一種推薦的風格,它是Kernighan和Ritchie的經典的那本書帶來的,它將開始
的大括弧放在一行的最後,而將結束大括弧放在一行的第一位,如下所示:
if (x is true) { we do y }

然而,還有一種特殊的情況:命名函數:開始的括弧是放在下一行的第一位,如下:
int function(int x) { body of function }

所有非正統的人會非難這種不一致性,但是,所有思維正常的人明白: (第一) K&R是___對___的,(第二)如果K&R不對,請參見第一條. (:-))......另外,函數也是特殊的,不一定非得一致.
需要注意的是結束的括弧在它所佔的那一行是空的,__除了__它跟隨著同一條語句的繼續符號.如"while"在do-while循環中,或者"else"在if語句中.如下:
do { body of do-loop } while (condition);
以及
if (x == y) { .. } else if (x > y) { ... } else { .... }
理由: K&R.

另外,注意到這種大括弧的放置方法減小了空行的數量,但卻沒有減少可讀性.於是,在屏幕大小受到限制的時候,你就可以有更多的空行來寫些注釋了.
第三章:命名系統
C是一種簡潔的語言,那麼,命名也應該是簡潔的.同MODULE-2以及ASCAL語言不同的是,C程序員不使用諸如之類的命名方式.一個C語言的程序員會將之命名為"tmp",這很容易書寫,且並不是那麼難以去理解.
然而,當混合類型的名字不得不出現的時候,描述性名字對全局變數來說是必要的了.調用一個名為"foo"全局的函數是很讓人惱火的.全局變數(只有你必須使用的時候才使用它) ,就象全局函數一樣,需要描述性的命名方式.假如你有一個函數用來計算活動用戶的數量,你應該這樣命名--"count_active_users()"--或另外的相近的形式,你不應命名為"cntusr()".
有一種稱為Hungarian命名方式,它將函數的類型編碼寫入變數名中,這種方式是腦子有毛病的一種表現---編譯器知道這個類型而且會去檢查它,而這樣只會迷惑程序員. --知道為什麼Micro$oft為什麼會生產這么多"臭蟲"程序了把!!.
局部變數的命名應該短小精悍.假如你有一個隨機的整數循環計數器,它有可能有"i",如果沒有任何可能使得它能被誤解的話,將其寫作"loop_counter"是效率低下的.同樣的,""tmp"可以是任何臨時數值的函數變數.
如果你害怕混淆你的局部變數的名字,還有另外一個問題,就是稱
function-growth-hormone-imbalancesyndrome.
第四章:函數
函數應該短小而迷人,而且它只作一件事情.它應只覆蓋一到兩個屏幕(80*24一屏),並且只作一件事情,而且將它做好.(這不就是UNIX的風格嗎,譯者注).
一個函數的最大長度和函數的復雜程度以及縮進大小成反比.於是,如果你已經寫了簡單但長度較長的的函數,而且你已經對不同的情況做了很多很小的事情,寫一個更長一點的函數也是無所謂的.
然而,假如你要寫一個很復雜的函數,而且你已經估計到假如一般人讀這個函數,他可能都不知道這個函數在說些什麼,這個時候,使用具有描述性名字的有幫助的函數.
另外一個需要考慮的是局部變數的數量.他們不應該超過5-10個,否則你有可能會出錯.重新考慮這個函數,將他們分割成更小的函數.人的大腦通常可以很容易的記住7件不同的事情,超過這個數量會引起混亂.你知道你很聰明,但是你可能仍想去明白2周以前的做的事情.
第5章:注釋
注釋是一件很好的事情,但是過多的注釋也是危險的,不要試圖區解釋你的代碼是注釋如何如何的好:你應該將代碼寫得更好,而不是花費大量的時間去解釋那些糟糕的代碼.
通常情況下,你的注釋是說明你的代碼做些什麼,而不是怎麼做的.而且,要試圖避免將注釋插在一個函數體里:假如這個函數確實很復雜,你需要在其中有部分的注釋,你應該回到第四章看看.你可以寫些簡短的注釋來註明或警告那些你認為特別聰明(或極其醜陋)的部分,但是你必須要避免過多.取而代之的是,將注釋寫在函數前,告訴別人它做些什麼事情,和可能為什麼要這樣做.
第六章:你已經深陷其中了.
不要著急.你有可能已經被告之"GUN emacs"會自動的幫你處理C的源代碼格式,而且你已經看到它確實如此,但是,預設的情況下,它的作用還是不盡如人意(實際上,他們比隨便敲出來的東西還要難看- ainfinite number of monkeys typing into GNU emacs would never make a good program)
於是,你可以要麼不要使用GUN emacs,要麼讓它使用sanervalules.使用後者,你需要將如下的語句輸入到你的.emacs文件中.(defun linux-c-mode() "C mode with adjusted defaults for use with the Linux kernel."(interactive) (c-mode) (c-set-style"K&R") (setq c-basic-offset8))

這會定義一個M-x Linux-c-mode的命令.當你hacking一個模塊的時候,如何你將-*- linux-c -*-輸入在最開始的兩行,這個模式會自動起作用.而且,你也許想加入如下
(setq auto-mode-alist (cons '("/usr/src/linux.*/.*.〖ch〗$" . linux-c-mode) auto-mode-alist))

到你的.emacs文件中,這樣的話,當你在/usr/src/linux下編輯文件的時候,它會自動切換到linux-c-mode .
但是,假如你還不能讓emaces去自動處理文件的格式,不要緊張,你還有一樣東西: "縮進" .
GNU的縮進格式也很死板,這就是你為什麼需要加上幾行命令選項.然而,這還不算太壞,因為GNU縮進格式的創造者也記得K&R的權威, (GNU沒有罪,他們僅僅是在這件事情上錯誤的引導了人們) ,你要做的就只有輸入選項"-kr -i8"(表示"K&R,縮進8個字元).
"縮進"有很多功能,特別是當它建議你重新格式你的代碼的時候,你應該看看幫助.但要記住: "縮進"不是風格很差的程序的萬靈丹.

http://www.nou.com.cn/portal/Article/itjs/jsjj/cxsj/200511/20051104115145.html

JAVA編程風格簡析

很久以來都在體會著JAVA的風格，現在做一簡單陳述，希望大家多提寶貴意見。

對於一種好的編程語言，學習它的編程風格是很重要的。每種語言都有自己的編寫和注釋約定，當然所有語言都建立在最基本的約定之上。編程中最重要的並不是讓代碼按自己希望的方式運行，而是程序中那種自明的編程風格（這對於程序員的益處相信眾多程序員都身有體會）！但這還不夠，程序還應該具有可讀、相對持久和可維護性。可讀性非常重要，因為你不希望自己以前的作品在之後的閱讀中給自己留下障礙，當然，更重要的是自己的程序能讓其他程序員讀懂並且修改。

下面我把工作中所理解的java風格做一簡單總結，這是我所理解的好的編程風格和應用中我們應當如何使用java編寫自己的代碼的小Guide。這並不完全，希望大家幫我陸續總結各自的經驗。

一般性概述
好的編程風格固然重要，但是你一定聽說過一些程序員的個人風格。其實我們完全不必為那些所謂條條框框所累，但是作為原則是我們至少不能打破這些常規。我們應該在保持自己風格的同時盡量的把自己與編程潛原則靠攏。

可讀性很容易達到，比如，讓自己的代碼縮排排列、名字採用描述性但不要過長（短名應僅僅用在非遠程）、特殊名稱比如pi應當被定義為final類型。模塊性是編程需要注意的另一重點，把代碼劃分到類里，在類中把功能劃分到方法中，別讓一個類太大，否則在使用、修改和理解上都會造成不必要的麻煩，方法也一樣，如果一個方法長度超過50行，它產生錯誤的概率將接近100％，盡量把大方法劃分為小方法，編程中為避免重復編寫，還應盡量調用JAVA標准類庫。

盡量避免在寫代碼和注釋時使用不同語言，經常見到論壇有朋友詢問諸如在java中調用c、調用php、調用shell之類的問題，其實在編程中，我們應盡量使用一種語言去完成事情。另外就是不必最優化自己的代碼，應該選擇相對較優的演算法就可以了。

類、方法和fields
類應體現出某種物質的基本概念，比如要編程實現「汽車」的組成，那麼所有的汽車都可以用類Car實現。這個類應當包括域描述、屬性描述和car的狀態（color, number of doors, age等）和由car可完成的操作（getColor, setColor等）。為了提高類的可重用性，不要在類中有過多的描述，當然這也會增加錯誤產生的機會。

類名首字母大寫，比如Date, String, Hashtable等 ... ...

類如下定義：(未使用Javadoc做注釋):

public class Car {

/* Instance variables are placed either in the beginning
or at the end of the class */

private int age;
private Color color;

/* The constructor should be placed in the beginning */

public Car(int age, Color color) {
this.age = age;
this.color = color;
}

/* Example method */
public int getAge() {
return age;
}

/* The main method is optional, but looks like this.
If it exists, it is either the first or the last
method in the class */

public static void main(String [] args) {
...

}
}

注意類名和大括弧間的空格！

方法
方法一般定義為public。當然，如果方法僅僅在當前類用到可以定義為private，而如果希望一個子類沿用這個方法則不同，這時候的方法應定義為protected。

java中的方法定義很有趣，它們一般小寫字母開頭，如果有兩個字組成，第二個字的首字母則大寫。因此名字的描述性是至關重要的。這使你不用閱讀整篇代碼來判斷這是一個什麼方法。在給自己的方法取名時應盡量不要太短或者太長，另一個需要注意的是大多方法使用動詞（動賓短語）。

例如：
public void eat() {}
public void eatBananas() {}

Selector（選擇器）方法有get前綴，後綴是它們將要get的，比如
public int getBananas() {}

Mutator（存取器）方法則有set前綴，後綴則是他們要set的，比如
public void setBananas(int amount) {}
注意mutators大多無返回值。

方法的參數應當以如下方式給出：
public void aMethod(type parameter1, type parameter2, ... , type parametern) {}

如果參數過長，也可以斷開為幾行，應對齊向下排列如：
public void aMethod(type parameter1, type parameter2,... ,
type parametern, type parameter n+1,... ,
type parameterm, type parameter m+1) {}

另外要注意類的左束括弧應在方法的右束括弧之後而非下一行:

public int aMethod() {
int i = 0;
if(i == 0)
System.out.println("success！");
}

為了文件可讀性好，還要注意語句最好寫在同一行，當然一行寫不下是可以斷行的，比如行字母超過80。

fields
比如變數，如果不希望它永久有效，應設為private。如果一個變數在類中不發生任何動作（比如數據結構中的node）則可以設置為public，常量一般聲明為public。如果不能確定一個變數到底該聲明為什麼，應暫且聲明為private。

field的名字一般使用小寫字母，不要使用下橫線或其他特殊字元。 如果變數包含兩個字，那麼第二個字的首字母大寫。比如：

int i, j, k;
Date date;
double myField;

常量一般全部大寫，也可以包含下橫線：

public static final int MAX_SIZE_OF_DATABASE

fields的名字通常為名詞。較重要的fields更應具備描述性，比如程序中包含一個游戲的得分，那可以用score來代表。如果變數變化較頻繁，那使用一個單一字元來代表就ok了：

i, j, k 通常代表整數
r, t, u, v, w 通常代表實數
x, y, z 通常是並列出現或代表浮點數
s, s1, s2, 通常代表字元串
c, ch 通常代表字元
f, file 通常代表文件
tmp, temp 通常代表臨時變數
ctr, cnt, cntr 一般代表計數器(如果i, j, k這些變數已被使用)
mmy, foo, bar 一般代表啞元變數
args 是main-method的主參數名

縮排與換行
每行長度不得超過80字元。如果需要可以折行時，也應當與上一行有共同的縮排距離。代碼應如何交錯、如何建立新行、在哪裡建立允許、哪裡不允許都有一些一般約定，縮排空格一般為2個或4個空格。

條件表達式
如果見到如下語法表達式：

if (expr)
statement1;
else
statement2;

代碼行向右錯排兩個空格如上所示。

如果在一個表達式中有超過一條的聲明，則需要大括弧:

if (expr){
statement1;
statement2;
} else{
statement3;
statement4;
}

有時我們會希望在表達式中使用表達式（比如條件嵌套），這時應注意else表達式，它的位置很容易出錯！如例：

if (expr1) {
statement1;
statement2;
} else if (expr2)
statement3;
else if (expr3) {
statement4;
statement5;
} else {
statement6;
statement7;
}

注意大括弧位置！

Loops
while-loop語法如下：

while (expr) {
statement1;
statement2;
}

for-loop語法如下：

for (expr1; expr2; expr3){
statement1;
statement2;
}

注意大括弧位置！僅一條聲明時大括弧省略：

while (expr)
statement;

for (expr1; expr2; expr3)
statement;

例如，我們寫一個procere寫出1到10這十個數字：

for (i = 1; i <= 10; i++)
System.out.println(i);

try-catch語法形如：

try {
statements;
} catch (ExceptionClass e) {
statements;
}

如果try-catch語句後跟隨finally子句則形如：

try {
statements;
} catch (ExceptionClass e) {
statements;
} finally {
statements;
}

新行
每一行最好只闡述一件事情。比如，一行包含一個聲明、一個條件語句、一個循環等。不論多小，最好不要一行辦兩件事及以上。例如不要把一個if表達式或循環語句的主體放置在同一行，這樣的表達式斷行的易讀性會更高。通常，互相協作的代碼應放在一起，為保證代碼美觀可讀，我們應將代碼的不同代碼段放置在不同的段落。不過要牢記斷行不要太過分！比如:

public int factorial(int n) {
int result = 1;
for(int i = 1; i <= n; i++)
result*=i;

return result;
}

給自己的代碼加入注釋
注釋就是類的描繪、方法存在的原因、它完成了什麼以及它對它其中（變數）的作用域。假定閱讀你代碼的人已經知道這是什麼語言，所以不需要注釋語句功能，盡量使用簡短而有描述力的注釋。

Java有兩種類型的注釋：

//This is a comment that continues until the end of the line.

/* This is a comment. It goes on and on and on and on and on and on and on
and on and on and on and on and on and on and on and on and on and on and
on and on and on and on and on and on and on and on and ends like this: */

/**
* This is a JavaDoc comment. More about JavaDoc in the next section.
*/

如果在注釋中加入注釋則會出錯：

/* You are not allowed to do anything like this /* because the compiler will
complain, if you are lucky */ DON'T DO THIS! And don't write comments in
upper case either... */

注釋應放在它要解釋內容上下，這樣會讓代碼更易於理解。

不要注釋一些語言的語句功能：
i++; // Add 1 to i

更不要讓自己的代碼處於這種狀態：

for(int i = 1; i <= n; i++)
/* don't place comments where
they don't belong */
result*=i;

較短的注釋既可被放在被注釋代碼上下，而長注釋則習慣性的放在代碼之上：

/* Comments can be placed before the
block that is to be commented */

for(int i = 1; i <= n; i++)
result*=i;

或者:
for(int i = 1; i <= n; i++){
result*=i; // short comments can be placed like this
tmp++; // if necessary, they continue here
}

不要寫沒用的注釋：

i++; // change this later

Excuse me,這句肯定是胡扯！

不要寫自己都看不懂的注釋：

i++; // BMW

BMW? 如果你能連續十天記住這是什麼意思的話，那麼你的記憶真是不錯了。所以不要寫沒人能看懂的注釋，ok？

最後重申一下：寫簡短而富於描述性的注釋，把它們放在該放的地方，而不要考驗你自己的記憶力！

JavaDoc - 文檔工具
JavaDoc不僅是另一種給代碼加註釋的彷彿咱，更是一個文檔工具。類、方法和一些重要地方需要用JavaDoc來注釋。這並不是說你可以放棄常規的注釋，這兩者在代碼中應該是相輔相成、互相彌補的關系。

類被注釋如：

/**
* Car represents cars ... A description of the class
* should be place here. Note that the description begins
* on the second line and that there is a space between
* the asterix and the text. Next we will add some fields
* indicating who the authors of the class are and
* other useful information. Notice the newline!
*
* @author Jerry Meng
* @version %I%, %G%
*/
public class Car {

注意JavaDoc結束和類開始間無空行。

方法被注釋如：

/**
* A description of what the method does...
*
* @param n a description of the parameter
* @return a description of the return value
*/
public int factorial(int n) {

某些不是全部，被JavaDoc注釋區域如：

/**
* Short description of the variable (one line)
*/
type variable;

什麼應當使用JavaDoc做注釋？如何注釋的恰當呢？
可以這樣想，JavaDoc中所作的注釋都可以在類的文檔中看到。所有讀這個類的文檔的讀者都會明白這個類所完成的功能、它包括的方法、如何使用這些方法及方法的返回值。一些作用域，比如public的變數或常量將會一目瞭然。任何不了解這個類內部結構的人都可以輕松的調用它。這便是你用JavaDoc可以輕松提供的信息。而使用一般注釋的地方，一般是給那些可能修改你的類代碼的程序員，它們一般描述了類的內部信息和結構。

下面我寫一下car的類來描述一個編程風格好的java類應該是怎樣的。當然這僅僅是一個小例子(apart from selector and mutator methods)，僅僅是在考慮JAVA編程風格上一個參考而已。

import java.awt.Color;

/**
* This is a class representing cars. A car has certain features, such
* as color, age, number of doors etc and a car can be repainted,
* the tank can be filled etc.
*
* @author Jerry Meng
* @version %I%, %G%
*/
public class Car {

/**
* The maximum size of the tank in litres.
*/
private static final double TANK_SIZE = 100.0;

/**
* The color of the car.
*/
private Color color;

/**
* The age of the car.
*/
private int age;

/**
* The number of doors of the car.
*/
private int doors;

/**
* The amount of gasoline in the tank.
*/
private double gasoline;

/**
* Class constructor, which constructs a brand new, black car with
* five doors and a full tank.
*/
public Car() {
this(Color.black, 0, 5, TANK_SIZE);
}

/**
* Class constructor specifying the color, age, number of doors
* and litres of gasoline
*
* @param color The color of the car
* @param age The age of the car
* @param doors The number of doors
* @param km Kilometres driven
* @param gasoline The litres of gasoline
*/
public Car(Color color, int age, int doors, double gasoline) {
this.color = color;
this.age = age;
this.doors = doors;
this.gasoline = gasoline;
}

/**
* Returns the color of the car
*/
public Color getColor() {
return color;
}

/**
* Repaints the car (i.e. changes its color)
*/
public void setColor(Color color) {
this.color = color;
}

/**
* Returns the age of the car
*/
public int getAge() {
return age;
}

/**
* Returns the number of doors of the car
*/
public int getDoors() {
return doors;
}

/**
* Returns the amount of gasoline in the tank
*/
public double getGasoline() {
return gasoline;
}

/**
* Fills the tank. The amount of gasoline cannot exceed
* the size of the tank. In that case, the tank will be
* filled to the maximum and the rest will run out in
* the sand.
*
* @param gas The amount of gasoline to put in the tank
*/
public void setGasoline(double gas) {

if(gasoline + gas <= TANK_SIZE)
gasoline+=gas;
else
gasoline = TANK_SIZE;
}
}

⑹ 如何將Java源代碼進行分行麻煩告訴我

一些企業在招聘程序員的時候，總會特意提出一個要求，即要求具有良好的編碼規范。確實現在程序開發人員已經不在是單槍匹馬的單干，而是講究團體作戰。此時就要求團隊內的乘員都可能夠恪守代碼的編寫規范，這對於乘員之間共享代碼、排錯等作業都具有非常現實的意義。這在Java語言中當然也不例外。筆者借這次機會，就跟大家分享一下Java源代碼的折行規則。雖然這基本不涉及到功能層面的內容，但是對於提高代碼的閱讀性卻有不可替代的作用。
一、代碼的最大長度。
雖然在Java的編譯器中對於代碼的最大長度沒有硬性的規定。但是如果代碼的長度太長，超過了編譯器的最當行寬，顯然閱讀起來比較麻煩。為此根據筆者的經驗，通常情況下Java源代碼的行長度不應該大於80個字元。如果超過這個長度的話，在一些開發工具和編輯器上就無法很好的顯示。如需要通過滾動條來顯示後面部分的代碼。當其他項目成員閱讀這超長的代碼時，就會看得眼花繚亂。當人的溫飽問題解決了之後，就需要開始注意美觀方面的問題。所以程序開發人員在開發應用程序的時候，要盡量避免書寫長的代碼。如果代碼的每行長度確實需要超過80個字元的話(最好將每行代碼的長度控制在70個字元左右)，那麼就需要對代碼進行分行。
二、在恰當的地方對代碼進行分行。
筆者建議將Java源代碼每行的長度控制在70個字元、最大不超過80個字元。當超過這個字元長度的時候，開發人員就需要考慮在恰當的地方對他們進行分行處理。不過這個分行也不是說開發人員想在哪裡進行分行就在哪裡進行分行。這個分行是有一定技巧的。雖然這些技巧大部分並不是強制性的規定，但是都是一些專家們的經驗總結，可以提高代碼的閱讀性。為此筆者希望各位程序開發能夠嚴格的遵守。
技巧一：高層折行優於低層折行。
這個技巧是說，在考慮對代碼進行折行處理的時候，需要注意代碼的層次性。如某段代碼涉及到混合四則運算，而四則運算又有明顯的運算順序，此時對代碼進行折行時就最好能夠在四則運算的關鍵順序上進行折行處理。如現在有如下的一段代碼：
Mynum=mynum1*(mynum1+mynue2+mynum3-mynum4)+8*mynum5
如果要對這段代碼進行折行的話，該在哪個地方加入一個折行符號呢?如果是筆者處理的話，筆者會按如下的格式對代碼進行折行處理。
Mynum=mynum1*(mynum1+mynue2+mynum3-mynum4)
+8*mynum5
這主要是根據四則運算的運算層次來進行折行的。顯然，*符號的優先順序要比+符號要高。所以在+號前面對其進行折行處理，那麼就可以一目瞭然的反應出代碼的運算層次。可以大幅度的提高代碼的閱讀性。所以代碼折行的第一個技巧就是高層折行優於低層折行。如此的話，可以使得應用程序的結構代碼更加的清晰，更容易被團隊成員所理解。
技巧二：在運算符前面進行折行處理。
其實在如上的折行技巧中，還隱藏著一個規則，即在運算符之前進行折行。如上例所示，筆者就是在+號前面進行折行，而不是在+號後面進行折行處理。這主要也是考慮到代碼的可讀性。如上面這個例子中，如果在+號後面進行折行處理的話，則下一行就會給人一種憑空多出來的感覺，顯得代碼很不連貫。跟這個規則類似，如果在折行處理的時候遇到逗號時，那麼最好能夠在逗號後面進行折行。如在一個方法中，需要傳入5個參數。此時如果代碼行比較長，那麼就需要在幾個參數之間進行折行處理。此時最理想的折行位置，就是在某個參數的逗號後面。注意，使在逗號後面進行折行，而不是在逗號前面。因為一個參數一個逗號是匹對的。而如果一個逗號加一個參數，則讓人看起來很不舒服。
技巧三：這行代碼的對起方式。
當不得已對代碼進行折行處理時，下一行的代碼應該與其同等級的代碼行左對齊。如上例所示，在+號前面將某一段四則運算公式進行折行處理的時候，其+號符號已經採取縮進處理。其縮進後的效果就是要與其同等級的代碼行左對齊。如此的話，明眼人一看就知道這段代碼採取過折行處理;而且跟上一行代碼的層次關系。當一段代碼被分割成三行甚至跟更多行數的時候，這個規則會非常的有用。如果能夠嚴格遵守這個規則，即使將代碼分割成多行，看起來也不會覺得那麼混亂。反而給人一種比較有層次的感覺。
另外在採取縮進處理的時候，可以利用Tab鍵來提高縮進處理的效率。因為直接按空格的話，有可能空格字元數量不一致，會讓人覺得層次不起，產生比較大的混亂。一般情況下，當代碼行兩側距離頁邊的距離比較大，看其來不怎麼舒服時，可以在代碼行中通過插入TAB鍵(會在代碼行中連續插入8個字元)來提高代碼的閱讀性，讓代碼的縮進實現統一。
技巧四：為變數尋找一個合適的位置。
在編寫應用程序時，盡量將變數聲明放置在一個代碼塊的開始處，也就是說{}花括弧的開始位置。雖然說可以在需要使用變數的時候再對其進行聲明。但是筆者不同義如此操作。因為如果在的呢感到使用變數的時候再來聲明變數時，會降低代碼的可讀性。同理，也需要避免低層聲明與高層聲明重復，這樣會引起代碼混亂並可能引發程序功能性錯誤。而且這種錯誤在後續的排錯中很難被發現。為此要在應用程序開發的時候就要盡量避免這種錯誤。
在聲明變數的時候，有時候可能代碼很簡單，生命變數的行總共加起來也不會超過十個字元。此時能否把多個變數的聲明寫在同一行呢?從就技術上來說，這是可行的。也就是說，Java編譯器允許將多個變數定義在同一行上。但是從閱讀性上來說，這並不是很好的做法。筆者的建議是，即使變數定義再簡單，或者變數比較多，也最好分行進行變數的聲明。也就是說，一行聲明一個變數。這可以提高代碼的可閱讀性。而且有時候往往需要對變數加一個注釋說明變數的用途，如果以行定義一個變數，添加行注釋也相對簡單許多。
總之，以上的這些折行的規則基本上不會影響到代碼的運行。但是，對於代碼的維護與後續的排錯、升級、二次開發等等具有不可忽視的作用。而且現在基本上應用程序開發式團隊開發，故大家都遵守同樣的代碼編寫規范是非常重要的。筆者在開發一個應用程序的時候，事先都會花一定的時間，跟項目成員強調這些折行的規則。目的只有一個，就是提高代碼的可讀性，便於後續代碼的共享與維護。畢竟後續面對這些代碼的，並不是客戶，而是我們自己。我們程序員在編寫代碼的時候，不能夠搬起石頭砸自己的腳。筆者認為，現在一個合格的程序人員，不僅技術功底上要過得硬，而且還必須要遵守這些無形規則的約束。難怪現在這么多企業在挑選程序開發人員的時候，都會註明良好的編碼規范。現在對於這些無形中的條條框框，項目經理已經開始重視起來。

⑺ 自學JAVA

最近論壇上看到好幾個朋友都在問，如何學習 Java的問題,「我已經學習了J2SE，怎麼樣才能轉向J2EE?」，「我看完了Thinking in Java， 可以學習J2EE了么?」。於是就有了寫這篇文章的想法，希望能幫助初學者少走一些彎路。也算是對自己幾年來學習Java的一個總結吧。

在開始之前有必要再討論一下J2ME，J2SE，J2EE這些概念。J2ME，The Micro Edition of the Java 2 Platform。主要用於嵌入式Java，如手機，PDA等等。J2SE，Java 2 Platform，Standard Edition，我們通常所說的JDK(Java Development Kit)包含在此，是J2EE的基礎。J2EE，Java 2 Platform，Enterprise Edition，就是所謂的企業級Java。這些只是從API級別上的劃分，實際上Sun給J2EE的定義是：開發基於組件的多層的企業級應用的規范。也就是為各種不同的技術定義一個Java的規范，使這些不同的技術結合起來，在Java平台上構建強壯的企業級應用。從這一點來看，J2EE這個概念應該是涵蓋J2ME，J2SE的。比如一個典型的J2EE應用，網上商店，它支持web方式下訂單，也支持手機下訂單。顯然必須用到J2SE，J2ME。所以也就不存在所謂的從J2SE轉向J2EE的問題了，只是後者包含的范圍更廣而已。

來看看Sun給出的J2EE 相關技術主要分為幾大塊。

1. Web Service技術

- Java API for XML Processing (JAXP)

- Java API for XML Registries (JAXR)

- Java API for XML-based RPC (JAX-RPC)

- SOAP with Attachments API for Java (SAAJ)

2. 組件模型技術（Component Model Technologies）

- Java Servlet

- JavaServer Pages

- JavaServer Faces

- Enterprise JavaBeans

- Java Message Service

- J2EE Connector Architecture

3. 管理技術(Management Technologies)

- J2EE Deployment Specification

- J2EE Management Specification

- J2EE Client Provisioning

- Java Authorization Contract for Containers

4. 其他相關技術(Other J2EE Technologies)

- JDBC

- Java Data Objects (JDO)

- CORBA (Java IDL and Java RMI-IIOP)

- JavaMail

- Transactions

如此之多的技術難免使初學者無所適從，望而卻步。即使是一位經驗豐富的J2EE開發者，又有幾個人敢說J2EE相關的技術我都熟練掌握了。不過作為一名普通J2EE應用程序的開發者來說，我們只需要重點學習其中的一部分技術就可以了，對於其他部分只要做到心中有數，哪天需要用到了知道跑哪裡去找到資料就行了。以我個人的觀點，下面這些技術是一般J2EE應用開發人員所必須熟練掌握的。Java Server Page，Java Servlet，Enterprise JavaBean，JDBC，Transactions。還有JAXP等XML相關技術，Java Message Service，Java Mail，JDO等等是最好應該掌握的。其他Management Technologies，Connector Architecture等等主要是給容器提供商中間件提供商參考的，應用開發者不需要怎麼關心，等用到了再去學習也不遲。

語言學習篇

首先是J2SE基礎。學習一門新技術，無外乎閱讀和實踐了。而一本好的參考書對於初學者來說顯得格外重要。現在市面上的 Java書籍可以說是鋪天蓋地，質量也是良莠不齊，令初學者無所適從。所以還是先推薦幾本書籍吧。目前對於Java基礎知識，大家一般都比較推薦兩本書<>和<< Core Java? 2， Volume I: Fundamentals >>。第一本書不必多說了，Bruce Eckel的大作，Jolt獲獎書籍。內容比較全面，基本涵蓋了java語言的方方面面。這本書提供了相當豐富的例子，非常有利於對學習內容的了解。另外書中第一部分對於OO基本書籍的介紹，我覺得對於剛接觸OO的人來說幫助會很大。而且此書是Open Source的，可以從作者網上下載http://www.mindview.net/Books/TIJ/而對於習慣於讀中文版的學習者來說，侯捷翻譯的中文版是不錯的選擇。要說這本說的缺點可能就是對於初學者來說厚了一點，這也是一些人並不推薦此書作為初學者學慣用書的原因吧。後面一本<< Core Java? 2， Volume I: Fundamentals >>。目前已經是第七版了，單從它出版的次數來看也可以看出此書受歡迎的程度，這本書特點也是講述比較全面系統，基本上一路啃下來的話Java語言基礎應該算過關了。缺點也是太厚了，有點像參考手冊，前面部分花了不少篇幅講Swing和Applet，可能對初學者不是很有用。還有一些像<< Java in a nutshell>>也是比較不錯的基礎書籍。

學習了基本的語言基礎，別忘了最重要也是最有用的資料還是JDK文檔。從你學習java的第一天開始JDK文檔應該是常備手頭了。如果你碰到問題首先想到的是到論壇上去提問而不是查閱Jdk文檔，那先別繼續往下學習了，學會查JDK文檔先。不誇張的說在我們的初學者論壇中60%的問題是光查一下JDK文檔就能解決問題的。最新JDK Documentation下載地址http://java.sun.com/j2se/1.4.2/download.html(目前最新版是J2SE5 http://java.sun.com/j2se/1.5.0/download.jsp)不能光說不練，同一下載頁面把JDK給下載回來。安裝完後有一點我想提一下，安裝路徑下有一個src.zip(有些jdk版本是src.jar)，好東西啊---JDK源代碼，老是有人在論壇上問哪裡有JDK源代碼下載，你說東西就放在你家裡還到處找。有了這個有些問題就需要在論壇上跟人家爭來爭去了，翻開源代碼瞧一下什麼疑問都沒有了。幾個最重要的命令行工具是

javac: 編譯源文件到class文件

java: 運行class

jar: 打包工具。

javadoc: 生成java doc的工具。

對於初學java的人來說，我不推薦使用IDE而直接用文本編輯器，然後用命令行編譯運行。這樣有利於理解CLASSPATH，PATH這些最基本概念。CLASSPATH是初學者比較容易感覺迷惑的地方。現在的IDE太聰明了，給個名字就給你自動生成java source code，自動編譯。可能你運行完了你的第一個Hello World程序，還不知道java和javac是用來做什麼的。至於實際的項目開發，一款合適的IDE還是十分重要的，我們稍後再對java開發工具做一些介紹。

J2EE基礎和Java語言進階

學習完語言基礎，就可以比較自然地轉入J2EE實際技術的學習了。J2EE實在是比較龐雜，而EJB，Servlet，這些核心技術是作為每一個J2EE開發人員所需要掌握的。關於servlet，我比較推薦<>和<>，第一本是Sun推薦的Servlet教材。第二本是當年Amazon最暢銷Java書籍，五星級書籍。這本書機械工業出版社有中文版叫<<與JSP權威指南>>，感覺翻譯得還可以，第二版好像還沒有看到有中文版。兩本書都全面系統地介紹了JSP和Sevlet知識，從web伺服器配置，JSP，Servlet基本編程，標記庫(Tag Lib)，過濾器，事件框架都有很好地描述。提供地例子也比較實用。對於EJB學習，比較著名有兩本書，<< Enterprise JavaBeans， 3nd Edition>>和<< Mastering Enterprise Java Beans Third Edition>>，兩位作者Richard Monson，Ed Roman都是屬於業界重量級人物。而Richard Monson本身就是EJB規范專家組成員。對我來說，兩本書難分優劣，第二本書有個好處就是可以免費下載http://www.theserverside.com/books/wiley/masteringEJB/index.tss。

還是那句話，不能光說不練，不過J2EE的練習做起來有一點麻煩，應用伺服器是不可少的，最好還得准備個輕量級的資料庫。下面簡單介紹一下這些工具。

web伺服器(Servlet Container)方面有。

Tomcat: http://jakarta.apache.org/tomcat/

Jetty: http://jetty.mortbay.org/jetty/

應用伺服器常用的有，

Jboss: http://www.jboss.org/procts/index

Weblogic: http://www.bea.com/framework.jsp?CNT=index.htm&FP=/content/procts/server

WebSphere: http://www-128.ibm.com/developerworks/downloads/ws/was/?S_TACT=105AGX28&S_CMP=DLMAIN。

Tomcat，Jetty，Jboss都是Open Source。Weblogic和WebSphere是J2EE伺服器中的老大級人物，價格也不菲。不過對於開發者有免費的試用版下載。

如果單單只是學習Servlet，推薦使用Tomcat，它是Sun官方指定的Servlet，JSP規范的參考實現。對初學者最重要的是它使用比較簡單，自帶文檔比較齊全，使用者眾多，有什麼問題容易在論壇上面得到幫助。如果學習EJB的話，推薦使用Jboss，不僅僅是因為它是Open Source的，主要是配置比較簡單，使用方便。比如說對於連接資料庫，對於常用的MySQL，Oracle，MS SQL等等都提供了Sample Config文件，直接拿過來做些小改動扔到Deploy目錄下就可以用DataSource了，部署J2EE應用也簡單，把整個.ear或者.war扔到deploy下就可以了。唯一不方便的地方是從Jboss3.0開始，它的文檔開始收費了。但是對於一些基本的配置，在網上還是非常容易找到的，畢竟它太流行了。至於Weblogic，也比較容易使用，不過比起Jboss來個頭大了很多，通過強大的管理界面使得一些常用的配置工作變得十分簡單。和Jboss比起來它的文檔就太多了，簡直是有點羅里八嗦，比如要部署一個.ear文件，一般我們也就是直接扔到domain下的applications目錄下就會自動deploy了，但是要看它的文檔可是長篇大論，容易嚇著初學者，以為這又是什麼高深的學問。至於WebSphere，個人不推薦初學者使用，相比前倆個Server比較難使，而且狂吃內存。不過在企業級市場這個傢伙表現不俗，畢竟是出生於IBM這樣的豪門。

資料庫方面，目前常見的主要有PostgreSQL，MySQL，Oracle，MS SQL，DB2等等。前面兩個是開源資料庫，後面幾個基本上壟斷著大部分的資料庫市場。對於初學者用來做做EJB，JDBC的練習，我推薦MySQL，理由還是很簡單，開源軟體不要錢，個頭小使用方面，用戶眾多文檔齊全。下載地址http://www.mysql.com/procts/mysql/。PostgreSQL也可以考慮，不過國內使用者遠不如MySQL多，所以要在論壇上問起問題來就少方便一些了，下載地址http://www.pervasive-postgres.com/downloads/。至於後面那些比較重量級的資料庫，為了做做練習而言就不用考慮了， 咱也花不起這個錢啊。

學習完J2EE的這些具體技術，這個時候進行基本的J2EE開發應該是不成問題了。此時應該考慮提高自己的代碼質量了。這里我強烈推薦Martin Fowler的<>，這本書不是一本非常實際的書，作者完全是手把手地教你如何提高代碼質量，從具體地代碼中告訴你什麼是代碼的Bad Smell，如何去掉這些Bad Smell。不少書評是這么說的，這本書對於初級，中級的讀者幫助是立桿見影的。至少就我接觸到的幾個學習編程不久的程序員，編碼質量在短期內都有很大提高。當然重構(Refactoring)這一概念並不只針對Java語言的，它對所有OO語言都是適用的。重構的概念是如此深入人心，以至於今天幾乎所有流行的IDE工具都有對重構的支持。這里我還想再推薦一本<>。從C++過來的程序員都知道<>在C++領域的地位，至今還流傳著這樣的趣話，C++程序員分為兩種，一種是讀過<>的，另一種是沒有讀過C++的。雖然這本<>在Java領域的影響也許沒有那麼大，但對於Java程序員絕對有相當的指導價值。作者是Sun公司的Joshua Bloch，java Collection framework的設計者。作者站在JDK設計者的角度向你介紹他的Best Practice，應該這樣做而不應該那樣做，對於JDK中某些API設計的缺陷他也毫不袒護的指出。Java語言之父James Gosling為此書寫的前言是這么說的「I sure wish I had had this book ten years ago。 Some might think that I don't need any Java books， but I need this one」。這本書會讓你覺得原來你對Java還是有很多東西不了解的。舉個例子來說，對象的equals方法，我們認為它很簡單，也許你每天都在為你新寫的Class重載這個方法，但是你在重載的時候注意過「自反」，「對稱」，「傳遞」這些必須要考慮的因素，你是否同時還小心謹慎的重載了hashcode這個方法？如果沒有，建議你要讀一下這本書。讀完這本書，你會覺得離Java的距離更近了。上面兩本書都出過中文版，後面一本<>還有兩個版本的中文版，第一次翻譯的比較差一點，後來機械工業出版社又委託潘愛民先生重新翻譯了一遍。同一本書在同一個出版社連續被翻譯了兩次也說明國內出版界對這本書還是比較重視的。

這個階段，在看書的同時，可以結合著學習一些優秀的開源項目的源代碼。這些開源項目的代碼風格，注釋都是值得借鑒的。實在太懶也別忘了手頭上還有個Jdk的源代碼。其實也不用刻意去找源代碼，在實際的J2EE項目開發中，基本上都會用到一些優秀的開源項目。Framework可能會用到Spring，Struts，Log機制基本上都會JarkartaCommons Log或者Log4j，單元測試會大多會用Junit，結合項目閱讀一下其中的一些源代碼，既可以提高自己又對項目會有所幫助，說不定因此而得到PM的賞識呢。一舉兩得，何樂而不為呢。呵呵，有點扯遠了。過了初學者階段，該學會如何找到適合自己的Java書籍了。歷經數十載，今天的Java技術已經變的如此之龐雜，我相信即使窮凈一個人畢生之精力也不可能把Java所有的相關技術都學通，何況新技術還在層出不窮地推出，3年之前誰會知道Struts會成為Web框架事實上的工業標准。2年之前誰會知道Hibernate會在今天獨領風騷。既然已經不能指望一次性把java技術的方方面面都學個通，在實際中也只能是需要什麼技術再學習什麼技術了。而能否選擇一本好的參考書籍帶來的就是事半功倍和事倍工半的效果。所以我覺得花點時間放在選擇書籍上面還是很值得的，否則你在後面只會花更多的時間。下面我談談自己選擇書籍的一些經驗，不一定正確。首先看作者，像上面提到的那些書的作者，都是業界鼎鼎大名的，選擇他們的書一般錯不了。大家看的書多了，自己胸中自然也會有一個list，哪些作者是信得過的。二看出版社，計算機書籍方面，Oreilly，Addison-Wesley都是公認比較好的出版社。對於目前比較流行的Java技術，Oreilly的< in Action>>系列是不錯的選擇。另外我還會去看看Amazon網站(http://www.amazon.com/)的書評，一般小於3星級的書我都不會考慮。還有一個好去處theserverside，http://www.theserverside.com/的書評，這里的書評比較有趣，往往都有很激烈的爭論，裡面經常會看到一些名人在發言。我要向所有Java學習者推薦，如果我的收藏夾裡面只能存放兩個網站，我會選擇java.sun和theserverside。在這里你可以了解最新的Java動態，可以學習第一手的Java資料，可以看到Java高手們(裡面不乏業界大腕)激烈辯論。in Action>>

到此階段，Java Developer的基本功底應該算是打好了吧，往後就是不斷學習嘍。結束這一段之前，最後再介紹一本書Oreilly的<， Second Edition >>，因為我覺得多線程編程屬於Java基本功，每一個想學好Java的人都應該好好掌握。

提高篇

在這個階段應該從軟體架構，Framework層次上來學習了。作為面向對象的聖經<>， 這本書是不得不推薦的。不用再多說了，這本在面向對象領域地位完全是屬於教父級別的。不管你學習的是什麼OO語言，不管你現在是用.Net還是J2EE開發，這本書都是你進階之路上的必讀之書。而<>則專門針對於J2EE來討論設計模式，書中Sun Java Center的資深設計師描述了J2EE關鍵技術的模式。最佳實踐，設計策略和經過驗證的解決方案。對於每一個希望成為J2EE 架構師或者設計師，這本書值得一讀。學習設計模式的時候，建議是結合實際的源代碼來看，比如看看Junit源代碼，你可以看到很多設計模式優雅的實現，作者之一Erich Gamma本身就是<>的作者。至於J2EE的設計模式，Sun還開辟了專門的空間http://java.sun.com/blueprints/patterns/，裡面有對常用模式的討論又提供了詳細的源代碼樣例。正如Grady Booch所說，模式對於普遍問題提供了通用的解決方案，利用模式就等於擁有一個強大的專家隊伍。如果你還沒有學習，現在就開始吧。此外對於面向對象方法論，極限編程的思想也應該有所了解http://www.extremeprogramming.org/。對於J2EE項目的具體實施，Rod Johnson的<>也很有價值，該書以作者豐富的實戰經驗向我們展示如何用盡可能簡單的解決方案構建J2EE 應用，書中作者第一次提出這樣的觀點，很多時候，J2EE應用完全沒有必要用到EJB，對於言必稱EJB的廣大J2EE開發者來說，怎麼說也有點驚世咳俗的味道。當然，作為Servlet和JDO兩個專家組的成員，這可不是作者信口胡騶的。今天風靡Java世界的Spring框架最初便是源於此書，而IOC，AOP等概念更是被時下的java開發者掛在嘴邊。最後，作為對Java的深入學習，Java技術的各個Specification也有必要一讀。暫時就寫到這里吧。

⑻ java簡單編程題，有追加分

第一題，x和n從命令行作為參數輸入：
public class Test1{
public static void main(String[] args){
int argLen = args.length;
//判斷是否至少傳入了兩個參數
if (argLen < 2){
System.out.println("請輸入兩個整型參數");
return;
}

int x = 0;
int n = 0;

//轉換傳遞進來的參數，如果輸入的參數不合法，不能轉換為int型，則Integer.parseInt方法會拋出NumberFormatException異常
try{
x = Integer.parseInt(args[0]);
n = Integer.parseInt(args[1]);
}
catch(NumberFormatException e)
{
System.out.println("輸入的參數不是整數");
System.exit(1);
}

//判斷x和n的值是否是正數
if (x<=0 || n<=0)
{
System.out.println("不能輸入負值或0，請輸入兩個正整數");
System.exit(1);
}

//列印轉換後的x和n
System.out.println("你輸入的x和n分別為： " + x + ", " + n);

/*
y=1+x/1+x*x*x/3+......+x^n/n
根據公式計算結果。由於公式中y增長的很快，所以我們定義一個double型的變數存儲結果的值。但仍然很有可能溢出。必要的話可以使用math包中的類來進行任意長度和精度的處理，但這里就不麻煩了。
*/
double y = 1.0;
for (int i=1; i<=n; i+=2)
{
y += Math.pow(x, i)/(double)i;
}

//列印結果
System.out.println("根據公式y=1+x/1+x*x*x/3+......+x^n/n所計算出的結果為： " + y);

} // main()

} /* Test1 */

第二題，需要的test11.html文件內容如下：
<html>
<head>
<title>Test11 demo</title>
</head>

<body>
<applet width="300" height="400" code="Test11.class"></applet>
</body>
</html>

然後使用appletviewer test11.html瀏覽小應用程序（在瀏覽器中可能不能正常運行）。

java代碼如下：

import java.applet.Applet;
import java.awt.Graphics;
import java.awt.Label;

public class Test11 extends Applet{

//定義文字所在位置與頂部的距離
private int posY = 200;

private Label textsLabel = new Label("我猜你將看到這句話一直在滾動");

public void init()
{
textsLabel.setBounds(50, 200, 200, 30);
this.add(textsLabel);

//啟動新線程
SecThread st = new SecThread();
st.start();
} // init()

public void paint(Graphics g){
super.paint(g);
} //paint()

//定義一個內部類，以啟動一個新的線程
private class SecThread extends Thread{
public void run()
{
while(true){
//讓當前線程休眠50毫秒，注意sleep方法會拋出InterruptedException異常
try{
Thread.sleep(50);
}
catch(InterruptedException e){
System.out.println("執行過程中出錯");
System.exit(1);
}

//設置文字的新位置
posY -= 5;
//判斷是否小於0（即已經到達頂部），如果小於0則重置為400
posY = (posY<=0?400:posY);
textsLabel.setBounds(50, posY, 200, 30);
Test11.this.repaint();
}
}
}

} /* Test2 */

3, 4兩題實在很簡單，略過了。

找到你的帖子了！
將3，和4也寫一下：

3.運行方法看2：

import java.applet.Applet;
import java.awt.Graphics;

public class Test111 extends Applet
{
public void paint(Graphics g)
{
for (int i=1; i<=10; i++) //畫橫線
{
g.drawLine(20, i*20, 200, i*20);
}

for (int j=1; j<=10; j++) //畫豎線
{
g.drawLine(j*20, 20, j*20, 200);
}
}
}

4. 代碼如下：（你說已經寫好的程序怎麼改成applet。記住一點，applet在運行時自動調用init、start和paint方法，而通常的應用程序調用main方法。只要將main方法中的內容妥善地移到這三個方法中就可以了。但修改的時候要注意，不要引入錯誤。）

//任意輸入三個數，可以有小數，然後比較它們的大小
import java.applet.Applet;
import java.awt.Graphics;
import java.awt.Button;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import javax.swing.JOptionPane;

public class Test1111 extends Applet
{

public void paint(Graphics g)
{
this.setLayout(null);
Button btn = new Button("開始輸入");
btn.setBounds(100, 130, 100, 30);
btn.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
sort();
}
});

this.add(btn);
}

private void sort()
{
//3個元素的字元串數組，存放輸入的數
String[] numberStrs = new String[3];

for (int i=0; i<numberStrs.length; i++)
{
//如果輸入時按了取消按鈕，則繼續提示輸入
while(numberStrs[i] == null)
{
numberStrs[i] = JOptionPane.showInputDialog("請輸入第 " + (i+1) + " 個數");
}
}

//定義3個元素的double型數組，存放轉換後的值
double[] numbers = new double[3];
try
{
for (int j=0; j<numbers.length; j++)
{
numbers[j] = Double.parseDouble(numberStrs[j]);
}
}
catch(NumberFormatException e)
{
JOptionPane.showMessageDialog(null, "輸入的不是數字!"
, "ERROR", JOptionPane.ERROR_MESSAGE);
System.exit(1);
}

String result = "";

result += "你輸入的數字為： ";
for (int k=0; k<numbers.length-1; k++)
{
result += numbers[k] + ", ";
}

result += numbers[numbers.length-1] + "\n";

//簡單點，使用冒泡排序
for (int i=1; i<numbers.length; i++)
{
for (int j=0; j<numbers.length-1; j++)
{
if (numbers[j] > numbers[j+1])
{
double temp = numbers[j];
numbers[j] = numbers[j+1];
numbers[j+1] = temp;
}
}
}

result += "排序後的數字為： ";
for (int k=0; k<numbers.length-1; k++)
{
result += numbers[k] + ", ";
}

result += numbers[numbers.length-1];

//輸出結果
JOptionPane.showMessageDialog(null, result, "Result", JOptionPane.PLAIN_MESSAGE);
}
}

⑼ 編程高手幫忙看個java代碼

你的while語句中的判斷有問題：你寫的是(s1 = br1.readLine())!=null&&(s2 = br1.readLine())!=null
你兩個判斷的都是br1，應該改為：(s1 = br1.readLine())!=null&&(s2 = br2.readLine())!=null