一、super() 方法的用法及作用？

有如下Java類：

public class Bird{ 
private String name; 
public Bird() { } 
public Bird(String name){ this.name = name; } 
public void walk() { System.out.println(“走路”); } 
public String getName(){ return name; } 
public void setName(String name){ this.name = name; } 
} 

另有一個類Chicken繼承上邊的Bird類;

public class Chicken extends Bird{ 
private String crest; 
public Chicken(){ super(); } 
public Chicken(String name,String crest) { 
super(name); 
this.name = name; } 
…………. 
} 

在第二個自定義的類Chicken中，super()方法一共出現了兩次，分別是super()和super(name)，請問super() 是什么含義，放在這里又作何解釋？

參考答案：

1.子類的構造過程中必須調用父類的構造方法。

2.子類可在自己的構造方法中使用super（）來調用父類的構造方法。

（1）使用this來調用本類的另外的構造方法。

（2）如果調用super必須寫在子類構造方法的***行。

3.如果子類的構造方法中沒有顯示的調用父類的構造方法，則系統默認的調用父類的無參的構造方法。

4.如果子類的構造方法中既沒有顯示調用父類的構造方法，而父類中又沒有無參的構造方法，則編譯出錯。

那你這里***個super（）無參的就是調用了上面Bird類的Bird() 方法！

super(name)這個有參數就是調用public Bird(String name){

this.name = name; 這個方法！super() 是調用父類的構造函數，你例子中有Bird()和Bird(String name)兩個方法，super()是調用Bird()構造函數，而super(name)是調用Birth(String name)構造函數。注意super() 調用的是對應參數個數和類型相同的父類構造函數。 public Chicken(String name,String crest) { super(name); this.name = name; } 應該重復了吧，super(name)應該就是this.name = name。

二、Java 語言中的 volatile 和synchronized有什么區別？

Java 語言中的 volatile 變量可以被看作是一種 “程度較輕的 synchronized”；與 synchronized 塊相比，volatile 變量所需的編碼較少，并且運行時開銷也較少，但是它所能實現的功能也僅是 synchronized 的一部分。

我們知道，在Java中設置變量值的操作，除了long和double類型的變量外都是原子操作，也就是說，對于變量值的簡單讀寫操作沒有必要進行同步。

這在JVM 1.2之前，Java的內存模型實現總是從主存讀取變量，是不需要進行特別的注意的。而隨著JVM的成熟和優化，現在在多線程環境下volatile關鍵字的使用變得非常重要。

在當前的Java內存模型下，線程可以把變量保存在本地內存（比如機器的寄存器）中，而不是直接在主存中進行讀寫。這就可能造成一個線程在主存中修改了一個變量的值，而另外一個線程還繼續使用它在寄存器中的變量值的拷貝，造成數據的不一致。

要解決這個問題，只需要像在本程序中的這樣，把該變量聲明為volatile（不穩定的）即可，這就指示JVM，這個變量是不穩定的，每次使用它都到主存中進行讀取。一般說來，多任務環境下各任務間共享的標志都應該加volatile修飾。

Volatile修飾的成員變量在每次被線程訪問時，都強迫從共享內存中重讀該成員變量的值。而且，當成員變量發生變化時，強迫線程將變化值回寫到共享內存。這樣在任何時刻，兩個不同的線程總是看到某個成員變量的同一個值。

Java語言規范中指出：為了獲得***速度，允許線程保存共享成員變量的私有拷貝，而且只當線程進入或者離開同步代碼塊時才與共享成員變量的原始值對比。

這樣當多個線程同時與某個對象交互時，就必須要注意到要讓線程及時的得到共享成員變量的變化。

而volatile關鍵字就是提示VM：對于這個成員變量不能保存它的私有拷貝，而應直接與共享成員變量交互。

使用建議：在兩個或者更多的線程訪問的成員變量上使用volatile。當要訪問的變量已在synchronized代碼塊中，或者為常量時，不必使用。

由于使用屏蔽掉了VM中必要的代碼優化，所以在效率上比較低，因此一定在必要時才使用此關鍵字。

注意：聲明為volatile的簡單變量如果當前值由該變量以前的值相關，那么volatile關鍵字不起作用，也就是說如下的表達式都不是原子操作：

n = n + 1; 
n++; 

如果要想使這種情況變成原子操作，需要使用synchronized關鍵字，如上的代碼可以改成如下的形式：

public static synchronized void inc() 
{ 
n++; 
} 

將n=n+1改成了inc()，其中inc方法使用了synchronized關鍵字進行方法同步。因此，在使用volatile關鍵字時要慎重，并不是只要簡單類型變量使用volatile修飾，對這個變量的所有操作都是原來操作，當變量的值由自身的上一個決定時，如n=n+1、n++等，volatile關鍵字將失效，只有當變量的值和自身上一個值無關時對該變量的操作才是原子級別的，如n = m + 1，這個就是原級別的。所以在使用volatile關鍵時一定要謹慎，如果自己沒有把握，可以使用synchronized來代替volatile。

三、什么是互斥鎖？使用互斥鎖都有哪些注意事項？

1．男孩和女孩例子，每個女孩是一個對象，每個男孩是個線程。每個女孩都有自己的鎖池。每個男孩可能在鎖池里等待。

Class Girl{ 
Public void hand(){ 
} 
Public syncronized void kiss(){ 
} 
} 
Class Boy extends Thread{ 
Public void run(){ 
} 
} 

鎖標記如果過多，就會出現線程等待其他線程釋放鎖標記，而又都不釋放自己的鎖標記供其他線程運行的狀況。就是死鎖。

死鎖的兩種處理方法：統一排列鎖順序(解決不同方法中對多個共享資源的訪問)。

對象1的方法

synchronized(a)
synchronized(b)

對象2的方法

synchronized(a) 
synchronized(b) 

2．線程間通信(也就是線程間的相互協調)

線程間通信使用的空間稱之為對象的等待池（wait pool），該隊列也是屬于對象的空間的。

進入等待池

使用Object類中wait()的方法，在運行狀態中，線程調用wait()，此時表示線程將釋放自己所有的鎖標記和CPU的占用，同時進入這個對象的等待池。等待池的狀態也是阻塞狀態，只不過線程釋放自己的鎖標記。

退出等待池進入鎖池

notify()：將從對象的等待池中移走一個任意的線程，并放到鎖池中，那里的對象一直在等待，直到可以獲得對象的鎖標記。

notifyAll()：將從等待池中移走所有等待那個對象的線程并放到鎖池中，只有鎖池中的線程能獲取對象的鎖標記，鎖標記允許線程從上次因調用wait()而中斷的地方開始繼續運行。

注意：只能對加鎖的資源進行wait()和notify()。

1) wait()：交出鎖和CPU的占用；

