2008年11月19日
#
Jsp頁面在URL中傳遞參數會出現亂碼可以采用以下方法解決：一、使用更改Tomcat的方法。二、使用JSP的scriptLet view plaincopy to clipboardprint?三、使用自定義JSTL。
Jsp頁面在URL中傳遞參數會出現亂碼
解決方法如下：
一、使用更改Tomcat的方法。這個方法簡單，但是需要改動的地方是服務器軟件級別的，如果稍微變動系統將無法正確轉碼，移植性不高。
1、來到tomcat目錄，找到conf目錄下的server.xml問價，打開，找到<Connector>標簽，在最后添加URIEncoding=’GBK’，效果如下：
view plaincopy to clipboardprint?
<Connector
port="8080"maxThreads="150"minSpareThreads="25"maxSpareThreads="75"
enableLookups="false"redirectPort="8443"acceptCount="100"
debug="0"connectionTimeout="20000"
disableUploadTimeout="true"URIEncoding=″GBK″/>
<Connectorport="8080" maxThreads="150" minSpareThreads="25" maxSpareThreads="75"enableLookups="false" redirectPort="8443" acceptCount="100"debug="0" connectionTimeout="20000"disableUploadTimeout="true" URIEncoding=″GBK″/>
這種方法對get這個方法測試成功。
2、在每個Jsp頁面添加如下代碼
view plaincopy to clipboardprint?
<%@pagepageEncoding=”gb2312″%>
<%@pagecontentType=”text/html;charset=gb2312″%>
<%request.setCharacterEncoding(”gb2312″);%>
<%@ page pageEncoding=”gb2312″%><%@ page contentType=”text/html;charset=gb2312″%><%request.setCharacterEncoding(”gb2312″);%>
編碼方式也可以改成GBK，支持繁體中文。重啟Tomcat，這一步很重要，否則可能看不到效果。
這種方法對post測試成功。建議兩種同步使用。
二、使用JSP的ｓｃｒｉｐｔLet
view plaincopy to clipboardprint?
<%=newString(elValue.getBytes("iso-8859-1"),"GBK")%>
<%=new String(elValue.getBytes("iso-8859-1"),"GBK")%>
三、使用自定義JSTL
這是我們的重點所在,這里要詳細說明.
第一,編寫自定義標簽
第二編寫tag文件
第三部署tag文件
第四使用吧;)很簡單的.
方法覆蓋必須滿足下列條件
(1) 子類的方法的名稱及參數必須和所覆蓋的方法相同
(2) 子類的方法返回類型必須和所覆蓋的方法相同
(3) 子類方法不能縮小所覆蓋方法的訪問權限
(4) 子類方法不能拋出比所覆蓋方法更多的異常
重載方法必須滿足下列條件
(1) 方法名必須相同
(2) 方法的參數簽名必須相同
(3) 方法的返回類型和方法的修飾符可以不相同
順便說說方法覆蓋和重載的區別
初次見到這兩個單詞并沒有什么特別的感覺，但是時間長了，卻發現書上一會兒用override，一會兒又用overload，搞得我的迷迷糊。于是就做了個總結，希望能對和我一樣對這兩個概念模糊不清的網友有一個幫助。
override可以翻譯為覆蓋，從字面就可以知道，它是覆蓋了一個方法并且對其重寫，以求達到不同的作用。對我們來說最熟悉的覆蓋就是對接口方法的實現，在接口中一般只是對方法進行了聲明，而我們在實現時，就需要實現接口聲明的所有方法。除了這個典型的用法以外，我們在繼承中也可能會在子類覆蓋父類中的方法。在覆蓋要注意以下的幾點：
1、覆蓋的方法的標志必須要和被覆蓋的方法的標志完全匹配，才能達到覆蓋的效果；
2、覆蓋的方法的返回值必須和被覆蓋的方法的返回一致；
3、覆蓋的方法所拋出的異常必須和被覆蓋方法的所拋出的異常一致，或者是其子類；
4、被覆蓋的方法不能為private，否則在其子類中只是新定義了一個方法，并沒有對其進行覆蓋。
overload對我們來說可能比較熟悉，可以翻譯為重載，它是指我們可以定義一些名稱相同的方法，通過定義不同的輸入參數來區分這些方法，然后再調用時，VM就會根據不同的參數樣式，來選擇合適的方法執行。在使用重載要注意以下的幾點：
1、在使用重載時只能通過不同的參數樣式。例如，不同的參數類型，不同的參數個數，不同的參數順序（當然，同一方法內的幾個參數類型必須不一樣，例如可以是fun(int,float)，但是不能為fun(int,int)）；
2、不能通過訪問權限、返回類型、拋出的異常進行重載；
3、方法的異常類型和數目不會對重載造成影響；
4、對于繼承來說，如果某一方法在父類中是訪問權限是priavte，那么就不能在子類對其進行重載，如果定義的話，也只是定義了一個新方法，而不會達到重載的效果。
下面是對override和overload的測試程序，其中注釋中的內容都是會產生編譯錯誤的代碼，我們將注釋去掉，看看在編譯時會產生什么效果。
//對overload測試的文件：OverloadTest.java
publicnewOverrideTest1();
try{
test.fun();
test.fun1();
}catch(Exceptione){}
}
}
classOverrideTest1extendsOverrideTest{
//以下正常Override
publicvoidfun()throwsTestException2{
System.out.println("funinOverrideTest1");
}
//不能Override父類中的方法，因為它定義了不同的異常類型和
//返回值。
//publicintfun()throwsTestException1{
//System.out.println("methodfuninTest");
//return1;
//}
//不能Override父類中的方法，因為它拋出了比父類中非法范圍
//更大的異常。
//publicvoidfun()throwsException{
//System.out.println("funinOverrideTest1");
//}
//這個方法并沒有Override父類中的fun1方法，因為這個方法在
//父類是private類型，所以這里只是相當于定義了一個新方法。
publicvoidfun1(){
System.out.println("methodfun1inTest");
}
}
classTestExceptionextendsException{
publicTestException(Stringmsg){
super(msg);
}
}
classTestException1extendsTestException{
publicTestException1(Stringmsg){
super(msg);
}
}
classTestException2extendsTestException{
publicTestException2(Stringmsg){
super(msg);
}
}
參考資料：http://zhidao.baidu.com/question/1996221.html
5.1 是否可以繼承String類？
String類是final類故不可以繼承。
5.2 swtich是否能作用在byte上，是否能作用在long上，是否能作用在String上？
switch（expr1）中，expr1是一個整數表達式。因此傳遞給 switch 和 case 語句的參數應該是 int、 short、 char 或者 byte.long，string 都不能作用于swtich.
5.3 try {}里有一個return語句，那么緊跟在這個try后的finally {}里的code會不會被執行，什么時候被執行，在return前還是后？
會執行，在return前執行。
5.4 編程題： 用最有效率的方法算出2乘以8等於幾？
2 << 3
5.5 兩個對象值相同（x.equals（y） == true），但卻可有不同的hash code，這句話對不對？
不對，有相同的hash code.
5.6 當一個對象被當作參數傳遞到一個方法后，此方法可改變這個對象的屬性，并可返回變化后的結果，那么這里到底是值傳遞還是引用傳遞？
是值傳遞。Java 編程語言只有值傳遞參數。當一個對象實例作為一個參數被傳遞到方法中時，參數的值就是對該對象的引用。對象的內容可以在被調用的方法中改變，但對象的引用是永遠不會改變的。
5.7 當一個線程進入一個對象的一個synchronized方法后，其它線程是否可進入此對象的其它方法？
不能，一個對象的一個synchronized方法只能由一個線程訪問。
（這個有點疑問：問的是這個對象的其他方法，而非synchonized方法。）
5.8 編程題： 寫一個Singleton出來。
Singleton模式主要作用是保證在Java應用程序中，一個類Class只有一個實例存在。
一般Singleton模式通常有幾種種形式：
第一種形式： 定義一個類，它的構造函數為private的，它有一個static的private的該類變量，在類初始化時實例話，通過一個public的getInstance方法獲取對它的引用，繼而調用其中的方法。
|
package test;
public class Singleton {
private Singleton() {
}
// 在自己內部定義自己一個實例，是不是很奇怪？
// 注意這是private 只供內部調用
private static Singleton instance = new Singleton();
// 這里提供了一個供外部訪問本class的靜態方法，可以直接訪問
public static Singleton getInstance() {
return instance;
}
}
|
第二種形式：
|
package test;
public class Singleton {
private static Singleton instance = null;
public static synchronized Singleton getInstance() {
// 這個方法比上面有所改進，不用每次都進行生成對象，只是第一次
// 使用時生成實例，提高了效率！
if (instance == null)
instance = new Singleton();
return instance;
}
}
|
其他形式：
定義一個類，它的構造函數為private的，所有方法為static的。
一般認為第一種形式要更加安全些
5.9 Java的接口和C++的虛類的相同和不同處。
由于Java不支持多繼承，而有可能某個類或對象要使用分別在幾個類或對象里面的方法或屬性，現有的單繼承機制就不能滿足要求。與繼承相比，接口有更高的靈活性，因為接口中沒有任何實現代碼。當一個類實現了接口以后，該類要實現接口里面所有的方法和屬性，并且接口里面的屬性在默認狀態下面都是public static，所有方法默認情況下是public.一個類可以實現多個接口。
5.10 Java中的異常處理機制的簡單原理和應用。
當Java程序違反了Java的語義規則時，Java虛擬機就會將發生的錯誤表示為一個異常。違反語義規則包括2種情況。一種是Java類庫內置的語義檢查。例如數組下標越界，會引發IndexOutOfBoundsException；訪問null的對象時會引發NullPointerException.另一種情況就是Java允許程序員擴展這種語義檢查，程序員可以創建自己的異常，并自由選擇在何時用throw關鍵字引發異常。所有的異常都是java.lang.Thowable的子類。
4.1 EJB包括（SessionBean，EntityBean）說出他們的生命周期，及如何管理事務的？
SessionBean：Stateless Session Bean 的生命周期是由容器決定的，當客戶機發出請求要建立一個Bean的實例時，EJB容器不一定要創建一個新的Bean的實例供客戶機調用，而是隨便找一個現有的實例提供給客戶機。當客戶機第一次調用一個Stateful Session Bean 時，容器必須立即在服務器中創建一個新的Bean實例，并關聯到客戶機上，以后此客戶機調用Stateful Session Bean 的方法時容器會把調用分派到與此客戶機相關聯的Bean實例。
EntityBean：Entity Beans能存活相對較長的時間，并且狀態是持續的。只要數據庫中的數據存在，Entity beans就一直存活。而不是按照應用程序或者服務進程來說的。即使EJB容器崩潰了，Entity beans也是存活的。Entity Beans生命周期能夠被容器或者 Beans自己管理。
EJB通過以下技術管理事務：對象管理組織（OMG）的對象事務服務（OTS），Sun Microsystems的Transaction Service（JTS）、Java Transaction API（JTA），開發組（X/Open）的XA接口。
4.2 應用服務器有那些？
BEA WebLogic Server，IBM WebSphere Application Server，Oracle9i Application Server，jBoss，Tomcat
4.3 給我一個你最常見到的runtime exception.
ArithmeticException， ArrayStoreException， BufferOverflowException， BufferUnderflowException， CannotRedoException， CannotUndoException， ClassCastException， CMMException， ConcurrentModificationException， DOMException， EmptyStackException， IllegalArgumentException， IllegalMonitorStateException， IllegalPathStateException， IllegalStateException， ImagingOpException， IndexOutOfBoundsException， MissingResourceException， NegativeArraySizeException， NoSuchElementException， NullPointerException， ProfileDataException， ProviderException， RasterFormatException， SecurityException， SystemException， UndeclaredThrowableException， UnmodifiableSetException， UnsupportedOperationException.
4.4 接口是否可繼承接口？ 抽象類是否可實現（implements）接口？ 抽象類是否可繼承實體類（concrete class）？
接口可以繼承接口。抽象類可以實現（implements）接口，抽象類是否可繼承實體類，但前提是實體類必須有明確的構造函數。
4.5 List， Set， Map是否繼承自Collection接口？
List，Set是，Map不是
4.6 說出數據連接池的工作機制是什么？
J2EE服務器啟動時會建立一定數量的池連接，并一直維持不少于此數目的池連接。客戶端程序需要連接時，池驅動程序會返回一個未使用的池連接并將其表記為忙。如果當前沒有空閑連接，池驅動程序就新建一定數量的連接，新建連接的數量有配置參數決定。當使用的池連接調用完成后，池驅動程序將此連接表記為空閑，其他調用就可以使用這個連接。
4.7 abstract的method是否可同時是static，是否可同時是native，是否可同時是synchronized？
都不能
4.8 數組有沒有length（）這個方法？ String有沒有length（）這個方法？
數組沒有length（）這個方法，有length的屬性。String有有length（）這個方法。
4.9 Set里的元素是不能重復的，那么用什么方法來區分重復與否呢？ 是用==還是equals（）？ 它們有何區別？
Set里的元素是不能重復的，那么用iterator（）方法來區分重復與否。equals（）是判讀兩個Set是否相等。
equals（）和==方法決定引用值是否指向同一對象equals（）在類中被覆蓋，為的是當兩個分離的對象的內容和類型相配的話，返回真值。
4.10 構造器Constructor是否可被override？
構造器Constructor不能被繼承，因此不能重寫Overriding，但可以被重載Overloading.
3.1 Static Nested Class 和 Inner Class的不同。
Static Nested Class是被聲明為靜態（static）的內部類，它可以不依賴于外部類實例被實例化。而通常的內部類需要在外部類實例化后才能實例化。
3.2 JSP中動態INCLUDE與靜態INCLUDE的區別？
動態INCLUDE用jsp：include動作實現 <jsp：include page="included.jsp" flush="true" />它總是會檢查所含文件中的變化，適合用于包含動態頁面，并且可以帶參數。
靜態INCLUDE用include偽碼實現，定不會檢查所含文件的變化，適用于包含靜態頁面<%@ include file="included.htm" %>
3.3 什么時候用assert.
assertion（斷言）在軟件開發中是一種常用的調試方式，很多開發語言中都支持這種機制。在實現中，assertion就是在程序中的一條語句，它對一個boolean表達式進行檢查，一個正確程序必須保證這個boolean表達式的值為true；如果該值為false，說明程序已經處于不正確的狀態下，系統將給出警告或退出。一般來說，assertion用于保證程序最基本、關鍵的正確性。assertion檢查通常在開發和測試時開啟。為了提高性能，在軟件發布后，assertion檢查通常是關閉的。
3.4 GC是什么？ 為什么要有GC？
GC是垃圾收集的意思（Gabage Collection），內存處理是編程人員容易出現問題的地方，忘記或者錯誤的內存回收會導致程序或系統的不穩定甚至崩潰，Java提供的GC功能可以自動監測對象是否超過作用域從而達到自動回收內存的目的，Java語言沒有提供釋放已分配內存的顯示操作方法。
3.5 short s1 = 1； s1 = s1 + 1；有什么錯？ short s1 = 1； s1 += 1；有什么錯？
short s1 = 1； s1 = s1 + 1； （s1+1運算結果是int型，需要強制轉換類型）
short s1 = 1； s1 += 1；（可以正確編譯）
3.6 Math.round（11.5）等於多少？ Math.round（-11.5）等於多少？
Math.round（11.5）==12
Math.round（-11.5）==-11
round方法返回與參數最接近的長整數，參數加1/2后求其floor.
3.7 String s = new String（"xyz"）；創建了幾個String Object？
兩個
3.8 設計4個線程，其中兩個線程每次對j增加1，另外兩個線程對j每次減少1.寫出程序。
以下程序使用內部類實現線程，對j增減的時候沒有考慮順序問題。
|
package test;
public class ThreadTest1 {
private int j;
public static void main(String args[]) {
ThreadTest1 tt = new ThreadTest1();
Inc inc = tt.new Inc();
Dec dec = tt.new Dec();
for (int i = 0; i < 2; i++) {
Thread t = new Thread(inc);
t.start();
t = new Thread(dec);
t.start();
}
}
private synchronized void inc() {
j++;
System.out.println(Thread.currentThread().getName() + "-inc:" + j);
}
private synchronized void dec() {
j--;
System.out.println(Thread.currentThread().getName() + "-dec:" + j);
}
class Inc implements Runnable {
public void run() {
for (int i = 0; i < 3; i++) {
inc();
}
}
}
class Dec implements Runnable {
public void run() {
for (int i = 0; i < 3; i++) {
dec();
}
}
}
}
|
3.9 Java有沒有goto？
Java中的保留字，現在沒有在Java中使用。
3.10 啟動一個線程是用run（）還是start（）？
啟動一個線程是調用start（）方法，使線程所代表的虛擬處理機處于可運行狀態，這意味著它可以由JVM調度并執行。這并不意味著線程就會立即運行。run（）方法可以產生必須退出的標志來停止一個線程。
2.1 HashMap和Hashtable的區別。
HashMap是Hashtable的輕量級實現（非線程安全的實現），他們都完成了Map接口，主要區別在于HashMap允許空（null）鍵值（key），由于非線程安全，效率上可能高于Hashtable.
HashMap允許將null作為一個entry的key或者value，而Hashtable不允許。
HashMap把Hashtable的contains方法去掉了，改成containsvalue和containsKey.因為contains方法容易讓人引起誤解。
Hashtable繼承自Dictionary類，而HashMap是Java1.2引進的Map interface的一個實現。
最大的不同是，Hashtable的方法是Synchronize的，而HashMap不是，在多個線程訪問Hashtable時，不需要自己為它的方法實現同步，而HashMap 就必須為之提供外同步。Hashtable和HashMap采用的hash/rehash算法都大概一樣，所以性能不會有很大的差異。
2.2 final， finally， finalize的區別。
final 用于聲明屬性，方法和類，分別表示屬性不可變，方法不可覆蓋，類不可繼承。
finally是異常處理語句結構的一部分，表示總是執行。
finalize是Object類的一個方法，在垃圾收集器執行的時候會調用被回收對象的此方法，可以覆蓋此方法提供垃圾收集時的其他資源回收，例如關閉文件等。
2.3 sleep（） 和 wait（） 有什么區別？
sleep是線程類（Thread）的方法，導致此線程暫停執行指定時間，給執行機會給其他線程，但是監控狀態依然保持，到時后會自動恢復。調用sleep不會釋放對象鎖。
wait是Object類的方法，對此對象調用wait方法導致本線程放棄對象鎖，進入等待此對象的等待鎖定池，只有針對此對象發出notify方法（或notifyAll）后本線程才進入對象鎖定池準備獲得對象鎖進入運行狀態。
2.4 Overload和Override的區別。Overloaded的方法是否可以改變返回值的類型？
方法的重寫Overriding和重載Overloading是Java多態性的不同表現。重寫Overriding是父類與子類之間多態性的一種表現，重載Overloading是一個類中多態性的一種表現。如果在子類中定義某方法與其父類有相同的名稱和參數，我們說該方法被重寫 （Overriding）。子類的對象使用這個方法時，將調用子類中的定義，對它而言，父類中的定義如同被"屏蔽"了。如果在一個類中定義了多個同名的方法，它們或有不同的參數個數或有不同的參數類型，則稱為方法的重載（Overloading）。Overloaded的方法是可以改變返回值的類型。
2.5 error和exception有什么區別？
error 表示恢復不是不可能但很困難的情況下的一種嚴重問題。比如說內存溢出。不可能指望程序能處理這樣的情況。
exception 表示一種設計或實現問題。也就是說，它表示如果程序運行正常，從不會發生的情況。
2.6 同步和異步有何異同，在什么情況下分別使用他們？舉例說明。
如果數據將在線程間共享。例如正在寫的數據以后可能被另一個線程讀到，或者正在讀的數據可能已經被另一個線程寫過了，那么這些數據就是共享數據，必須進行同步存取。
當應用程序在對象上調用了一個需要花費很長時間來執行的方法，并且不希望讓程序等待方法的返回時，就應該使用異步編程，在很多情況下采用異步途徑往往更有效率。
2.7 abstract class和interface有什么區別？
聲明方法的存在而不去實現它的類被叫做抽象類（abstract class），它用于要創建一個體現某些基本行為的類，并為該類聲明方法，但不能在該類中實現該類的情況。不能創建abstract 類的實例。然而可以創建一個變量，其類型是一個抽象類，并讓它指向具體子類的一個實例。不能有抽象構造函數或抽象靜態方法。Abstract 類的子類為它們父類中的所有抽象方法提供實現，否則它們也是抽象類為。取而代之，在子類中實現該方法。知道其行為的其它類可以在類中實現這些方法。
接口（interface）是抽象類的變體。在接口中，所有方法都是抽象的。多繼承性可通過實現這樣的接口而獲得。接口中的所有方法都是抽象的，沒有一個有程序體。接口只可以定義static final成員變量。接口的實現與子類相似，除了該實現類不能從接口定義中繼承行為。當類實現特殊接口時，它定義（即將程序體給予）所有這種接口的方法。然后，它可以在實現了該接口的類的任何對象上調用接口的方法。由于有抽象類，它允許使用接口名作為引用變量的類型。通常的動態聯編將生效。引用可以轉換到接口類型或從接口類型轉換，instanceof 運算符可以用來決定某對象的類是否實現了接口。
2.8 heap和stack有什么區別。
棧是一種線形集合，其添加和刪除元素的操作應在同一段完成。棧按照后進先出的方式進行處理。
堆是棧的一個組成元素。
2.9 forward 和redirect的區別
forward是服務器請求資源，服務器直接訪問目標地址的URL，把那個URL的響應內容讀取過來，然后把這些內容再發給瀏覽器，瀏覽器根本不知道服務器發送的內容是從哪兒來的，所以它的地址欄中還是原來的地址。
redirect就是服務端根據邏輯，發送一個狀態碼，告訴瀏覽器重新去請求那個地址，一般來說瀏覽器會用剛才請求的所有參數重新請求，所以session，request參數都可以獲取。
2.10 EJB與Java Bean的區別？
Java Bean 是可復用的組件，對Java Bean并沒有嚴格的規范，理論上講，任何一個Java類都可以是一個Bean.但通常情況下，由于Java Bean是被容器所創建（如Tomcat）的，所以Java Bean應具有一個無參的構造器，另外，通常Java Bean還要實現Serializable接口用于實現Bean的持久性。Java Bean實際上相當于微軟COM模型中的本地進程內COM組件，它是不能被跨進程訪問的。Enterprise Java Bean 相當于DCOM，即分布式組件。它是基于Java的遠程方法調用（RMI）技術的，所以EJB可以被遠程訪問（跨進程、跨計算機）。但EJB必須被布署在諸如Webspere、WebLogic這樣的容器中，EJB客戶從不直接訪問真正的EJB組件，而是通過其容器訪問。EJB容器是EJB組件的代理，EJB組件由容器所創建和管理。客戶通過容器來訪問真正的EJB組件。
一、面向對象的特征有哪些方面
1.抽象：
抽象就是忽略一個主題中與當前目標無關的那些方面，以便更充分地注意與當前目標有關的方面。抽象并不打算了解全部問題，而只是選擇其中的一部分，暫時不用部分細節。抽象包括兩個方面，一是過程抽象，二是數據抽象。
2.繼承：
繼承是一種聯結類的層次模型，并且允許和鼓勵類的重用，它提供了一種明確表述共性的方法。對象的一個新類可以從現有的類中派生，這個過程稱為類繼承。新類繼承了原始類的特性，新類稱為原始類的派生類（子類），而原始類稱為新類的基類（父類）。派生類可以從它的基類那里繼承方法和實例變量，并且類可以修改或增加新的方法使之更適合特殊的需要。
3.封裝：
封裝是把過程和數據包圍起來，對數據的訪問只能通過已定義的界面。面向對象計算始于這個基本概念，即現實世界可以被描繪成一系列完全自治、封裝的對象，這些對象通過一個受保護的接口訪問其他對象。
4.多態性：
多態性是指允許不同類的對象對同一消息作出響應。多態性包括參數化多態性和包含多態性。多態性語言具有靈活、抽象、行為共享、代碼共享的優勢，很好的解決了應用程序函數同名問題。
二、String是最基本的數據類型嗎？
基本數據類型包括byte、int、char、long、float、double、boolean和short. java.lang.String類是final類型的，因此不可以繼承這個類、不能修改這個類。為了提高效率節省空間，我們應該用StringBuffer類。
三、int 和 Integer 有什么區別？
Java 提供兩種不同的類型：引用類型和原始類型（或內置類型）。int是Java的原始數據類型，Integer是Java為int提供的封裝類。Java為每個原始類型提供了封裝類。
原始類型封裝類
boolean Boolean
char Character
byte Byte
short Short
int Integer
long Long
float Float
double Double
引用類型和原始類型的行為完全不同，并且它們具有不同的語義。引用類型和原始類型具有不同的特征和用法，它們包括：大小和速度問題，這種類型以哪種類型的數據結構存儲，當引用類型和原始類型用作某個類的實例數據時所指定的缺省值。對象引用實例變量的缺省值為 null，而原始類型實例變量的缺省值與它們的類型有關。
四、String 和StringBuffer的區別？
Java平臺提供了兩個類：String和StringBuffer，它們可以儲存和操作字符串，即包含多個字符的字符數據。這個String類提供了數值不可改變的字符串。而這個StringBuffer類提供的字符串進行修改。當你知道字符數據要改變的時候你就可以使用StringBuffer.典型地，你可以使用StringBuffer來動態構造字符數據。
五、運行時異常與一般異常有何異同？
異常表示程序運行過程中可能出現的非正常狀態，運行時異常表示虛擬機的通常操作中可能遇到的異常，是一種常見運行錯誤。Java編譯器要求方法必須聲明拋出可能發生的非運行時異常，但是并不要求必須聲明拋出未被捕獲的運行時異常。
六、說出Servlet的生命周期，并說出Servlet和CGI的區別。
Servlet被服務器實例化后，容器運行其init方法，請求到達時運行其service方法，service方法自動派遣運行與請求對應的doXXX方法（doGet，doPost）等，當服務器決定將實例銷毀的時候調用其destroy方法。
與CGI的區別在于Servlet處于服務器進程中，它通過多線程方式運行其service方法，一個實例可以服務于多個請求，并且其實例一般不會銷毀，而CGI對每個請求都產生新的進程，服務完成后就銷毀，所以效率上低于CGI.
七、說出ArrayList，Vector， LinkedList的存儲性能和特性
ArrayList和Vector都是使用數組方式存儲數據，此數組元素數大于實際存儲的數據以便增加和插入元素，它們都允許直接按序號索引元素，但是插入元素要涉及數組元素移動等內存操作，所以索引數據快而插入數據慢，Vector由于使用了synchronized方法（線程安全），通常性能上較ArrayList差，而LinkedList使用雙向鏈表實現存儲，按序號索引數據需要進行前向或后向遍歷，但是插入數據時只需要記錄本項的前后項即可，所以插入速度較快。
八、EJB是基于哪些技術實現的？并說出SessionBean和EntityBean的區別，StatefulBean和StatelessBean的區別。
EJB包括Session Bean、Entity Bean、Message Driven Bean，基于JNDI、RMI、JAT等技術實現。
SessionBean在J2EE應用程序中被用來完成一些服務器端的業務操作，例如訪問數據庫、調用其他EJB組件。EntityBean被用來代表應用系統中用到的數據。
對于客戶機，SessionBean是一種非持久性對象，它實現某些在服務器上運行的業務邏輯。
對于客戶機，EntityBean是一種持久性對象，它代表一個存儲在持久性存儲器中的實體的對象視圖，或是一個由現有企業應用程序實現的實體。
Session Bean 還可以再細分為 Stateful Session Bean 與 Stateless Session Bean ，這兩種的 Session Bean都可以將系統邏輯放在 method之中執行，不同的是 Stateful Session Bean 可以記錄呼叫者的狀態，因此通常來說，一個使用者會有一個相對應的 Stateful Session Bean 的實體。Stateless Session Bean 雖然也是邏輯組件，但是他卻不負責記錄使用者狀態，也就是說當使用者呼叫 Stateless Session Bean 的時候，EJB Container 并不會找尋特定的 Stateless Session Bean 的實體來執行這個 method.換言之，很可能數個使用者在執行某個 Stateless Session Bean 的 methods 時，會是同一個 Bean 的 Instance 在執行。從內存方面來看， Stateful Session Bean 與 Stateless Session Bean 比較， Stateful Session Bean 會消耗 J2EE Server 較多的內存，然而 Stateful Session Bean 的優勢卻在于他可以維持使用者的狀態。
九、Collection 和 Collections的區別。
Collection是集合類的上級接口，繼承與他的接口主要有Set 和List.
Collections是針對集合類的一個幫助類，他提供一系列靜態方法實現對各種集合的搜索、排序、線程安全化等操作。
十、&和&&的區別。
&是位運算符，表示按位與運算，&&是邏輯運算符，表示邏輯與（and）。
JVM JRE JDK，這些東西到底是什么?
我們在安裝好JDK后就可以想象成我們已經買了一臺安裝好軟件的新的電腦。
JVM : Java Virtual Machine(Java虛擬機) 。所謂“虛擬機”顧名思義就是模擬出來的東西。就像是我們在用電腦看電視，但是電腦里并沒有像電視機里面一樣的硬件支持，但是我們仍然可以從電腦里接受電視臺的節目。那是因為我們編寫了一個可以模擬電視機硬件工作的軟件運行在電腦的平臺上面的原因。同樣JVM就是模擬了電腦的硬件，它同樣有著像CPU一樣可以執行代碼的功能。它的實現具體有：指令集 寄存器組 類文件格式 棧 垃圾收集堆 內存區。可以把它理解成是專門用來執行Java程序的一臺機器。也就是說JVM提供了Java執行的硬件平臺。JVM上執行的代碼都存放在 .CLASS 文件中。JVM只執行字節碼文件。
JRE : Java Runtime Environment(Java運行環境)。就是可以運行Java程序的地方。就像是我們要在電腦上運行一個視頻軟件的時候必須在Windos或者是Linux等操作系統上一樣。那我們就可以把它看做是一個操作系統。也就是說JRE提供了Java執行的軟件平臺。在運行Java的過程中除了需要有JVM執行Java代碼這個動作外，還需要Java API(Application Programming Interface,應用編程接口)說簡單的就是“類庫”。Java程序在運行中沒有這些API是不行的，所以JRE包含JVM。
JDK : Java Development ToolKit(Java開發工具包)。我們有了硬件和軟件兩個平臺后就可以做我們自己想做的事情了。JDK就是我們用來做事情的工具，它包括JRE還有其他工具。我們所說版本的不同，也就是說它里面的工具有差異。就像是你不同的工具箱里放著不同的工具一樣。舉個例子：最常用的一個就是javac,它是把.java的文件翻譯成.class文件的工具。然后讓JVM來執行.class文件中的字節碼。(就像電腦的CPU只認識0或1的道理)
如果一臺計算機的需求只是運行Java程序，而不是去編寫Java程序的時候，它只需要安裝JRE就可以了。現在大家知道JVM JRE JDK，這些東西到底是什么了吧。
摘要：本文從
Java異常最基本的概念、語法開始講述了
Java異常處理的基本知識，分析了Java異常體系結構，對比Spring的異常處理框架，闡述了異常處理的基本原則。并且作者提出了自己處理一個大型應用系統異常的思想，并通過設計一個異常處理的框架來論述此思想。
一、 異常的概念和Java異常體系結構
異常是程序運行過程中出現的錯誤。本文主要講授的是Java語言的異常處理。Java語言的異常處理框架，是Java語言健壯性的一個重要體現。
Java把異常當作對象來處理，并定義一個基類java.lang.Throwable作為所有異常的超類。在Java API中已經定義了許多異常類，這些異常類分為兩大類，錯誤Error和異常Exception。Java異常體系結構呈樹狀，其層次結構圖如圖 1所示：
Thorwable類所有異常和錯誤的超類，有兩個子類Error和Exception，分別表示錯誤和異常。其中異常類Exception又分為運行時異常(RuntimeException)和非運行時異常，這兩種異常有很大的區別，也稱之為不檢查異常（Unchecked Exception）和檢查異常（Checked Exception）。下面將詳細講述這些異常之間的區別與聯系：
1、Error與Exception
Error是程序無法處理的錯誤，比如OutOfMemoryError、ThreadDeath等。這些異常發生時，Java虛擬機（JVM）一般會選擇線程終止。
Exception是程序本身可以處理的異常，這種異常分兩大類運行時異常和非運行時異常。程序中應當盡可能去處理這些異常。
2、運行時異常和非運行時異常
運行時異常都是RuntimeException類及其子類異常，如NullPointerException、IndexOutOfBoundsException等，這些異常是不檢查異常，程序中可以選擇捕獲處理，也可以不處理。這些異常一般是由程序邏輯錯誤引起的，程序應該從邏輯角度盡可能避免這類異常的發生。
非運行時異常是RuntimeException以外的異常，類型上都屬于Exception類及其子類。從程序語法角度講是必須進行處理的異常，如果不處理，程序就不能編譯通過。如IOException、SQLException等以及用戶自定義的Exception異常，一般情況下不自定義檢查異常。
二、 異常的捕獲和處理
Java異常的捕獲和處理是一個不容易把握的事情，如果處理不當，不但會讓程序代碼的可讀性大大降低，而且導致系統性能低下，甚至引發一些難以發現的錯誤。
Java異常處理涉及到五個關鍵字，分別是：try、catch、finally、throw、throws。下面將驟一介紹，通過認識這五個關鍵字，掌握基本異常處理知識。
1、 異常處理的基本語法
在java中，異常處理的完整語法是：
try{
//（嘗試運行的）程序代碼
}catch(異常類型 異常的變量名){
//異常處理代碼
}finally{
//異常發生，方法返回之前，總是要執行的代碼
} |
以上語法有三個代碼塊：
try語句塊，表示要嘗試運行代碼，try語句塊中代碼受異常監控，其中代碼發生異常時，會拋出異常對象。
catch語句塊會捕獲try代碼塊中發生的異常并在其代碼塊中做異常處理，catch語句帶一個Throwable類型的參數，表示可捕獲異常類型。當try中出現異常時，catch會捕獲到發生的異常，并和自己的異常類型匹配，若匹配，則執行catch塊中代碼，并將catch塊參數指向所拋的異常對象。catch語句可以有多個，用來匹配多個中的一個異常，一旦匹配上后，就不再嘗試匹配別的catch塊了。通過異常對象可以獲取異常發生時完整的JVM堆棧信息，以及異常信息和異常發生的原因等。
finally語句塊是緊跟catch語句后的語句塊，這個語句塊總是會在方法返回前執行，而不管是否try語句塊是否發生異常。并且這個語句塊總是在方法返回前執行。目的是給程序一個補救的機會。這樣做也體現了Java語言的健壯性。
2、 try、catch、finally三個語句塊應注意的問題
第一、try、catch、finally三個語句塊均不能單獨使用，三者可以組成 try...catch...finally、try...catch、try...finally三種結構，catch語句可以有一個或多個，finally語句最多一個。
第二、try、catch、finally三個代碼塊中變量的作用域為代碼塊內部，分別獨立而不能相互訪問。如果要在三個塊中都可以訪問，則需要將變量定義到這些塊的外面。
第三、多個catch塊時候，只會匹配其中一個異常類并執行catch塊代碼，而不會再執行別的catch塊，并且匹配catch語句的順序是由上到下。
3、throw、throws關鍵字
throw關鍵字是用于方法體內部，用來拋出一個Throwable類型的異常。如果拋出了檢查異常，則還應該在方法頭部聲明方法可能拋出的異常類型。該方法的調用者也必須檢查處理拋出的異常。如果所有方法都層層上拋獲取的異常，最終JVM會進行處理，處理也很簡單，就是打印異常消息和堆棧信息。如果拋出的是Error或RuntimeException，則該方法的調用者可選擇處理該異常。有關異常的轉譯會在下面說明。
throws關鍵字用于方法體外部的方法聲明部分，用來聲明方法可能會拋出某些異常。僅當拋出了檢查異常，該方法的調用者才必須處理或者重新拋出該異常。當方法的調用者無力處理該異常的時候，應該繼續拋出，而不是囫圇吞棗一般在catch塊中打印一下堆棧信息做個勉強處理。下面給出一個簡單例子，看看如何使用這兩個關鍵字：
public static void test3() throws Exception{
//拋出一個檢查異常
throw new Exception("方法test3中的Exception");
}
3、 Throwable類中的常用方法
getCause()：返回拋出異常的原因。如果 cause 不存在或未知，則返回 null。
getMessage()：返回異常的消息信息。
printStackTrace()：對象的堆棧跟蹤輸出至錯誤輸出流，作為字段 System.err 的值。
|
三、 異常處理的一般原則
1、 能處理就早處理，拋出不去還不能處理的就想法消化掉或者轉換為RuntimeException處理。因為對于一個應用系統來說，拋出大量異常是有問題的，應該從程序開發角度盡可能的控制異常發生的可能。
2、 對于檢查異常，如果不能行之有效的處理，還不如轉換為RuntimeException拋出。這樣也讓上層的代碼有選擇的余地――可處理也可不處理。
3、 對于一個應用系統來說，應該有自己的一套異常處理框架，這樣當異常發生時，也能得到統一的處理風格，將優雅的異常信息反饋給用戶。
四、 異常的轉譯與異常鏈
1、異常轉譯的原理
所謂的異常轉譯就是將一種異常轉換另一種新的異常，也許這種新的異常更能準確表達程序發生異常。
在Java中有個概念就是異常原因，異常原因導致當前拋出異常的那個異常對象，幾乎所有帶異常原因的異常構造方法都使用Throwable類型做參數，這也就為異常的轉譯提供了直接的支持，因為任何形式的異常和錯誤都是Throwable的子類。比如將SQLException轉換為另外一個新的異常DAOException，可以這么寫：
先自定義一個異常DAOException：
public class DAOException extends RuntimeException {
//(省略了部分代碼)
public DAOException(String message, Throwable cause) {
super(message, cause);
}
} |
比如有一個SQLException類型的異常對象e，要轉換為DAOException，可以這么寫：
DAOException daoEx = new DAOException ( "SQL異常", e);
異常轉譯是針對所有繼承Throwable超類的類而言的，從編程的語法角度講，其子類之間都可以相互轉換。但是，從合理性和系統設計角度考慮，可將異常分為三類：Error、Exception、RuntimeException，筆者認為，合理的轉譯關系圖應該如圖 2：
圖 2 異常轉譯
為什么要這么做呢？筆者認為，異常的處理存在著一套哲學思想：對于一個應用系統來說，系統所發生的任何異常或者錯誤對操作用戶來說都是系統"運行時"異常，都是這個應用系統內部的異常。這也是異常轉譯和應用系統異常框架設計的指導原則。在系統中大量處理非檢查異常的負面影響很多，最重要的一個方面就是代碼可讀性降低，程序編寫復雜，異常處理的代碼也很蒼白無力。因此，很有必要將這些檢查異常Exception和錯誤Error轉換為RuntimeException異常，讓程序員根據情況來決定是否捕獲和處理所發生的異常。
圖中的三條線標識轉換的方向，分三種情況：
①：Error到Exception：將錯誤轉換為異常，并繼續拋出。例如Spring WEB框架中，將org.springframework.web.servlet.DispatcherServlet的doDispatch()方法中，將捕獲的錯誤轉譯為一個NestedServletException異常。這樣做的目的是為了最大限度挽回因錯誤發生帶來的負面影響。因為一個Error常常是很嚴重的錯誤，可能會引起系統掛起。
②：Exception到RuntimeException：將檢查異常轉換為RuntimeException可以讓程序代碼變得更優雅，讓開發人員集中經理設計更合理的程序代碼，反過來也增加了系統發生異常的可能性。
③：Error到RuntimeException：目的還是一樣的。把所有的異常和錯誤轉譯為不檢查異常，這樣可以讓代碼更為簡潔，還有利于對錯誤和異常信息的統一處理。
1、 異常鏈
異常鏈顧名思義就是將異常發生的原因一個傳一個串起來，即把底層的異常信息傳給上層，這樣逐層拋出。Java API文檔中給出了一個簡單的模型：
try {
lowLevelOp();
} catch (LowLevelException le) {
throw (HighLevelException)
new HighLevelException().initCause(le);
} |
當程序捕獲到了一個底層異常le，在處理部分選擇了繼續拋出一個更高級別的新異常給此方法的調用者。這樣異常的原因就會逐層傳遞。這樣，位于高層的異常遞歸調用getCause()方法，就可以遍歷各層的異常原因。這就是Java異常鏈的原理。異常鏈的實際應用很少，發生異常時候逐層上拋不是個好注意，上層拿到這些異常又能奈之何？而且異常逐層上拋會消耗大量資源，因為要保存一個完整的異常鏈信息
五、 設計一個高效合理的異常處理框架
對于一個應用系統來說，發生所有異常在用戶看來都是應用系統內部的異常。因此應該設計一套應用系統的異常框架，以處理系統運行過程中的所有異常。
基于這種觀點，可以設計一個應用系統的異常比如叫做AppException。并且對用戶來說，這些異常都是運行應用系統運行時發生的，因此AppException應該繼承RuntimeException，這樣系統中所有的其他異常都轉譯為AppException，當異常發生的時候，前端接收到AppExcetpion并做統一的處理。畫出異常處理框架如圖 3 ：
圖 3 一個應用系統的異常處理框架
在這個設計圖中，AppRuntimeException是系統異常的基類，對外只拋出這個異常，這個異常可以由前端（客戶端）接收處理，當異常發生時，客戶端的相關組件捕獲并處理這些異常，將"友好"的信息展示給客戶。
在AppRuntimeException下層，有各種各樣的異常和錯誤，最終都轉譯為AppRuntimeException，AppRuntimeException下面還可以設計一些別的子類異常，比如AppDAOException、OtherException等，這些都根據實際需要靈活處理。在往下就是如何將捕獲的原始異常比如SQLException、HibernateException轉換為更高級一點AppDAOException。
有關異常框架設計這方面公認比較好的就是Spring，Spring中的所有異常都可以用org.springframework.core.NestedRuntimeException來表示，并且該基類繼承的是RuntimeException。Spring框架很龐大，因此設計了很多NestedRuntimeException的子類，還有異常轉換的工具，這些都是非常優秀的設計思想。
六、 Java異常處理總結
回顧全文，總結一下Java異常處理的要點：
1、 異常是程序運行過程過程出現的錯誤，在Java中用類來描述，用對象來表示具體的異常。Java將其區分為Error與Exception，Error是程序無力處理的錯誤，Exception是程序可以處理的錯誤。異常處理是為了程序的健壯性。
2、 Java異常類來自于Java API定義和用戶擴展。通過繼承Java API異常類可以實現異常的轉譯。
3、 異常能處理就處理，不能處理就拋出，最終沒有處理的異常JVM會進行處理。
4、 異常可以傳播，也可以相互轉譯，但應該根據需要選擇合理的異常轉譯的方向。
5、 對于一個應用系統，設計一套良好的異常處理體系很重要。這一點在系統設計的時候就應該考慮到。
轉自:http://forum.hibernate.org.cn
作者:robbin
Java Learning Path （一）、工具篇
一、 JDK (Java Development Kit)
JDK是整個Java的核心，包括了Java運行環境（Java Runtime
Envirnment），一堆Java工具和Java基礎的類庫(rt.jar)。不論什么Java應用服務器實質都是內置了某個版本的JDK。因此掌握
JDK是學好Java的第一步。最主流的JDK是Sun公司發布的JDK，除了Sun之外，還有很多公司和組織都開發了自己的JDK，例如IBM公司開發
的JDK，BEA公司的Jrocket，還有GNU組織開發的JDK等等。其中IBM的JDK包含的JVM（Java Virtual
Machine）運行效率要比Sun JDK包含的JVM高出許多。而專門運行在x86平臺的Jrocket在服務端運行效率也要比Sun
JDK好很多。但不管怎么說，我們還是需要先把Sun JDK掌握好。
1、 JDK的下載和安裝
JDK又叫做J2SE（Java2 SDK Standard
Edition），可以從Sun的Java網站上下載到，http://java.sun.com/j2se/downloads.html
，JDK當前最新的版本是J2SDK1.4.2，建議下載該版本的JDK，下載頁面在這里：http://java.sun.com/j2se
/1.4.2/download.html。
下載好的JDK是一個可執行安裝程序，默認安裝完畢后會在C:\Program
Files\Java\目錄下安裝一套JRE（供瀏覽器來使用），在C:\j2sdk1.4.2下安裝一套JDK（也包括一套JRE）。然后我們需要在環
境變量PATH的最前面增加java的路徑C:\j2sdk1.4.2\bin。這樣JDK就安裝好了。
2、 JDK的命令工具
JDK的最重要命令行工具：
java： 啟動JVM執行class
javac： Java編譯器
jar： Java打包工具
javadoc： Java文檔生成器
這些命令行必須要非常非常熟悉，對于每個參數都要很精通才行。對于這些命令的學習，JDK Documentation上有詳細的文檔。
二、 JDK Documentation
Documentation在JDK的下載頁面也有下載連接，建議同時下載Documentation。Documentation是最最重要的編程手
冊，涵蓋了整個Java所有方面的內容的描述。可以這樣說，學習Java編程，大部分時間都是花在看這個Documentation上面的。我是隨身攜帶
的，寫Java代碼的時候，隨時查看，須臾不離手。
三、 應用服務器(App Server)
App Server是運行Java企業組件的平臺，構成了應用軟件的主要運行環境。當前主流的App Server是BEA公司的Weblogic
Server和IBM公司的Websphere以及免費的Jboss，選擇其中一個進行學習就可以了，個人推薦Weblogic，因為它的體系結構更加干
凈，開發和部署更加方便，是Java企業軟件開發人員首選的開發平臺。下面簡要介紹幾種常用的App Server：
1、 Tomcat
Tomcat嚴格意義上并不是一個真正的App
Server，它只是一個可以支持運行Serlvet/JSP的Web容器，不過Tomcat也擴展了一些App
Server的功能，如JNDI，數據庫連接池，用戶事務處理等等。Tomcat被非常廣泛的應用在中小規模的Java
Web應用中，因此本文做一點下載、安裝和配置Tomcat的介紹：
Tomcat是Apache組織下Jakarta項目下的一個子項目，它的主網站是：http://jakarta.apache.org/tomcat
/
，Tomcat最新版本是Tomcat4.1.27，軟件下載的連接是：http://www.apache.org/dist/jakarta
/tomcat-4/binaries/ 。
下載Tomcat既可以直接下載zip包，也可以下載exe安裝包（個人建議zip更干凈些），不管哪種情況，下載完畢安裝好以后（zip直接解壓縮就可以了）。需要設置兩個環境變量：
JAVA_HOME=C:\j2sdk1.4.2
CATALINA_HOME=D:\tomcat4 (你的Tomcat安裝目錄)
這樣就安裝好了，啟動Tomcat運行CATALINA_HOME\bin\startup.bat，關閉Tomcat運行shutdown.bat腳
本。Tomcat啟動以后，默認使用8080端口，因此可以用瀏覽器訪問http://localhost:8080來測試Tomcat是否正常啟動。
Tomcat提供了兩個Web界面的管理工具，URL分別是：
http://localhost:8080/admin/index.jsp
http://localhost:8080/manager/html
在啟用這兩個管理工具之前，先需要手工配置一下管理員用戶和口令。用一個文本工具打開CATALINA_HOME\conf\tomcat-users.xml這個文件，加入如下幾行：
<role rolename="manager"/>;
<role rolename="admin"/>;
<user username="robbin" password="12345678" roles="admin,manager,tomcat"/>;
這樣用戶“robbin”就具備了超級管理員權限。重新啟動Tomcat以后，你就可以使用該用戶來登陸如上的兩個管理工具，通過Web方式進行Tomcat的配置和管理了。
2、 BEA Weblogic
Weblogic可以到BEA的網站上免費注冊之后下載到最新的Weblogic8.1企業版，License可以免費使用1年時間，其實這已經完全足夠
了。Weblogic的下載連接：http://commerce.bea.com/index.jsp，Weblogic的在線文檔：http:
//edocs.bea.com/ 。
3、 IBM Webshpere
Websphere同樣可以下載到免費的試用版本，到IBM的developerWorks網站可以看到Websphere試用產品的下載和相關的
Websphere的資料，developerWorks中文網站的連接是：http://www-900.ibm.com
/developerWorks/cn/wsdd/
，Websphere的下載連接：http://www7b.software.ibm.com/wsdd/downloads
/WASsupport.html 。
4、 Jboss
Jboss是免費開源的App
Server，可以免費的從Jboss網站下載：http://www.jboss.org/index.html，然而Jboss的文檔是不免費，需要
花錢購買，所以為我們學習Jboss設置了一定的障礙。在Jdon上有幾篇不錯的Jboss配置文檔，可以用來參
考：http://www.jdon.com/idea.html
四、 Java應用的運行環境
Java的應用可以簡單分為以下幾個方面：
1、 Java的桌面應用
桌面應用一般僅僅需要JRE的支持就足夠了。
2、 Java Web應用
Java的Web應用至少需要安裝JDK和一個web容器（例如Tomcat），以及一個多用戶數據庫，Web應用至少分為三層：
Browser層：瀏覽器顯示用戶頁面
Web層：運行Servlet/JSP
DB層：后端數據庫，向Java程序提供數據訪問服務
3、 Java企業級應用
企業級應用比較復雜，可以擴展到n層，最簡單情況會分為4層：
Browser層：瀏覽器顯示用戶頁面
Client層：Java客戶端圖形程序（或者嵌入式設備的程序）直接和Web層或者EJB層交互
Web層：運行Servlet/JSP
EJB層：運行EJB，完成業務邏輯運算
DB層：后端數據庫，向Java程序提供數據訪問服務
4、 Java嵌入式應用
Java嵌入式應用是一個方興未艾的領域，從事嵌入式開發，需要從Sun下載J2ME開發包，J2ME包含了嵌入式設備專用虛擬機KVM，和普通的JDK中包含的JVM有所不同。另外還需要到特定的嵌入式廠商那里下載模擬器。
Java Learning Path（二）、書籍篇
學習一門新的知識，不可能指望只看一本，或者兩本書就能夠完全掌握。需要有一個循序漸進的閱讀過程。我推薦Oreilly出版的Java系列書籍。
在這里我只想補充一點看法，很多人學習Java是從《Thinking in
Java》這本書入手的，但是我認為這本書是不適合初學者的。我認為正確的使用這本書的方法應該是作為輔助的讀物。《Thinking in
Java》并不是在完整的介紹Java的整個體系，而是一種跳躍式的寫作方法，是一種類似tips的方法來對Java很多知識點進行了深入的分析和解釋。
對于初學者來說，最好是找一本Java入門的書籍，但是比較完整的循序的介紹Java的語法，面向對象的特性，核心類庫等等，在看這本書的同時，
可以同步來看《Thinking in Java》，來加深對Java的理解和原理的運用，同時又可以完整的了解Java的整個體系。
對于Java的入門書籍，蔡學鏞推薦的是Oreilly的《Exploring Java, 2nd Edition》 或者《Java in a
Nutshell,2nd Edition（針對C++背景）》，我并沒有看過這兩本書。其實我覺得電子工業出版社的《Java
2編程詳解》或者《Java 2從入門到精通》就很不錯。
在所有的Java書籍當中，其實最最有用的，并不是O'reilly的 Java
Serials，真正最最有用處是JDK的Documentation！幾乎你想獲得的所有的知識在Documentation里面全部都有，其中最主要
的部分當然是Java基礎類庫的API文檔，是按照package來組織的，對于每一個class都有詳細的解釋，它的繼承關系，是否實現了某個接口，通
常用在哪些場合，還可以查到它所有的public的屬性和方法，每個屬性的解釋，意義，每個方法的用途，調用的參數，參數的意義，返回值的類型，以及方法
可能拋出的異常等等。可以這樣來說，所有關于Java編程方面的書籍其實都不過是在用比較通俗易懂的語言，和良好的組織方式來介紹
Documentation里面的某個package里面包含的一些類的用法而已。所以萬變不離其宗，如果你有足夠的能力來直接通過
Documentation來學習Java的類庫，那么基本上就不需要看其他的書籍了。除此之外，Documentation也是編程必備的手冊，我的桌
面上有三個Documentation的快捷方式，分別是J2SDK1.4.1的Documentation，Servlet2.3的
Documentation和J2SDKEE1.3.1的Documentation。有了這個三個Documentation，什么其他的書籍都不需要
了。
對于Java Web
編程來說，最核心的是要熟悉和掌握HTTP協議，這個就和Java無關了，在熟悉HTTP協議之后，就需要熟悉Java的實現HTTP協議的類庫，也就是
Servlet API，所以最重要的東西就是Servlet API。當然對于初學者而言，直接通過Servlet
API來學習Web編程有很大的難度，我推薦O'reilly的《Java Server Pages 》這本書來學習Web 編程。
EJB的書籍當中，《Enterprise JavaBeans, 2nd Edition》是一本很不錯的書，
EJB的學習門檻是比較高，入門很難，但是這本書完全降低了學習的難度，特別重要的一點是，EJB的學習需要結合一種App
Server的具體實現，所以在學習EJB的同時，必須同步的學習某種App
Server，而這本書相關的出了三本書，分別是Weblogic6.1，Websphere4.0和JBoss3.0上面部署書中例子的實做。真是既有
理論，又有實踐。在學習EJB的同時，可以邊看邊做，EJB的學習會變得很輕松。
但是這本書也有一個問題，就是版本比較舊，主要講EJB1.1規范和部分EJB2.0的規范。而Ed Roman寫的《Mastering EJB
2.0》這本書完全是根據EJB2.0規范寫的，深入淺出，覆蓋了EJB編程的各個方面，并且還有很多編程經驗tips，也是學習EJB非常推薦的書籍之
一。
如果是結合Weblogic來學習J2EE的話，《J2EE應用與BEA Weblogic
Server》絕對是首選讀物，雖然是講述的Weblogic6.0，仍然值得購買，這本書是BEA官方推薦的教材，作者也是BEA公司的工程師。現在中
文版已經隨處可見了。這本書結合Weblogic介紹了J2EE各個方面的技術在Weblogic平臺上的開發和部署，實踐指導意義非常強。
在掌握了Java平臺基礎知識和J2EE方面的知識以后，更進一步的是學習如何運用OO的方法進行軟件的設計，那么就一定要學習“設計模式”。Sun公司
出版了一本《J2EE核心模式》，是每個開發Java企業平臺軟件的架構師必備的書籍。這本書全面的介紹了J2EE體系架構的各種設計模式，是設計師的必
讀書籍。
Java Learning Path（三）過程篇
每個人的學習方法是不同的，一個人的方法不見得適合另一個人，我只能是談自己的學習方法。因為我學習Java是完全自學的，從來沒有問過別人，所以學習的過程基本上完全是自己摸索出來的。我也不知道這種方法是否是比較好的方法，只能給大家提供一點參考了。
學習Java的第一步是安裝好JDK，寫一個Hello World，?
其實JDK的學習沒有那么簡單，關于JDK有兩個問題是很容易一直困擾Java程序員的地方：一個是CLASSPATH的問題，其實從原理上來說，是要搞
清楚JRE的ClassLoader是如何加載Class的；另一個問題是package和import問題，如何來尋找類的路徑問題。把這兩個問題摸索
清楚了，就掃除了學習Java和使用JDK的最大障礙。推薦看一下王森的《Java深度歷險》，對這兩個問題進行了深入的探討。
第二步是學習Java的語法。Java的語法是類C++的，基本上主流的編程語言不是類C，就是類C++的，沒有什么新東西，所以語法的學習，大概就是半
天的時間足夠了。唯一需要注意的是有幾個不容易搞清楚的關鍵字的用法，public，protected，private，static，什么時候用，為
什么要用，怎么用，這可能需要有人來指點一下，我當初是完全自己琢磨出來的，花了很久的時間。不過后來我看到《Thinking in
Java》這本書上面是講了這些概念的。
第三步是學習Java的面向對象的編程語言的特性的地方。比如繼承，構造器，抽象類，接口，方法的多態，重載，覆蓋，Java的異常處理機制。對于一個沒
有面向對象語言背景的人來說，我覺得這個過程需要花很長很長時間，因為學習Java之前沒有C++的經驗，只有C的經驗，我是大概花了一個月左右吧，才徹
底把這些概念都搞清楚，把書上面的例子反復的揣摩，修改，嘗試，把那幾章內容反復的看過來，看過去，看了不下5遍，才徹底領悟了。不過我想如果有C++經
驗的話，應該一兩天時間足夠了。那么在這個過程中，可以多看看《Thinking in
Java》這本書，對面向對象的講解非常透徹。可惜的是我學習的時候，并沒有看到這本書，所以自己花了大量的時間，通過自己的嘗試和揣摩來學會的。
第四步就是開始熟悉Java的類庫。Java的基礎類庫其實就是JDK安裝目錄下面jre\lib\rt.jar這個包。學習基礎類庫就是學習rt.jar。基礎類庫里面的類非常非常多。據說有3000多個，我沒有統計過。但是真正對于我們來說最核心的只有4個，分別是
java.lang.*;
java.io.*;
java.util.*;
java.sql.*;
這四個包的學習，每個包的學習都可以寫成一本厚厚的教材，而O'reilly也確實是這樣做的。我覺得如果時間比較緊，是不可能通過讀四本書來學習。我覺得比較好的學習方法是這樣的：
首先要通讀整個package的框架，了解整個package的class，interface，exception的構成，最好是能夠找到介紹整個包框架的文章。這些專門介紹包的書籍的前幾章應該就是這些總體的框架內容介紹。
對包整體框架的把握并不是要熟悉每個類的用法，記住它有哪些屬性，方法。想記也記不住的。而是要知道包有哪些方面的類構成的，這些類的用途是什么，最核心
的幾個類分別是完成什么功能的。我在給人培訓的時候一般是一次課講一個包，所以不可能詳細的介紹每個類的用法，但是我反復強調，我給你們講這些包的不是要
告訴你們類的方法是怎么調用的，也不要求你們記住類的方法調用，而是要你們了解，Java給我們提供了哪些類，每個類是用在什么場合，當我遇到問題的時
候，我知道哪個類，或者哪幾個類的組合可以解決我的問題，That'all！，當我們具體寫程序的時候，只要你知道該用哪個類來完成你的工作就足夠了。編
碼的時候，具體的方法調用，是邊寫代碼，邊查Documentation，所有的東西都在Documentation里面，不要求你一定記住，實際你也記
不住3000多個類的總共將近10萬個方法調用。所以對每個包的總體框架的把握就變得極為重要。
第五步，通過上面的學習，如果學的比較扎實的話，就打好了Java的基礎了，剩下要做的工作是掃清Documentation里面除了上面4個包之外的其
他一些比較有用處的類。相信進展到這一步，Java的自學能力已經被培養出來了，可以到了直接學習Documentation的水平了。除了要做GUI編
程之外，JDK里面其他會有用處的包是這些：
java.text.*;
java.net.*;
javax.naming.*;
這些包里面真正用的比較多的類其實很少，只有幾個，所以不需要花很多時間。
第六步，Java Web 編程
Web編程的核心是HTTP協議，HTTP協議和Java無關，如果不熟悉HTTP協議的話，雖然也可以學好Servlet/JSP編程，但是達不到舉一
反三，一通百通的境界。所以HTTP協議的學習是必備的。如果熟悉了HTTP協議的話，又有了Java編程的良好的基礎，學習Servlet/JSP簡直
易如反掌，我學習Servlet/JSP就用了不到一周的時間，然后就開始用JSP來做項目了。
在Servlet/JSP的學習中，重頭仍然是Servlet Documentation。Servlet
API最常用的類很少，花比較少的時間就可以掌握了。把這些類都看一遍，多寫幾個例子試試。Servlet/JSP編程本質就是在反復調用這些類來通過
HTTP協議在Web Server和Brower之間交談。另外對JSP，還需要熟悉幾個常用JSP的標記，具體的寫法記不住的話，臨時查就是了。
此外Java Web編程學習的重點要放在Web
Application的設計模式上，如何進行業務邏輯的分析，并且進行合理的設計，按照MVC設計模式的要求，運用Servlet和JSP分別完成不同
的邏輯層，掌握如何在Servlet和JSP之間進行流程的控制和數據的共享，以及Web Application應該如何配置和部署。
第七步，J2EE編程
以上的學習過程如果是比較順利的話，進行到這一步，難度又陡然提高。因為上面的知識內容都是只涉及一個方面，而像EJB，JMS，JTA等核心的J2EE規范往往是幾種Java技術的綜合運用的結晶，所以掌握起來難度比較大。
首先一定要學習好JNDI，JNDI是App
Server定位服務器資源（EJB組件，Datasouce，JMS）查找方法，如果對JNDI不熟悉的話，EJB，JMS這些東西幾乎學不下去。
JNDI其實就是javax.naming.*這個包，運用起來很簡單。難點在于服務器資源文件的配置。對于服務器資源文件的配置，就需要看看專門的文檔
規范了，比如web.xml的寫法，ejb-jar.xml的寫法等等。針對每種不同的App
Server，還有自己的服務資源配置文件，也是需要熟悉的。
然后可以學習JTA，主要是要理解JTA對于事務的控制的方法，以及該在什么場合使用JTA。這里可以簡單的舉個例子，我們知道一般情況可以對于一個數據
庫連接進行事務控制(conn.setAutoCommit(false),....,conn.commit())，做為一個原子操作，但是假設我的業
務需求是要把對兩個不同數據庫的操作做為一個原子操作，你能做的到嗎？這時候只能用JTA了。假設操作過程是先往A數據庫插一條記錄，然后刪除B數據庫另
一個記錄，我們自己寫代碼是控制不了把整個操作做為一個原子操作的。用JTA的話，由App Server來完成控制。
在學習EJB之前要學習對象序列化和RMI，RMI是EJB的基礎。接著學習JMS和EJB，對于EJB來說，最關鍵是要理解EJB是如何通過RMI來實現對遠端對象的調用的，以及在什么情況下要用到EJB。
在學習完EJB，JMS這些東西之后，你可能會意識到要急不可待學習兩個領域的知識，一個是UML，另一個是Design
Pattern。Java企業軟件的設計非常重視框架(Framework)的設計，一個好的軟件框架是軟件開發成功的必要條件。在這個時候，應該開始把
學習的重點放在設計模式和框架的學習上，通過學習和實際的編程經驗來掌握EJB的設計模式和J2EE的核心模式。
J2EE規范里面，除了EJB，JMS，JTA，Servlet/JSP，JDBC之外還有很多很多的企業技術，這里不一一進行介紹了。
另外還有一個最新領域Web Services。Web
Services也完全沒有任何新東西，它像是一種黏合劑，可以把不同的服務統一起來提供一個統一的調用接口，作為使用者來說，我只要獲得服務提供者給我
的WSDL（對服務的描述），就夠了，我完全不知道服務器提供者提供的服務究竟是EJB組件，還是.Net組件，還是什么CORBA組件，還是其他的什么
實現，我也不需要知道。Web
Services最偉大的地方就在于通過統一的服務提供方式和調用方式，實現了整個Internet服務的共享，是一個非常令人激動的技術領域。Web
Services好像目前還沒有什么很好的書籍，但是可以通過在網絡上面查資料的方式來學習。
Java Learning Path（四） 方法篇
Java作為一門編程語言，最好的學習方法就是寫代碼。當你學習一個類以后，你就可以自己寫個簡單的例子程序來運行一下，看看有什么結果，然后再多調用幾
個類的方法，看看運行結果，這樣非常直觀的把類給學會了，而且記憶非常深刻。然后不應該滿足把代碼調通，你應該想想看如果我不這樣寫，換個方式，再試試行
不行。記得哪個高人說過學習編程就是個破壞的過程，把書上的例子，自己學習Documentation編寫的例子在運行通過以后，不斷的嘗試著用不同的方
法實現，不斷的嘗試破壞代碼的結構，看看它會有什么結果。通過這樣的方式，你會很徹底的很精通的掌握Java。
舉個例子，我們都編過Hello World
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello World"
;
}
}
很多初學者不是很理解為什么main方法一定要這樣來定義public static void main(String[]
args)，能不能不這樣寫？包括我剛學習Java的時候也有這樣的疑問。想知道答案嗎？很簡單，你把main改個名字運行一下，看看報什么錯誤，然后根
據出錯信息進行分析；把main的public取掉，在試試看，報什么錯誤；static去掉還能不能運行；不知道main方法是否一定要傳一個
String[]數組的，把String[]改掉，改成int[]，或者String試試看；不知道是否必須寫args參數名稱的，也可以把args改成
別的名字，看看運行結果如何。
我當初學習Java的時候就是這樣做的，把Hello World程序反復改了七八次，不斷運行，分析運行結果，最后就徹底明白為什么了main方法是這樣定義的了。
此外，我對于staic，public，private，Exception，try{ }catch
{}finally{}等等等等一開始都不是很懂，都是把參考書上面的例子運行成功，然后就開始破壞它，不斷的根據自己心里面的疑問來重新改寫程序，看看
能不能運行，運行出來是個什么樣子，是否可以得到預期的結果。這樣雖然比較費時間，不過一個例子程序這樣反復破壞幾次之后。我就對這個相關的知識徹底學通
了。有時候甚至故意寫一些錯誤的代碼來運行，看看能否得到預期的運行錯誤。這樣對于編程的掌握是及其深刻的。
其中特別值得一提的是JDK有一個非常棒的調試功能，-verbose
java –verbose
javac –verbose 以及其它很多JDK工具都有這個選項
-verbose 可以顯示在命令執行的過程中，JVM都依次加載哪里Class，通過這些寶貴的調試信息，可以幫助我們分析出JVM在執行的過程中都干了些什么。
另外，自己在學習過程中，寫的很多的這種破壞例程，應該有意識的分門別類的保存下來，在工作中積累的典型例程也應該定期整理，日積月累，自己就有了一個代
碼庫了。遇到類似的問題，到代碼庫里面 Copy & Paste ，Search &
Replace，就好了，極大提高了開發速度。最理想的情況是把一些通用的例程自己再抽象一層，形成一個通用的類庫，封裝好。那么可復用性就更強了。
所以我覺得其實不是特別需要例程的，自己寫的破壞例程就是最好的例子，如果你實在對自己寫的代碼不放心的話，我強烈推薦你看看JDK基礎類庫的Java源
代碼。在JDK安裝目錄下面會有一個src.zip，解開來就可以完整的看到整個JDK基礎類庫，也就是rt.jar的Java源代碼，你可以參考一下
Sun是怎么寫Java程序的，規范是什么樣子的。我自己在學習Java的類庫的時候，當有些地方理解的不是很清楚的時候，或者想更加清晰的理解運作的細
節的時候，往往會打開相應的類的源代碼，通過看源代碼，所有的問題都會一掃而空。
Java Learning Path（五）資源篇
1、 http://java.sun.com/ (英文)
Sun的Java網站，是一個應該經常去看的地方。不用多說。
2、http://www-900.ibm.com/developerWorks/cn/
IBM的developerWorks網站，英語好的直接去英文主站點看。這里不但是一個極好的面向對象的分析設計網站，也是Web Services，Java，Linux極好的網站。強烈推薦！！！
3、http://www.javaworld.com/ (英文)
關于Java很多新技術的討論和新聞。想多了解Java的方方面面的應用，這里比較好。
4、http://dev2dev.bea.com.cn/index.jsp
BEA的開發者園地，BEA作為最重要的App Server廠商，有很多獨到的技術，在Weblogic上做開發的朋友不容錯過。
5、http://www.huihoo.com/
灰狐動力網站，一個專業的中間件網站，雖然不是專業的Java網站，但是在J2EE企業應用技術方面有深厚的造詣。
6、http://www.theserverside.com/home/ (英文)
TheServerSide是一個著名的專門面向Java Server端應用的網站。
7、http://www.javaresearch.org/
Java研究組織，有很多優秀的Java方面的文章和教程，特別是在JDO方面的文章比較豐富。
8、http://www.cnjsp.org/
JSP技術網站，有相當多的Java方面的文章和資源。
9、http://www.jdon.com/
Jdon論壇，是一個個人性質的中文J2EE專業技術論壇，在眾多的Java的中文論壇中，Jdon一個是技術含量非常高，帖子質量非常好的論壇。
10、http://sourceforge.net/
SourgeForge是一個開放源代碼軟件的大本營，其中也有非常非常豐富的Java的開放源代碼的著名的軟件。
_________________
Java編程技術中漢字問題的分析及解決
在基于
Java 語言的編程中，我們經常碰到
漢字的
處理及顯示的問題。一大堆看不懂的亂碼肯定不是我們愿意看到的顯示效果，怎樣才能夠讓那些漢字正確顯示呢？Java語言默認的編碼方式是UNICODE，
而我們中國人通常使用的文件和數據庫都是基于GB2312或者BIG5等方式編碼的，怎樣才能夠恰當地選擇漢字編碼方式并正確地處理漢字的編碼呢？本文將
從漢字編碼的常識入手，結合Java編程實例，分析以上兩個問題并提出解決它們的方案。
現在 Java
編程語言已經廣泛應用于互聯網世界，早在 Sun 公司開發 Java 語言的時候，就已經考慮到對非英文字符的支持了。Sun 公司公布的 Java
運行環境（JRE）本身就分英文版和國際版，但只有國際版才支持非英文字符。不過在 Java 編程語言的應用中，對中文字符的支持并非如同 Java
Soft
的標準規范中所宣稱的那樣完美，因為中文字符集不只一個，而且不同的操作系統對中文字符的支持也不盡相同，所以會有許多和漢字編碼處理有關的問題在我們進
行應用開發中困擾著我們。有很多關于這些問題的解答，但都比較瑣碎，并不能夠滿足大家迫切解決問題的愿望，關于 Java
中文問題的系統研究并不多，本文從漢字編碼常識出發，分析 Java 中文問題，希望對大家解決這個問題有所幫助。
漢字編碼的常識
我們知道，英文字符一般是以一個字節來表示的，最常用的編碼方法是 ASCII
。但一個字節最多只能區分256個字符，而漢字成千上萬，所以現在都以雙字節來表示漢字，為了能夠與英文字符分開，每個字節的最高位一定為1，這樣雙字節
最多可以表示64K格字符。我們經常碰到的編碼方式有 GB2312、BIG5、UNICODE
等。關于具體編碼方式的詳細資料，有興趣的讀者可以查閱相關資料。我膚淺談一下和我們關系密切的 GB2312 和 UNICODE。GB2312
碼，中華人民共和國國家標準漢字信息交換用編碼，是一個由中華人民共和國國家標準總局發布的關于簡化漢字的編碼，通行于中國大陸地區及新加坡，簡稱國標
碼。兩個字節中，第一個字節（高字節）的值為區號值加32（20H），第二個字節（低字節）的值為位號值加32（20H），用這兩個值來表示一個漢字的編
碼。UNICODE 碼是微軟提出的解決多國字符問題的多字節等長編碼，它對英文字符采取前面加“0”字節的策略實現等長兼容。如 “A” 的
ASCII 碼為0x41，UNICODE 就為0x00，0x41。利用特殊的工具各種編碼之間可以互相轉換。
Java 中文問題的初步認識
我們基于 Java 編程語言進行應用開發時，不可避免地要處理中文。Java 編程語言默認的編碼方式是
UNICODE，而我們通常使用的數據庫及文件都是基于 GB2312 編碼的，我們經常碰到這樣的情況：瀏覽基于 JSP
技術的網站看到的是亂碼，文件打開后看到的也是亂碼，被 Java 修改過的數據庫的內容在別的場合應用時無法繼續正確地提供信息。
String sEnglish = “apple”;
String sChinese = “蘋果”;
String s = “蘋果 apple ”; |
sEnglish 的長度是5，sChinese的長度是4，而 s 默認的長度是14。對于 sEnglish來說， Java
中的各個類都支持得非常好，肯定能夠正確顯示。但對于 sChinese 和 s 來說，雖然 Java Soft 聲明 Java
的基本類已經考慮到對多國字符的支持（默認 UNICODE 編碼），但是如果操作系統的默認編碼不是 UNICODE ，而是國標碼等。從 Java
源代碼到得到正確的結果，要經過 “Java 源代碼-> Java 字節碼->
;虛擬機->操作系統->顯示設備”的過程。在上述過程中的每一步驟，我們都必須正確地處理漢字的編碼，才能夠使最終的顯示結果正確。
“ Java 源代碼-> Java 字節碼”，標準的 Java 編譯器 javac 使用的字符集是系統默認的字符集，比如在中文
Windows 操作系統上就是 GBK ,而在 Linux 操作系統上就是ISO-8859-1，所以大家會發現在 Linux
操作系統上編譯的類中源文件中的中文字符都出了問題，解決的辦法就是在編譯的時候添加 encoding 參數，這樣才能夠與平臺無關。用法是
javac ?Cencoding GBK。
“ Java 字節碼->虛擬機->操作系統”， Java 運行環境 （JRE） 分英文版和國際版，但只有國際版才支持非英文字符。
Java 開發工具包 （JDK） 肯定支持多國字符，但并非所有的計算機用戶都安裝了 JDK 。很多操作系統及應用軟件為了能夠更好的支持
Java ，都內嵌了 JRE 的國際版本，為自己支持多國字符提供了方便。
“操作系統->顯示設備”，對于漢字來說，操作系統必須支持并能夠顯示它。英文操作系統如果不搭配特殊的應用軟件的話，是肯定不能夠顯示中文的。
還有一個問題，就是在 Java 編程過程中，對中文字符進行正確的編碼轉換。例如，向網頁輸出中文字符串的時候，不論你是用
還是用<%=string%>，都必須作 UNICODE 到 GBK 的轉換，或者手動，或者自動。在 JSP 1.0中，可以定義輸出字符集，從而實現內碼的自動轉換。用法是
| <%@page contentType=”text/html;charset=gb2312” %> |
但是在一些 JSP 版本中并沒有提供對輸出字符集的支持，（例如 JSP 0.92），這就需要手動編碼輸出了，方法非常多。最常用的方法是
String s1 = request.getParameter(“keyword”);
String s2 = new String(s1.getBytes(“ISO-8859-1”),”GBK”); |
getBytes 方法用于將中文字符以“ISO-8859-1”編碼方式轉化成字節數組，而“GBK”
是目標編碼方式。我們從以ISO-8859-1方式編碼的數據庫中讀出中文字符串 s1 ，經過上述轉換過程，在支持 GBK
字符集的操作系統和應用軟件中就能夠正確顯示中文字符串 s2 。
Java 中文問題的表層分析及處理
|
背景
|
| 開發環境 |
JDK1.15 |
Vcafe2.0 |
JPadPro |
| 服務器端 |
NT IIS |
Sybase System |
Jconnect（JDBC） |
| 客戶端 |
IE5.0 |
Pwin98 |
|
.CLASS 文件存放在服務器端，由客戶端的瀏覽器運行 APPLET ， APPLET 只起調入 FRAME 類等主程序的作用。界面包括 Textfield ，TextArea，List，Choice 等。
I.用 JDBC 執行 SELECT 語句從服務器端讀取數據（中文）后，將數據用 APPEND 方法加到 TextArea（TA） ，不能正確顯示。但加到 List 中時，大部分漢字卻可正確顯示。
將數據按“ISO-8859-1” 編碼方式轉化為字節數組，再按系統缺省編碼方式 （Default Character Encoding） 轉化為 STRING ，即可在 TA 和 List 中正確顯示。
程序段如下：
dbstr2 = results.getString(1);
//After reading the result from DB server，converting it to string.
dbbyte1 = dbstr2.getBytes(“iso-8859-1”);
dbstr1 = new String(dbbyte1); |
在轉換字符串時不采用系統默認編碼方式，而直接采用“ GBK” 或者 “GB2312” ,在 A 和 B 兩種情況下，從數據庫取數據都沒有問題。
II.處理方式與“取中文”相逆，先將 SQL 語句按系統缺省編碼方式轉化為字節數組，再按“ISO-8859-1”編碼方式轉化為 STRING ，最后送去執行，則中文信息可正確寫入數據庫。
程序段如下：
sqlstmt = tf_input.getText();
//Before sending statement to DB server，converting it to sql statement.
dbbyte1 = sqlstmt.getBytes();
sqlstmt = newString(dbbyte1,”iso-8859-1”);
_stmt = _con.createStatement();
_stmt.executeUpdate(sqlstmt);
…… |
問題：如果客戶機上存在 CLASSPATH 指向 JDK 的 CLASSES.ZIP 時（稱為 A 情況），上述程序代碼可正確執行。但是如果客戶機只有瀏覽器，而沒有 JDK 和 CLASSPATH 時（稱為 B 情況），則漢字無法正確轉換。
我們的分析：
1.經過測試，在 A 情況下，程序運行時系統的缺省編碼方式為 GBK 或者 GB2312 。在 B 情況下，程序啟動時瀏覽器的 JAVA 控制臺中出現如下錯誤信息：
Can't find resource for sun.awt.windows.awtLocalization_zh_CN
然后系統的缺省編碼方式為“8859-1”。
2.如果在轉換字符串時不采用系統缺省編碼方式，而是直接采用 “GBK” 或“GB2312”，則在 A 情況下程序仍然可正常運行，在 B 情況下，系統出現錯誤：
UnsupportedEncodingException。
3.在客戶機上，把 JDK 的 CLASSES.ZIP 解壓后，放在另一個目錄中， CLASSPATH
只包含該目錄。然后一邊逐步刪除該目錄中的 .CLASS 文件，另一邊運行測試程序，最后發現在一千多個 CLASS
文件中，只有一個是必不可少的，該文件是：
sun.io.CharToByteDoubleByte.class。
將該文件拷到服務器端和其它的類放在一起，并在程序的開頭 IMPORT 它，在 B 情況下程序仍然無法正常運行。
4.在 A 情況下，如果在 CLASSPTH 中去掉 sun.io.CharToByteDoubleByte.class ，則程序運行時測得默認編碼方式為“8859-1”，否則為 “GBK” 或 “GB2312” 。
如果 JDK 的版本為1.2以上的話，在 B 情況下遇到的問題得到了很好的解決，測試的步驟同上，有興趣的讀者可以嘗試一下。
Java 中文問題的根源分析及解決
在簡體中文 MS Windows 98 + JDK 1.3 下，可以用 System.getProperties() 得到 Java 運行環境的一些基本屬性，類 PoorChinese 可以幫助我們得到這些屬性。
類 PoorChinese 的源代碼：
public class PoorChinese {}
執行 java PoorChinese 后，我們會得到:
系統變量 file.encoding 的值為 GBK ，user.language 的值為 zh ， user.region 的值為 CN ，這些系統變量的值決定了系統默認的編碼方式是 GBK 。
在上述系統中，下面的代碼將 GB2312 文件轉換成 Big5 文件，它們能夠幫助我們理解 Java 中漢字編碼的轉化:
import java.io.*;
import java.util.*;
public class gb2big5
{
static int iCharNum=0;
public static void main(String[] args) {
System.out.println("Input GB2312 file, output Big5 file.");
if (args.length!=2)
{
System.err.println("Usage: jview gb2big5 gbfile big5file");
System.exit(1);
String inputString = readInput(args[0]);
writeOutput(inputString,args[1]);
System.out.println("Number of Characters in file: "+iCharNum+".");
}
static void writeOutput(String str, String strOutFile)
{
try
{
FileOutputStream fos = new FileOutputStream(strOutFile);
Writer out = new OutputStreamWriter(fos, "Big5");
out.write(str);
out.close();
}
catch (IOException e)
{
e.printStackTrace();
e.printStackTrace();
}
}
static String readInput(String strInFile)
{
StringBuffer buffer = new StringBuffer();
try
{
FileInputStream fis = new FileInputStream(strInFile);
InputStreamReader isr = new InputStreamReader(fis, "GB2312");
Reader in = new BufferedReader(isr);
int ch;
while ((ch = in.read()) > -1)
{
iCharNum += 1;buffer.append((char)ch);
}
in.close();
return buffer.toString();
}
catch (IOException e)
{
e.printStackTrace();
return null;
}
}
} |
編碼轉化的過程如下：
GB2312------------------>Unicode------------->Big5
執行 java gb2big5 gb.txt big5.txt ，如果 gb.txt 的內容是“今天星期三”，則得到的文件 big5.txt
中的字符能夠正確顯示；而如果 gb.txt 的內容是“情人節快樂”，則得到的文件 big5.txt
中對應于“節”和“樂”的字符都是符號“？”（0x3F），可見 sun.io.ByteToCharGB2312 和
sun.io.CharToByteBig5 這兩個基本類并沒有編好。
正如上例一樣， Java
的基本類也可能存在問題。由于國際化的工作并不是在國內完成的，所以在這些基本類發布之前，沒有經過嚴格的測試，所以對中文字符的支持并不像 Java
Soft 所聲稱的那樣完美。前不久，我的一位技術上的朋友發信給我說，他終于找到了 Java Servlet 中文問題的根源。兩周以來，他一直為
Java Servlet
的中文問題所困擾，因為每面對一個含有中文字符的字符串都必須進行強制轉換才能夠得到正確的結果（這好象是大家公認的唯一的解決辦法）。
后來，他確實不想如此繼續安分下去了，因為這樣的事情確實不應該是高級程序員所要做的工作，他就找出 Servlet
解碼的源代碼進行分析，因為他懷疑問題就出在解碼這部分。經過四個小時的奮斗，他終于找到了問題的根源所在。原來他的懷疑是正確的， Servlet
的解碼部分完全沒有考慮雙字節，直接把 %XX 當作一個字符。（原來 Java Soft 也會犯這幺低級的錯誤！）
如果你對這個問題有興趣或者遇到了同樣的煩惱的話，你可以按照他的步驟 對Servlet.jar 進行修改：
找到源代碼 HttpUtils 中的 static private String parseName ，在返回前將
sb（StringBuffer） 復制成 byte bs[] ，然后 return new
String(bs,”GB2312”)。作上述修改后就需要自己解碼了：
HashTable form=HttpUtils .parseQueryString(request.getQueryString())或者
form=HttpUtils.parsePostData(……) |
千萬別忘了編譯后放到 Servlet.jar 里面。
關于 Java 中文問題的總結
Java 編程語言成長于網絡世界，這就要求 Java 對多國字符有很好的支持。 Java
編程語言適應了計算的網絡化的需求，為它能夠在網絡世界迅速成長奠定了堅實的基礎。 Java 的締造者 （Java Soft） 已經考慮到
Java
編程語言對多國字符的支持，只是現在的解決方案有很多缺陷在里面，需要我們付諸一些補償性的措施。而世界標準化組織也在努力把人類所有的文字統一在一種編
碼之中，其中一種方案是 ISO10646 ，它用四個字節來表示一個字符。當然，在這種方案未被采用之前，還是希望 Java Soft
能夠嚴格地測試它的產品，為用戶帶來更多的方便。
附一個用于從數據庫和網絡中取出 中文亂碼的處理函數，入參是有問題的字符串，出參是問題已經解決了的字符串。
1、vi的基本概念
基本上vi可以分為三種狀態，分別是命令模式（command mode）、插入模式（Insert mode）和底行模式（last line mode），各模式的功能區分如下：
1) 命令行模式command mode）
控制屏幕光標的移動，字符、字或行的刪除，移動復制某區段及進入Insert mode下，或者到 last line mode。
2) 插入模式（Insert mode）
只有在Insert mode下，才可以做文字輸入，按「ESC」鍵可回到命令行模式。
3) 底行模式（last line mode）
將文件保存或退出vi，也可以設置編輯環境，如尋找字符串、列出行號……等。
不過一般我們在使用時把vi簡化成兩個模式，就是將底行模式（last line mode）也算入命令行模式command mode）。
2、vi的基本操作
a) 進入vi
在系統提示符號輸入vi及文件名稱后，就進入vi全屏幕編輯畫面：
$ vi myfile
不過有一點要特別注意，就是您進入vi之后，是處于「命令行模式（command mode）」，您要切換到「插入模式（Insert mode）」才能夠輸入文字。初次使用vi的人都會想先用上下左右鍵移動光標，結果電腦一直嗶嗶叫，把自己氣個半死，所以進入vi后，先不要亂動，轉換到「插入模式（Insert mode）」再說吧！
b) 切換至插入模式（Insert mode）編輯文件
在「命令行模式（command mode）」下按一下字母「i」就可以進入「插入模式（Insert mode）」，這時候你就可以開始輸入文字了。
c) Insert 的切換
您目前處于「插入模式（Insert mode）」，您就只能一直輸入文字，如果您發現輸錯了字！想用光標鍵往回移動，將該字刪除，就要先按一下「ESC」鍵轉到「命令行模式（command mode）」再刪除文字。
d) 退出vi及保存文件
在「命令行模式（command mode）」下，按一下「：」冒號鍵進入「Last line mode」，例如：
: w filename （輸入 「w filename」將文章以指定的文件名filename保存）
: wq (輸入「wq」，存盤并退出vi)
: q! (輸入q!， 不存盤強制退出vi)
3、命令行模式（command mode）功能鍵
1）. 插入模式
按「i」切換進入插入模式「insert mode」，按“i”進入插入模式后是從光標當前位置開始輸入文件；
按「a」進入插入模式后，是從目前光標所在位置的下一個位置開始輸入文字；
按「o」進入插入模式后，是插入新的一行，從行首開始輸入文字。
2）. 從插入模式切換為命令行模式
按「ESC」鍵。
3）. 移動光標
vi可以直接用鍵盤上的光標來上下左右移動，但正規的vi是用小寫英文字母「h」、「j」、「k」、「l」，分別控制光標左、下、上、右移一格。
按「ctrl」+「b」：屏幕往“后”移動一頁。
按「ctrl」+「f」：屏幕往“前”移動一頁。
按「ctrl」+「u」：屏幕往“后”移動半頁。
按「ctrl」+「d」：屏幕往“前”移動半頁。
按數字「0」：移到文章的開頭。
按「G」：移動到文章的最后。
按「$」：移動到光標所在行的“行尾”。
按「^」：移動到光標所在行的“行首”
按「w」：光標跳到下個字的開頭
按「e」：光標跳到下個字的字尾
按「b」：光標回到上個字的開頭
按「#l」：光標移到該行的第#個位置，如：5l,56l。
4）. 刪除文字
「x」：每按一次，刪除光標所在位置的“后面”一個字符。
「#x」：例如，「6x」表示刪除光標所在位置的“后面”6個字符。
「X」：大寫的X，每按一次，刪除光標所在位置的“前面”一個字符。
「#X」：例如，「20X」表示刪除光標所在位置的“前面”20個字符。
「dd」：刪除光標所在行。
「#dd」：從光標所在行開始刪除#行
5）. 復制
「yw」：將光標所在之處到字尾的字符復制到緩沖區中。
「#yw」：復制#個字到緩沖區
「yy」：復制光標所在行到緩沖區。
「#yy」：例如，「6yy」表示拷貝從光標所在的該行“往下數”6行文字。
「p」：將緩沖區內的字符貼到光標所在位置。注意：所有與“y”有關的復制命令都必須與“p”配合才能完成復制與粘貼功能。
6）. 替換
「r」：替換光標所在處的字符。
「R」：替換光標所到之處的字符，直到按下「ESC」鍵為止。
7）. 回復上一次操作
「u」：如果您誤執行一個命令，可以馬上按下「u」，回到上一個操作。按多次“u”可以執行多次回復。
8）. 更改
「cw」：更改光標所在處的字到字尾處
「c#w」：例如，「c3w」表示更改3個字
9）. 跳至指定的行
「ctrl」+「g」列出光標所在行的行號。
「#G」：例如，「15G」，表示移動光標至文章的第15行行首。
4、Last line mode下命令簡介
在使用「last line mode」之前，請記住先按「ESC」鍵確定您已經處于「command mode」下后，再按「：」冒號即可進入「last line mode」。
A) 列出行號
「set nu」：輸入「set nu」后，會在文件中的每一行前面列出行號。
B) 跳到文件中的某一行
「#」：「#」號表示一個數字，在冒號后輸入一個數字，再按回車鍵就會跳到該行了，如輸入數字15，再回車，就會跳到文章的第15行。
C) 查找字符
「/關鍵字」：先按「/」鍵，再輸入您想尋找的字符，如果第一次找的關鍵字不是您想要的，可以一直按「n」會往后尋找到您要的關鍵字為止。
「?關鍵字」：先按「?」鍵，再輸入您想尋找的字符，如果第一次找的關鍵字不是您想要的，可以一直按「n」會往前尋找到您要的關鍵字為止。
D) 保存文件
「w」：在冒號輸入字母「w」就可以將文件保存起來。
E) 離開vi
「q」：按「q」就是退出，如果無法離開vi，可以在「q」后跟一個「!」強制離開vi。
「qw」：一般建議離開時，搭配「w」一起使用，這樣在退出的時候還可以保存文件。
5、vi命令列表
1、下表列出命令模式下的一些鍵的功能：
h
左移光標一個字符
l
右移光標一個字符
k
光標上移一行
j
光標下移一行
^
光標移動至行首
0
數字“0”，光標移至文章的開頭
G
光標移至文章的最后
$
光標移動至行尾
Ctrl+f
向前翻屏
Ctrl+b
向后翻屏
Ctrl+d
向前翻半屏
Ctrl+u
向后翻半屏
i
在光標位置前插入字符
a
在光標所在位置的后一個字符開始增加
o
插入新的一行，從行首開始輸入
ESC
從輸入狀態退至命令狀態
x
刪除光標后面的字符
#x
刪除光標后的＃個字符
X
(大寫X)，刪除光標前面的字符
#X
刪除光標前面的#個字符
dd
刪除光標所在的行
#dd
刪除從光標所在行數的#行
yw
復制光標所在位置的一個字
#yw
復制光標所在位置的#個字
yy
復制光標所在位置的一行
#yy
復制從光標所在行數的#行
p
粘貼
u
取消操作
cw
更改光標所在位置的一個字
#cw
更改光標所在位置的#個字
2、下表列出行命令模式下的一些指令
w filename
儲存正在編輯的文件為filename
wq filename
儲存正在編輯的文件為filename，并退出vi
q!
放棄所有修改，退出vi
set nu
顯示行號
/或?
查找，在/后輸入要查找的內容
n
與/或?一起使用，如果查找的內容不是想要找的關鍵字，按n或向后（與/聯用）或向前（與?聯用）繼續查找，直到找到為止。
對于第一次用vi，有幾點注意要提醒一下：
1、用vi打開文件，是處于「命令行模式（command
用什么編輯器可以使xml文件的中文變成UTF-8亂碼
我把g b2312改成UTF-8瀏覽器提示出錯~~~
最簡單的Word應該可以完成轉換，另外UE和Edit++都支持轉換
=======================================================
在寫一個東東,是sqlserver后臺,用utf-8編碼,一直是剛出來還可,一刷新就成亂碼了,以為是sql的原因,一次
把<title></title>里的全刪了,就沒問題了,后來發現,最好把<META
http-equiv=Content-Type content="textHtml;
charset=utf-8">放在title前,不然有些還是會錯!
=======================================================
為每個jsp頁面設置了其編碼格式(utf-8)，但傳遞數據到另一頁面時依然顯示為亂碼？ 首先要需要了解的是web容器默認編碼是iso-
8859-1，一個漢字占用兩個字節，而在utf-8中一個漢字占用三個字節。所以在數據傳遞過程中，必須手動設定容器編碼格式，否則會出現字符位丟失的
情況。即3個字節變為兩個字節，自然會變成亂碼。為什么保存到數據庫中的數據都變成了亂碼？ 原理同上，首先要搞清楚使用的數據庫默認的編碼格式，比如
mysql默認的字符編碼是ISO-8859-1。所以必須手動修改其默認編碼格式。 清楚了以上問題后，再來看如何解決utf-8的亂碼問題。
1:設置web容器的編碼格式。為你的servlet的doGet或doPost方法開始處加入如下代碼：request.setCharacterEncoding("utf-8");
response.setCharacterEncoding("utf-8");
2:為每個jsp頁面指定其編碼格式。<%@ page pageEncoding="utf-8"%>
3:在連接數據庫用的URL后加入：useUnicode=true;characterEncoding=utf-8 如： url="jdbc:mysql:///db1?useUnicode=true;characterEncoding=utf-8"，
4:為指定數據庫默認編碼格式。在C:\WINDOWS目錄下找到my.ini文件，并在[mysqld]中加入default-character-
set=gbk，重新啟動mysql服務。 至此，亂碼問題全部解決。起初總搞上去不清，為什么要將mysql的默認編碼格式設置為gbk，后來由相關
的資料得知utf-8默認輸入編碼方式為gbk，默認輸出編碼方式為utf-16be。 個人認為，將數據進行utf-8進行編碼的目的(即將中文編碼
為％的形式)，主要是為了在多層服務間進行數據傳輸時，防止發生字符丟失(如msn)。普通的web程序顯然沒有必要這樣做，只要使用以上方法進行處理，
就可以有效的解決亂碼問題，從而結省存儲空間。如果都像公司的SC系統那樣，將一個漢字編碼為18個字符后，再存儲到數據庫中，拋開效率不說，就存儲空間
的浪費就夠人受的，要知道，那是需要銀子地！
========================================================
ASP動態網頁下UTF-8頁面亂碼的解決方法
為什么在ASP里指定了codepage為65001還經常顯示亂碼。才子在這里將這個問題詳細解釋一下，以免很多朋友再走彎路，甚至排斥UTF-8。
如果你還不知道UTF-8是什么東東，那才子建議你先去搜索一下UTF-8的相關資料吧。
UTF-8編碼之所以被越來越多的人接受甚至喜歡，肯定是有道理的，在WEB2.0盛行的今天，在大談多瀏覽器兼容的同時，不得不想到字符編碼不同所造成的亂碼現象同樣需要得到很好的處理..... CHINAZ
在N年以前,IE6以下的所有版本，只要沒有安裝相應的字庫，訪問相關的頁面都是會亂碼的，例如，我是IE5 (Windows2000默認)
的版本，在沒有安裝IE繁體字庫的情況下，訪問任何繁體頁面的網站都是會亂碼的，當然前提是該頁面采用了BIG5的Charset，而UTF-8作為一種
國際編碼就能很好的處理該問題，只要將頁面存為UTF-8編碼格式，再在頁面上將codepage及charset全部定義為utf-8就可以在任何客戶
端瀏覽器中顯示出完全正確的內容，完全不會亂碼......
好了，這里以ASP頁面為例，以一個實例來看具體操作吧：
打開新建一個ASP頁面，相信玩ASP的朋友都會留意到，許多下載的源碼里，頁面最上方一般都有一句：
以下為引用的內容：
%@LANGUAGE="VBSCRIPT" CODEPAGE="936"% CHINAZ
CHINAZ
前面的language應該不用多說了，vbscript就是ASP默認的腳本語言，其實完全可以不用寫，寫了好像還會影響頁面執行效率，在這里我
們先不討論這個問題。后面的codepage就是關鍵了，目的就是告訴瀏覽器，此頁面是何種編碼，936代表是簡體中文，而950代表繁體中
文，65001就是我們今天說的UTF-8編碼了。我們將936改成65001。整句如下： CHINAZ
以下為引用的內容：
%@LANGUAGE="VBSCRIPT" CODEPAGE="65001"%
再加上輸出幾個中文字看看能不能正確顯示吧。 CHINAZ
以下為引用的內容：
<%
Response.Write "第一次測試UTF-8頁面"
%>
OK，直接點擊“保存”，執行這個頁面看看，如果不出意外，大家可能看到顯示出的是 “一尾UTF-8頁”這幾個字，中文有亂碼的現象，什么原因呢？
OK，請大家再點擊最上面的 "文件"
菜單，選擇"另存為"，最下面一行有個編碼，默認應該是ANSI的，請大家點下拉框，選擇UTF-8，再點保存，再執行試試看，如果不出意外，亂得更厲害
了，呵呵，暈了吧。別急，想想原因，因為我們做的頁面是HTML返回的，以前我們寫HTML時，看到body前面，也就是head里都有一句meta，應
該是這樣的：
以下為引用的內容：
<meta http-equiv="Content-Type" content="text/html; charset=gb2312">
也就是指定頁面以gb2312編碼返回結果，一定要寫在有返回結果輸出的前面。大家都知道gb2312是簡體中文吧，我們今天說的是UTF-8編碼，我們就將gb2312改成UTF-8吧，全部代碼如下： CHINAZ
以下為引用的內容：
<%@LANGUAGE="VBSCRIPT" CODEPAGE="65001"%>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<%
Response.Write "第一次測試UTF-8頁面"
%>
一，文件沒有存為對應的格式，
可能有網友認為將META元標記的解碼方式改一下，就可以實現GB2312轉UTF-8，或者UTF-8轉GB2312，這其實是錯誤的，雖然你把
GB2312編碼的網頁的Meta標記改為了Utf-8，但這樣的操作會讓你發現網頁出現了亂碼。究其原因你文件編碼格式還是gb2312的，這時你應把
文件存為utf-8，再改meta標記的解碼方式。對于將文件存為utf-8，很多朋友可能會用記事本去操作，我不建議這樣去做，因為用記事本轉換的編碼
而做的網頁會在W3C效驗時出現BOM錯誤，具體如下
Byte-Order Mark found in UTF-8 File. The Unicode Byte-Order Mark
(BOM) in UTF-8 encoded files is known to cause problems for some text
editors and older browsers. You may want to consider avoiding its use
until it is better supported.
你可以用比較新版本的editplus和ultraedit都可以選擇保存為無BOM的utf-8格式。
二，文件缺少必要的標識
檢查Html標記里有沒有如下
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
檢查XML文檔里有沒有
<?xml version="1.0" encoding="utf-8"?>
utf-8或者gb2312，看你文檔的編碼。
如果是ASP動態頁面，最好加上以下幾句
以下為相關html文檔
<%@ LANGUAGE = "VBScript" CodePage = "65001"%>
CodePage = "65001"中的65001代表是UTF-8編碼的文檔，GB2312編碼的是936
以下為相關vbscript文檔
Session.CodePage=65001
另外網上還有如下的ASP代碼，我沒試過
以下為相關vbscript文檔
Response.Charset="utf-8"
結論：采用UTF-8編碼，除了要將文件另存為UTF-8格式之外，還需要同時指定codepage及charset。
http-equiv顧名思義，相當于http的文件頭作用，它可以向瀏覽器傳回一些有用的信息，以幫助正確和精確地顯示網頁內容，與之對應的屬性值為content，content中的內容其實就是各個參數的變量值。
meat標簽的http-equiv屬性語法格式是：＜meta http-equiv="參數" content="參數變量值"＞ ；其中http-equiv屬性主要有以下幾種參數：
1、Expires(期限)
說明：可以用于設定網頁的到期時間。一旦網頁過期，必須到服務器上重新傳輸。
用法：＜meta http-equiv="expires" content="Wed, 20 Jun 2007 22:33:00 GMT"＞
注意：必須使用GMT的時間格式。
2、Pragma(cache模式)
說明：禁止瀏覽器穎鏡丶撲慊 幕捍嬤蟹夢室趁婺諶蕁?br>
用法：＜meta http-equiv="Pragma" content="no-cache"＞
注意：這樣設定，訪問者將無法脫機瀏覽。
3、Refresh(刷新)
說明：自動刷新并指向新頁面。
用法：＜meta http-equiv="Refresh" content="2；URL=http://www.net.cn/"＞
注意：其中的2是指停留2秒鐘后自動刷新到URL網址。
4、Set-Cookie(cookie設定)
說明：如果網頁過期，那么存盤的cookie將被刪除。
用法：＜meta http-equiv="Set-Cookie" content="cookievalue=xxx;
expires=Wednesday, 20-Jun-2007 22:33:00 GMT； path=/"＞
注意：必須使用GMT的時間格式。
5、Window-target(顯示窗口的設定)
說明：強制頁面在當前窗口以獨立頁面顯示。
用法：＜meta http-equiv="Window-target" content="_top"＞
注意：用來防止別人在框架里調用自己的頁面。
6、content-Type(顯示字符集的設定)
說明：設定頁面使用的字符集。
用法：＜meta http-equiv="content-Type" content="text/html; charset=gb2312"＞
7、Pics-label(網頁等級評定)
用法：<meta http-equiv="Pics-label" contect="">網頁等級評定
說明：在IE的internet選項中有一項內容設置，可以防止瀏覽一些受限制的網站，而網站的限制級別就是通過meta屬性來設置的。
還有Page_Enter、Page_Exit……
補充：
設定進入頁面時的特殊效果<meta http-equiv="Page-Enter" contect="revealTrans(duration=1.0,transtion= 12)">
設定離開頁面時的特殊效果<meta http-equiv="Page-Exit" contect="revealTrans(duration=1.0,transtion= 12)">
Duration的值為網頁動態過渡的時間，單位為秒。
Transition是過渡方式，它的值為0到23，分別對應24種過渡方式。如下表：
0 盒狀收縮 1 盒狀放射
2 圓形收縮 3 圓形放射
4 由下往上 5 由上往下
6 從左至右 7 從右至左
8 垂直百葉窗 9 水平百葉窗
10 水平格狀百葉窗 11垂直格狀百葉窗
12 隨意溶解 13從左右兩端向中間展開
14從中間向左右兩端展開 15從上下兩端向中間展開
16從中間向上下兩端展開 17 從右上角向左下角展開
18 從右下角向左上角展開 19 從左上角向右下角展開
20 從左下角向右上角展開 21 水平線狀展開
22 垂直線狀展開 23 隨機產生一種過渡方式
這幾天因為學習到了基于AWT的java 軟件程序設計，所以再用eclipse 的過程中遇到了問題，沒有找到那些可視化組件，找了一段時間，才知道，原來安裝VE 不是象其他的軟件一樣，單擊就可以完成。存在了這樣那樣的問題，呵呵，真是的，再好用的軟件也有麻煩的時候啊，不過在安裝的過程中自己也學習到了很多的東西呢！
書上說要下載一個叫做VE—runtime 的東西，沒事簡單的很呢，只要登陸到這個網站（
http://www.eclipse.org/downloads/，在右邊的小框里可以看見）就可以輕松的完成這項工作，自己也覺得沒什么的，不就下載一個軟件嘛，呵呵！你覺的呢？
書上又說了，你要按照以下的方法做，將VE—runtime 解壓到和JDK，EMF，GMF的一個文件里，如果在對VE—runtime解壓過程中出現了“文件覆蓋”對話框，就選擇“全部為否”按鈕予以關閉，然后找configuration子文件夾，刪除除了“config配置設置”以外的所有文件。
大功告成，呵呵，書啊，就是好東西，它叫你學到了很多的東西呢！可是，呵呵！可是，結果是我失敗了，palette中沒有那些書上說的組件！找啊，有錯就找，網上的資源多的很呢！過程和其它的就不說了，只說找的結論，以及一定能讓你安裝好這個軟件的方法！
結論是：VE 只有和其相應版本的EMF，eclipse-SDK，GMF工作，而JDK的要求是要在1.4.2以及以上的版本。干嗎要配套使用呢，更高版本的不行嘛，不是更好嘛，想了很久還是不知道，也沒有找過，要是有人找到了，請告訴我一聲啊，謝謝了！還有一個結論就是：不要總是相信書上的東西，它也是有錯的時候！
下面說一下安裝的具體過程：
（1）要在以下的網址上下載我們需要的東西（EMF，GMF，VE，eclipse-SDK)http://download.eclipse.org/tools/ve/downloads/drops/R-1.2.3_jem-200701301117/index.html(注意!一定看清其版本)我們下的這幾個的版本分別是:
Eclipse build eclipse-SDK-3.2,EMF build 2.2.0,GEF Build 3.2,VE-runtime-1.2.3如果這一步錯了，下面的工作就不要進行了！
（２）將 Eclipse build eclipse-SDK-3.2直接解壓到某個磁盤中，（如Ｄ：盤）這時在Ｄ盤根目錄就出現了一個叫eclipse的文件夾，（注意不要先建一個eclipse文件夾，在將Eclipse build eclipse-SDK-3.2解壓到這個文件夾中，這樣會出現兩個eclipse文件夾）打開它有許多的文件，不要管它！
（３）在eclipse 文件夾中建立以如下幾個文件EMF,GEF,VEruntime,VESDK然后將 Eclipse build eclipse-SDK-3.2解壓到VESDK中，將EMF build 2.2.0解壓到EMF中，將GEF Build 3.2解壓GEF中，將VE-runtime-1.2.3解壓到VEruntime中,呵呵！，不要煩啊，這樣做的好處就是能讓你一次安裝完成！
（４）在eclipse中建立一個名為links的文件夾，在其中分別建立如下的文本文件：（可以先將其建為.txt格式的，寫完內容后，重命名為.link)
EMF.link 內容為：path=D://eclipse//EMF
GEF.link 內容為：path=D://eclipse//GEF
VEruntime.link 內容為：path=D://eclipse//VEruntime
VESDK.link 內容為：path=D://eclipse//VESDK
好了，做到現在啟動eclipse，在新建類快捷鍵中出現了visible class ，在看看palette中是不是出現了需要的可視化組件！如果出現了，祝賀你成功了，如果沒有出現，請在安裝一遍，不要恢心，好好看看上邊的過程，你一定會成功的，并體會到java 中可視化的樂趣！
這是自己找別人的，所以不算是自己的勞動成果，借用一下，方便自己看，也方便只想知道下面兩個語句區別的人，不要見怪啊！
String a=new String("hello");和String a="hello";的區別，（1)前者是直接開辟一個內存空間，其中保存的數據為字符串hello，同時申請一個引用變量a將為字符串開辟的內存地址賦值給a :而對于后者，后臺的操作是：首先查看“字符串池”中是否存在hello這個字面量，如果存在，則將該字面量的內存地址賦值給b，如果沒有，剛在“字符串池“中生成一個hello字面量，將新生成的字面量的內存地址賦值給b.
(2)前者是在程序運行時，在內存開辟的空間，而后者是在程序編譯時就為之開了內存空間。
（3）前者用new 關健字，相當于創建了一個對象的引用，是在運行時完成，后者則是在編譯時就完成的字符串學量。
看如下代碼：
String s0="hello";
String s1="hello";
String s2="he"+"llo";
System.out.println(s0=s1);
System.out.println(s1=s2);
運行的結果是：true;
true;
因為例子中的s0和s1中的“hello"在編譯期就被確定了，所以s0==s1為真；而"he"和"llo"也都是字符串常量，當一個字符串常量連接成時，它自己也定是字符串常量，所s2也同樣在編譯期就被解析為一個字符串常量，所以s2也是常量池（constant pool 指的是在編譯期被確定，并被保存在已編譯的.clas文件中的一些數據，它包括了關于類，方法，接口等的常量，也包括字符串常量）中的"hello"的一個引用。
String s0=new String ("hello");
String s1=new String ("hello");
Stirng s2=new String(“he")+"llo";
System.out.println(s0==s1);
System.out.println(s1==s2);
System.out.println(s0==s1);
結果則是
false
false
false