2) notify()：將從對象的等待池中移走一個任意的線程，并放到鎖池中，那里的對象一直在等待，直到可以獲得對象的鎖標記。

3) notifyAll(): 將從等待池中移走所有等待那個對象的線程并放到鎖池中，只有鎖池中的線程能獲取對象的鎖標記，鎖標記允許線程從上次因調用wait()而中斷的地方開始繼續運行。

注：在java.io包中Vector 和 HashTable 之所以是線程安全的，是因為每個方法都有synchronized修飾。Static 方法可以加 synchronized , 鎖的是類對象。

但是Vector 是 jdk 1.0 的 ArrayList 是 jdk1.2 所以實際應用還是使用ArrayList

例子：

生產者和消費者

一個柜臺一定數量的產品,柜臺滿時不能生產，空時不能夠買。

四、Java中流的分類都有哪些？

1）從數據類型分為字節流和字符流

字節流類：

抽象父類： InputStream,OutputStream

實現類包括如下幾種：

BufferedInputStream 緩沖流－過慮流
BufferedOutputStream
ByteArrayInputStream 字節數組流－節點流
ByteArrayOutputStream
DataInputStream 處理JAVA標準數據流－過慮流
DataOutputStream
FileInputStream 處理文件IO流－節點流
FileOutputStream
FilterInputStream 實現過慮流－字節過慮流父類
FilterOutputStream
PipedInputStream 管道流
PipedOutputStream
PrintStream 包含print() 和 println()
RandomAccessFile 支持隨機文件

抽象父類：Reader, Writer

實現類：

BufferedReader
BufferedWriter
PrintWriter
CharArrayReader
CharArrayWriter
FileReader
FileWriter
FilterReader
FilterWriter
InputStreamReader
OutputStreamWriter
PipedReader
PipedWriter
StringReader
StringWriter

2) 從數據方向分為輸入流和輸出流

InputXXXXX , OutputXXXXX

3) 從流的功能分為節點流和過濾流

節點流用來傳輸數據。

過濾流用來封裝節點流或者其他過濾流，從而給節點流或其他的過濾流增加一個功能。

五、Java中父類和子類關系

父類的非私有化屬性(不同包的子類無法訪問default修飾符)和方法可以默認繼承到子類。

Class Son extends Father{ 
} 

而如果父類中的私有方法被子類調用的話，則編譯報錯。

父類的構造方法子類不可以繼承，更不存在覆蓋的問題。

所以子類構造方法默認調用父類的無參構造方法。（所以養成寫無參構造的習慣）

如果子類訪問父類的有參構造方法，必須在子類構造方法***行使用super(參數)

當構造一個對象的時候，系統先構造父類對象，再構造子類對象。

Public class BMWcar extends Car{ 
Public BMWcar(){ 
Super(int alength); //顯式的調用父類的構造，默認調用無參構造 
//所以父類沒有無參構造的話，子類如果不加顯示調用其他構造就會報錯。這里的super是一個對父類的引用 
} 
} 

#p#

六、Java多線程常見面試題

1、定義線程

1）擴展java.lang.Thread類。

此類中有個run()方法，應該注意其用法：

public void run()如果該線程是使用獨立的 Runnable 運行對象構造的，則調用該 Runnable 對象的 run 方法；否則，該方法不執行任何操作并返回。

Thread 的子類應該重寫該方法。

2）實現java.lang.Runnable接口。

void run()

使用實現接口 Runnable 的對象創建一個線程時，啟動該線程將導致在獨立執行的線程中調用對象的 run 方法。

方法 run 的常規協定是，它可能執行任何所需的操作。

2、實例化線程

1）如果是擴展java.lang.Thread類的線程，則直接new即可。

2）如果是實現了java.lang.Runnable接口的類，則用Thread的構造方法：

Thread(Runnable target)
Thread(Runnable target, String name)
Thread(ThreadGroup group, Runnable target)
Thread(ThreadGroup group, Runnable target, String name)
Thread(ThreadGroup group, Runnable target, String name, long stackSize)

3、啟動線程

在線程的Thread對象上調用start()方法，而不是run()或者別的方法。

在調用start()方法之前：線程處于新狀態中，新狀態指有一個Thread對象，但還沒有一個真正的線程。

在調用start()方法之后：發生了一系列復雜的事情

啟動新的執行線程（具有新的調用棧）；

該線程從新狀態轉移到可運行狀態；

當該線程獲得機會執行時，其目標run()方法將運行。

注意：對Java來說，run()方法沒有任何特別之處。像main()方法一樣，它只是新線程知道調用的方法名稱(和簽名)。因此，在Runnable上或者Thread上調用run方法是合法的。但并不啟動新的線程。

4、例子

1）實現Runnable接口的多線程例子。

/** 
* 實現Runnable接口的類 
* 
* @author leizhimin 2008-9-13 18:12:10 
*/ 
public class DoSomething implements Runnable { 
private String name; 
 
public DoSomething(String name) { 
this.name = name; 
} 
 
public void run() { 
for (int i = 0; i < 5; i++) { 
for (long k = 0; k < 100000000; k++) ; 
System.out.println(name + “: ” + i); 
} 
} 
} 
 
/** 
* 測試Runnable類實現的多線程程序 
* 
* @author leizhimin 2008-9-13 18:15:02 
*/ 
public class TestRunnable { 
public static void main(String[] args) { 
DoSomething ds1 = new DoSomething(“阿三”); 
DoSomething ds2 = new DoSomething(“李四”); 
 
Thread t1 = new Thread(ds1); 
Thread t2 = new Thread(ds2); 
 
t1.start(); 
t2.start(); 
} 
} 

執行結果：

李四: 0
阿三: 0
李四: 1
阿三: 1
李四: 2
李四: 3
阿三: 2
李四: 4
阿三: 3
阿三: 4
Process finished with exit code 0

2）擴展Thread類實現的多線程例子。

/** 
* 測試擴展Thread類實現的多線程程序 
* 
* @author leizhimin 2008-9-13 18:22:13 
*/ 
public class TestThread extends Thread{ 
public TestThread(String name) { 
super(name); 
} 
 
public void run() { 
for(int i = 0;i<5;i++){ 
for(long k= 0; k <100000000;k++); 
System.out.println(this.getName()+” :”+i); 
} 
} 
 
public static void main(String[] args) { 
Thread t1 = new TestThread(“阿三”); 
Thread t2 = new TestThread(“李四”); 
t1.start(); 
t2.start(); 
} 
} 

執行結果：

阿三 :0
李四 :0
阿三 :1
李四 :1
阿三 :2
李四 :2
阿三 :3
阿三 :4
李四 :3
李四 :4
Process finished with exit code 0

對于上面的多線程程序代碼來說，輸出的結果是不確定的。其中的一條語句for(long k= 0; k <100000000;k++);是用來模擬一個非常耗時的操作的。

5、一些常見問題

1）線程的名字，一個運行中的線程總是有名字的，名字有兩個來源，一個是虛擬機自己給的名字，一個是你自己的定的名字。在沒有指定線程名字的情況下，虛擬機總會為線程指定名字，并且主線程的名字總是mian，非主線程的名字不確定。

2）線程都可以設置名字，也可以獲取線程的名字，連主線程也不例外。

3）獲取當前線程的對象的方法是：Thread.currentThread()；

4）在上面的代碼中，只能保證：每個線程都將啟動，每個線程都將運行直到完成。一系列線程以某種順序啟動并不意味著將按該順序執行。對于任何一組啟動的線程來說，調度程序不能保證其執行次序，持續時間也無法保證。

5）當線程目標run()方法結束時該線程完成。

6）一旦線程啟動，它就永遠不能再重新啟動。只有一個新的線程可以被啟動，并且只能一次。一個可運行的線程或死線程可以被重新啟動。

7）線程的調度是JVM的一部分，在一個CPU的機器上上，實際上一次只能運行一個線程。一次只有一個線程棧執行。JVM線程調度程序決定實際運行哪個處于可運行狀態的線程。眾多可運行線程中的某一個會被選中做為當前線程。可運行線程被選擇運行的順序是沒有保障的。

8）盡管通常采用隊列形式，但這是沒有保障的。隊列形式是指當一個線程完成“一輪”時，它移到可運行隊列的尾部等待，直到它最終排隊到該隊列的前端為止，它才能被再次選中。事實上，我們把它稱為可運行池而不是一個可運行隊列，目的是幫助認識線程并不都是以某種有保障的順序排列唱呢個一個隊列的事實。

9）盡管我們沒有無法控制線程調度程序，但可以通過別的方式來影響線程調度的方式。

七、java經典面試題

總結了一下java的一些企業常面試的面試題，也可以說是堪稱經典吧！大部分企業的面試題，差不多都會以下我列出的面試題！而且面試題為紅色的題更是企業經常面試的，可以說是屢試不爽，大家如果看到了我的這篇文章，那么請你進來看看，會對你有不小的收獲的。

Java基礎方面：

1、Static Nested Class 和 Inner Class的不同。

Static Nested Class是被聲明為靜態（static）的內部類，它可以不依賴于外部類實例被實例化。而通常的內部類需要在外部類實例化后才能實例化。

2、java.lang.String類是否能被繼承和修改，為什么？

java.lang.String類是final類型的，因此不可以繼承這個類、不能修改這個類。為了提高效率節省空間，我們應該用StringBuffer類

3、int 和 Integer 有什么區別？

Java 提供兩種不同的類型：引用類型和原始類型（或內置類型）。Int是java的原始數據類型，Integer是java為int提供的封裝類。Java為每個原始類型提供了封裝類。

原始類型封裝類

booleanBoolean
charCharacter
byteByte
shortShort
intInteger
longLong
floatFloat
doubleDouble

引 用類型和原始類型的行為完全不同，并且它們具有不同的語義。引用類型和原始類型具有不同的特征和用法，它們包括：大小和速度問題，這種類型以哪種類型的數 據結構存儲，當引用類型和原始類型用作某個類的實例數據時所指定的缺省值。對象引用實例變量的缺省值為 null，而原始類型實例變量的缺省值與它們的類型有關。

4、String 和StringBuffer的區別。

JAVA 平臺提供了兩個類：String和StringBuffer，它們可以儲存和操作字符串，即包含多個字符的字符數據。這個String類提供了數值不可改 變的字符串。而這個StringBuffer類提供的字符串進行修改。當你知道字符數據要改變的時候你就可以使用StringBuffer。典型地，你可 以使用StringBuffers來動態構造字符數據。

5、運行時異常與一般異常有何異同？

異常表示程序運行過程中可能出現的非正常狀態，運行時異常表示虛擬機的通常操作中可能遇到的異常，是一種常見運行錯誤。java編譯器要求方法必須聲明拋出可能發生的非運行時異常，但是并不要求必須聲明拋出未被捕獲的運行時異常。

6、說出Servlet的生命周期，并說出Servlet和CGI的區別。

Servlet被服務器實例化后，容器運行其init方法，請求到達時運行其service方法，service方法自動派遣運行與請求對應的doXXX方法（doGet，doPost）等，當服務器決定將實例銷毀的時候調用其destroy方法。

與cgi的區別在于servlet處于服務器進程中，它通過多線程方式運行其service方法，一個實例可以服務于多個請求，并且其實例一般不會銷毀，而CGI對每個請求都產生新的進程，服務完成后就銷毀，所以效率上低于servlet。

7、說出ArrayList,Vector, LinkedList的存儲性能和特性。

ArrayList 和Vector都是使用數組方式存儲數據，此數組元素數大于實際存儲的數據以便增加和插入元素，它們都允許直接按序號索引元素，但是插入元素要涉及數組元 素移動等內存操作，所以索引數據快而插入數據慢，Vector由于使用了synchronized方法（線程安全），通常性能上較ArrayList差， 而LinkedList使用雙向鏈表實現存儲，按序號索引數據需要進行前向或后向遍歷，但是插入數據時只需要記錄本項的前后項即可，所以插入速度較快。

8、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 的優勢卻在于他可以維持使用者的狀態。

9、Collection 和 Collections的區別。

Collection是集合類的上級接口，繼承與他的接口主要有Set 和List.

Collections是針對集合類的一個幫助類，他提供一系列靜態方法實現對各種集合的搜索、排序、線程安全化等操作。

10、&和&&的區別。

&是位運算符，表示按位與運算，&&是邏輯運算符，表示邏輯與（and）。

11、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算法都大概一樣，所以性能不會有很大的差異。

12、final, finally, finalize的區別。

final 用于聲明屬性，方法和類，分別表示屬性不可變，方法不可覆蓋，類不可繼承。

finally是異常處理語句結構的一部分，表示總是執行。

finalize是Object類的一個方法，在垃圾收集器執行的時候會調用被回收對象的此方法，可以覆蓋此方法提供垃圾收集時的其他資源回收，例如關閉文件等。

13、sleep() 和 wait() 有什么區別?

sleep是線程類（Thread）的方法，導致此線程暫停執行指定時間，給執行機會給其他線程，但是監控狀態依然保持，到時后會自動恢復。調用sleep不會釋放對象鎖。

wait是Object類的方法，對此對象調用wait方法導致本線程放棄對象鎖，進入等待此對象的等待鎖定池，只有針對此對象發出notify方法（或notifyAll）后本線程才進入對象鎖定池準備獲得對象鎖進入運行狀態。

14、Overload和Override的區別。Overloaded的方法是否可以改變返回值的類型?

方 法的重寫Overriding和重載Overloading是Java多態性的不同表現。重寫Overriding是父類與子類之間多態性的一種表現，重 載Overloading是一個類中多態性的一種表現。如果在子類中定義某方法與其父類有相同的名稱和參數，我們說該方法被重寫 (Overriding)。子類的對象使用這個方法時，將調用子類中的定義，對它而言，父類中的定義如同被”屏蔽”了。如果在一個類中定義了多個同名的方 法，它們或有不同的參數個數或有不同的參數類型，則稱為方法的重載(Overloading)。Overloaded的方法是可以改變返回值的類型。

15、error和exception有什么區別?

error 表示恢復不是不可能但很困難的情況下的一種嚴重問題。比如說內存溢出。不可能指望程序能處理這樣的情況。

exception 表示一種設計或實現問題。也就是說，它表示如果程序運行正常，從不會發生的情況。

16、同步和異步有何異同，在什么情況下分別使用他們？舉例說明。

如果數據將在線程間共享。例如正在寫的數據以后可能被另一個線程讀到，或者正在讀的數據可能已經被另一個線程寫過了，那么這些數據就是共享數據，必須進行同步存取。

當應用程序在對象上調用了一個需要花費很長時間來執行的方法，并且不希望讓程序等待方法的返回時，就應該使用異步編程，在很多情況下采用異步途徑往往更有效率。

17、abstract class和interface有什么區別?

聲 明方法的存在而不去實現它的類被叫做抽象類（abstract class），它用于要創建一個體現某些基本行為的類，并為該類聲明方法，但不能在該類中實現該類的情況。不能創建abstract 類的實例。然而可以創建一個變量，其類型是一個抽象類，并讓它指向具體子類的一個實例。不能有抽象構造函數或抽象靜態方法。Abstract 類的子類為它們父類中的所有抽象方法提供實現，否則它們也是抽象類為。取而代之，在子類中實現該方法。知道其行為的其它類可以在類中實現這些方法。

接 口（interface）是抽象類的變體。在接口中，所有方法都是抽象的。多繼承性可通過實現這樣的接口而獲得。接口中的所有方法都是抽象的，沒有一個有 程序體。接口只可以定義static final成員變量。接口的實現與子類相似，除了該實現類不能從接口定義中繼承行為。當類實現特殊接口時，它定義（即將程序體給予）所有這種接口的方法。 然后，它可以在實現了該接口的類的任何對象上調用接口的方法。由于有抽象類，它允許使用接口名作為引用變量的類型。通常的動態聯編將生效。引用可以轉換到 接口類型或從接口類型轉換，instanceof 運算符可以用來決定某對象的類是否實現了接口。

18、heap和stack有什么區別。

棧是一種線形集合，其添加和刪除元素的操作應在同一段完成。棧按照后進先出的方式進行處理。

堆是棧的一個組成元素

19、forward 和redirect的區別

forward是服務器請求資源，服務器直接訪問目標地址的URL，把那個URL的響應內容讀取過來，然后把這些內容再發給瀏覽器，瀏覽器根本不知道服務器發送的內容是從哪兒來的，所以它的地址欄中還是原來的地址。
redirect就是服務端根據邏輯,發送一個狀態碼,告訴瀏覽器重新去請求那個地址，一般來說瀏覽器會用剛才請求的所有參數重新請求，所以session,request參數都可以獲取。

20、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組件。

#p#

八、戴爾公司電話面試Java

接到了dell公司項目經理的電話面試，我們從java 的接口，abstract函數，談的c++的虛函數，然后談到java native interface。談到動態庫，談到靜態庫，然后談到了進程間通訊，操作系統是如何管理進程的，已經操作系統原理。談到了android的framework的部分原理，談到了aidl接口。

九、一朋友面試失敗后得到的一個回復信 你被涮后有過回復信嗎？

尊敬的應聘者xxx，

非常感謝您到敝公司來面試。經過我們對您的表現的認真評估，認為您目前還不適合敝公司的職位。如果您想在Java開發方面有好的發展，我們對您有以下建議：

1. 要注重基礎知識的學習，不要只會SSH框架。

2. 多學習一些Linux方面的知識。

3. 推薦您看看Java核心技術，Think in java這兩本書。

4. 建議您閑時上一些技術論壇看看，同大家多交流交流技術。

十、什么是觀察者模式(Observer)？

觀察者模式定義了一種一對多的依賴關系，讓多個觀察者對象同時監聽某一個主題對象。這個主題對象在狀態上發生變化時，會通知所有觀察者對象，讓他們能夠自動更新自己

觀察者模式的組成

抽象主題角色：把所有對觀察者對象的引用保存在一個集合中，每個抽象主題角色都可以有任意數量的觀察者。抽象主題提供一個接口，可以增加和刪除觀察者角色。一般用一個抽象類或接口來實現。

抽象觀察者角色：為所有具體的觀察者定義一個接口，在得到主題的通知時更新自己。

從AWT1.1開始圖形系統的事件模型采用觀察者模式，因此觀察者模式在Java語言中的地位極其重要。

在xml解析中的SAX也采用了觀察者模式來實現。

Java也提供了對觀察者模式的內置支持。

Observable類用于創建可以觀測到你的程序中其他部分的子類。當這種子類的對象發生變化時，觀測類被通知。觀測類必須實現定義了update( )方法的Observer接口。當一個觀測程序被通知到一個被觀測對象的改變時，update( )方法被調用。

一個被觀測的對象必須服從下面的兩個簡單規則。***，如果它被改變了，它必須調用setChanged( )方法。第二，當它準備通知觀測程序它的改變時，它必須調用notifyObservers( )方法。這導致了在觀測對象中對update( )方法的調用。注意——當對象在調用notifyObservers( )方法之前，沒有調用setChanged( )方法，就不會有什么動作發生。在update( )被調用之前，被觀測對象必須調用setChanged( )和notifyObservers( )兩種方法。

注意notifyObservers()有兩種形式：一種帶有參數而另一種沒有。當用參數調用notifyObservers( )方法時，該對象被傳給觀測程序的update( )方法作為其第二個參數。否則，將給update( )方法傳遞一個null。可以使用第二個參數傳遞適合于你的應用程序的任何類型的對象。

為了觀測一個可觀測的對象，必須實現Observer接口。這個接口僅僅定義了如下所示的一個方法。

void update(Observable observOb, Object arg) 

這里，observOb是被觀測的對象，而arg是由notifyObservers( )方法傳遞的值。當被觀測對象發生了改變，調用update( )方法。

十一、JavaEE N層架構的好處都有哪些？

JavaEE帶來的好處是雙向的，對于開發應用的公司和使用它的客戶，優點主要在于4個方面。

1、簡化了體系和開發。相對于傳統的應用開發，JavaEE提供了簡單的、基于組件的開發模型。這個模型提供了WORA（Write Once, Run Anywhere）的可移植性，只要符合JavaEE規范的服務器，就可以運行應用。同時，基于組件的開發模型也大大提高了生產力。

2、集成現有的企業信息系統。JavaEE平臺，與JavaSE平臺一樣，提供訪問現有的企業信息系統的一些工業標準API；

3、提供可擴展性。當前JavaEE容器向組件提供事務支持、數據庫連接、生命周期管理和影響性能的其它特性，從而提供可擴展性（scalability）。

4、安全機制。JavaEE支持豐富的跨越整個體系的一致的安全措施。

十二、四種操作xml的方式：SAX, DOM, JDOM , DOM4J的比較

1、DOM(JAXP Crimson解析器)

DOM是用與平臺和語言無關的方式表示XML文檔的官方W3C標準。DOM是以層次結構組織的節點或信息片斷的集合。

這個層次結構允許開發人員在樹中尋找特定信息。分析該結構通常需要加載整個文檔和構造層次結構，然后才能做任何工作。

由于它是基于信息層次的，因而DOM被認為是基于樹或基于對象的。DOM以及廣義的基于樹的處理具有幾個優點。

首先，由于樹在內存中是持久的，因此可以修改它以便應用程序能對數據和結構作出更改。

它還可以在任何時候在樹中上下導航，而不是像SAX那樣是一次性的處理。DOM使用起來也要簡單得多。

2、SAX

SAX處理的優點非常類似于流媒體的優點。分析能夠立即開始，而不是等待所有的數據被處理。而且，由于應用程序只是在讀取數據時檢查數據，因此不需要將數據存儲在內存中。這對于大型文檔來說是個巨大的優點。事實上，應用程序甚至不必解析整個文檔；它可以在某個條件得到滿足時停止解析。一般來說，SAX還比它的替代者DOM快許多。 選擇DOM還是選擇SAX？ 對于需要自己編寫代碼來處理XML文檔的開發人員來說，選擇DOM還是SAX解析模型是一個非常重要的設計決策。 DOM采用建立樹形結構的方式訪問XML文檔，而SAX采用的事件模型。

DOM解析器把XML文檔轉化為一個包含其內容的樹，并可以對樹進行遍歷。用DOM解析模型的優點是編程容易，開發人員只需要調用建樹的指令，然后利用navigation APIs訪問所需的樹節點來完成任務。可以很容易的添加和修改樹中的元素。然而由于使用DOM解析器的時候需要處理整個XML文檔，所以對性能和內存的要求比較高，尤其是遇到很大的XML文件的時候。由于它的遍歷能力，DOM解析器常用于XML文檔需要頻繁的改變的服務中。

SAX解析器采用了基于事件的模型，它在解析XML文檔的時候可以觸發一系列的事件，當發現給定的tag的時候，它可以激活一個回調方法，
告訴該方法制定的標簽已經找到。SAX對內存的要求通常會比較低，因為它讓開發人員自己來決定所要處理的tag。
特別是當開發人員只需要處理文檔中所包含的部分數據時，SAX這種擴展能力得到了更好的體現。但用SAX解析器的時候編碼工作會比較困難，
而且很難同時訪問同一個文檔中的多處不同數據。

3、JDOM

JDOM的目的是成為Java特定文檔模型，它簡化與XML的交互并且比使用DOM實現更快。由于是***個Java特定模型，JDOM一直得到大力推廣和促進。

正在考慮通過“Java規范請求JSR-102”將它最終用作“Java標準擴展”。從2000年初就已經開始了JDOM開發。

JDOM與DOM主要有兩方面不同。首先，JDOM僅使用具體類而不使用接口。這在某些方面簡化了API，但是也限制了靈活性。

第二，API大量使用了Collections類，簡化了那些已經熟悉這些類的Java開發者的使用。

JDOM文檔聲明其目的是“使用20%(或更少)的精力解決80%(或更多)Java/XML問題”(根據學習曲線假定為20%)。JDOM對于大多數Java/XML應用程序來說當然是有用的，并且大多數開發者發現API比DOM容易理解得多。JDOM還包括對程序行為的相當廣泛檢查以防止用戶做任何在XML中無意義的事。

然而，它仍需要您充分理解XML以便做一些超出基本的工作(或者甚至理解某些情況下的錯誤)。這也許是比學習DOM或JDOM接口都更有意義的工作。

JDOM自身不包含解析器。它通常使用SAX2解析器來解析和驗證輸入XML文檔(盡管它還可以將以前構造的DOM表示作為輸入)。

它包含一些轉換器以將JDOM表示輸出成SAX2事件流、DOM模型或XML文本文檔。JDOM是在Apache許可證變體下發布的開放源碼。

4、DOM4J

雖然DOM4J代表了完全獨立的開發結果，但最初，它是JDOM的一種智能分支。它合并了許多超出基本XML文檔表示的功能，包括集成的XPath支持、XML Schema支持以及用于大文檔或流化文檔的基于事件的處理。它還提供了構建文檔表示的選項，它通過DOM4J API和標準DOM接口具有并行訪問功能。從2000下半年開始，它就一直處于開發之中。

為支持所有這些功能，DOM4J使用接口和抽象基本類方法。DOM4J大量使用了API中的Collections類，但是在許多情況下，它還提供一些替代方法以允許更好的性能或更直接的編碼方法。直接好處是，雖然DOM4J付出了更復雜的API的代價，但是它提供了比JDOM大得多的靈活性。在添加靈活性、XPath集成和對大文檔處理的目標時，DOM4J的目標與JDOM是一樣的：針對Java開發者的易用性和直觀操作。它還致力于成為比JDOM更完整的解決方案，實現在本質上處理所有Java/XML問題的目標。在完成該目標時，它比JDOM更少強調防止不正確的應用程序行為。

DOM4J是一個非常非常優秀的Java XML API，具有性能優異、功能強大和極端易用使用的特點，同時它也是一個開放源代碼的軟件。如今你可以看到越來越多的Java軟件都在使用DOM4J來讀寫XML，特別值得一提的是連Sun的JAXM也在用DOM4J。

比較

1、DOM4J性能***，連Sun的JAXM也在用DOM4J。目前許多開源項目中大量采用DOM4J，例如大名鼎鼎的Hibernate也用DOM4J來讀取XML配置文件。如果不考慮可移植性，那就采用DOM4J。

2、JDOM和DOM在性能測試時表現不佳，在測試10M文檔時內存溢出。在小文檔情況下還值得考慮使用DOM和JDOM。雖然JDOM的開發者已經說明他們期望在正式發行版前專注性能問題，但是從性能觀點來看，它確實沒有值得推薦之處。另外，DOM仍是一個非常好的選擇。DOM實現廣泛應用于多種編程語言。它還是許多其它與XML相關的標準的基礎，因為它正式獲得W3C推薦(與基于非標準的Java模型相對)，所以在某些類型的項目中可能也需要它(如在JavaScript中使用DOM)。

3、SAX表現較好，這要依賴于它特定的解析方式－事件驅動。一個SAX檢測即將到來的XML流，但并沒有載入到內存(當然當XML流被讀入時，會有部分文檔暫時隱藏在內存中)

原文鏈接：http://mianwww.iteye.com/blog/1270817

【編輯推薦】

1. 學習JavaScript的***方法
2. Java中反射機制詳解
3. 剖析Javascript Widget入門學習
4. 2011年計算機等級考試二級Java章節練習題***套
5. 2011年計算機等級考試二級Java筆試練習題第二套