一、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.如果子類的構造方法中沒有顯示的調用父類的構造方法，則系統(tǒng)默認的調用父類的無參的構造方法。

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有什么區(qū)別？

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

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

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

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

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

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

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

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

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

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

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

注意：聲明為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(){?
????}?
????}?

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

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

對象1的方法

synchronized(a)
synchronized(b)

對象2的方法

????synchronized(a)?
????synchronized(b)?

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

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

進入等待池

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

退出等待池進入鎖池

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

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

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

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

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

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

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

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

例子：

生產者和消費者

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

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

1）從數據類型分為字節(jié)流和字符流

字節(jié)流類：

抽象父類：?InputStream,OutputStream

實現類包括如下幾種：

BufferedInputStream?緩沖流－過慮流
BufferedOutputStream
ByteArrayInputStream?字節(jié)數組流－節(jié)點流
ByteArrayOutputStream
DataInputStream?處理JAVA標準數據流－過慮流
DataOutputStream
FileInputStream?處理文件IO流－節(jié)點流
FileOutputStream
FilterInputStream?實現過慮流－字節(jié)過慮流父類
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)?從流的功能分為節(jié)點流和過濾流

節(jié)點流用來傳輸數據。

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

五、Java中父類和子類關系

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

????Class?Son?extends?Father{?
????}?

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

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

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

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

當構造一個對象的時候，系統(tǒng)先構造父類對象，再構造子類對象。

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

1、定義線程

1）擴展java.lang.Thread類。

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

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

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

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

void?run()

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

方法?run?的常規(guī)協(xié)定是，它可能執(zhí)行任何所需的操作。

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()方法之前：線程處于新狀態(tài)中，新狀態(tài)指有一個Thread對象，但還沒有一個真正的線程。

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

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

該線程從新狀態(tài)轉移到可運行狀態(tài)；

當該線程獲得機會執(zhí)行時，其目標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();?
????}?
????}?

執(zhí)行結果：

李四:?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();?
????}?
????}?

執(zhí)行結果：

阿三?: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）在上面的代碼中，只能保證：每個線程都將啟動，每個線程都將運行直到完成。一系列線程以某種順序啟動并不意味著將按該順序執(zhí)行。對于任何一組啟動的線程來說，調度程序不能保證其執(zhí)行次序，持續(xù)時間也無法保證。

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

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

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

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

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

七、java經典面試題

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

Java基礎方面：

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

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

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

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

3、int?和?Integer?有什么區(qū)別？

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

原始類型封裝類

booleanBoolean
charCharacter
byteByte
shortShort
intInteger
longLong
floatFloat
doubleDouble

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

4、String?和StringBuffer的區(qū)別。

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

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

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

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

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

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

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

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

8、EJB是基于哪些技術實現的？并說出SessionBean和EntityBean的區(qū)別，StatefulBean和StatelessBean的區(qū)別。

EJB包括Session?Bean、Entity?Bean、Message?Driven?Bean，基于JNDI、RMI、JAT等技術實現。

SessionBean在J2EE應用程序中被用來完成一些服務器端的業(yè)務操作，例如訪問數據庫、調用其他EJB組件。EntityBean被用來代表應用系統(tǒng)中用到的數據。

對于客戶機，SessionBean是一種非持久性對象，它實現某些在服務器上運行的業(yè)務邏輯。

對于客戶機，EntityBean是一種持久性對象，它代表一個存儲在持久性存儲器中的實體的對象視圖，或是一個由現有企業(yè)應用程序實現的實體。

Session?Bean?還可以再細分為?Stateful?Session?Bean?與?Stateless?Session?Bean?，這兩種的?Session?Bean都可以將系統(tǒng)邏輯放在?method之中執(zhí)行，不同的是?Stateful?Session?Bean?可以記錄呼叫者的狀態(tài)，因此通常來說，一個使用者會有一個相對應的?Stateful?Session?Bean?的實體。Stateless?Session?Bean?雖然也是邏輯組件，但是他卻不負責記錄使用者狀態(tài)，也就是說當使用者呼叫?Stateless?Session?Bean?的時候，EJB?Container?并不會找尋特定的?Stateless?Session?Bean?的實體來執(zhí)行這個?method。換言之，很可能數個使用者在執(zhí)行某個?Stateless?Session?Bean?的?methods?時，會是同一個?Bean?的?Instance?在執(zhí)行。從內存方面來看，?Stateful?Session?Bean?與?Stateless?Session?Bean?比較，?Stateful?Session?Bean?會消耗?J2EE?Server?較多的內存，然而?Stateful?Session?Bean?的優(yōu)勢卻在于他可以維持使用者的狀態(tài)。

9、Collection?和?Collections的區(qū)別。

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

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

10、&和&&的區(qū)別。

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

11、HashMap和Hashtable的區(qū)別。

HashMap是Hashtable的輕量級實現（非線程安全的實現），他們都完成了Map接口，主要區(qū)別在于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的區(qū)別。

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

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

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

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

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

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

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

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

15、error和exception有什么區(qū)別?

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

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

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

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

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

17、abstract?class和interface有什么區(qū)別?

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

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

18、heap和stack有什么區(qū)別。

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

堆是棧的一個組成元素

19、forward?和redirect的區(qū)別

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

20、EJB與JAVA?BEAN的區(qū)別？
Java?Bean?是可復用的組件，對Java?Bean并沒有嚴格的規(guī)范，理論上講，任何一個Java類都可以是一個Bean。但通常情況下，由于Java?Bean是被容器所創(chuàng)建（如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組件由容器所創(chuàng)建和管理?？蛻敉ㄟ^容器來訪問真正的EJB組件。
八、戴爾公司電話面試Java

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

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

尊敬的應聘者xxx，

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

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

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

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

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

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

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

觀察者模式的組成

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

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

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

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

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

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

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

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

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

????void?update(Observable?observOb,?Object?arg)?

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

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

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

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

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

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

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

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

1、DOM(JAXP?Crimson解析器)

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

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

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

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

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

2、SAX

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

DOM解析器把XML文檔轉化為一個包含其內容的樹，并可以對樹進行遍歷。用DOM解析模型的優(yōu)點是編程容易，開發(fā)人員只需要調用建樹的指令，然后利用navigation?APIs訪問所需的樹節(jié)點來完成任務?？梢院苋菀椎奶砑雍托薷臉渲械脑亍Ｈ欢捎谑褂肈OM解析器的時候需要處理整個XML文檔，所以對性能和內存的要求比較高，尤其是遇到很大的XML文件的時候。由于它的遍歷能力，DOM解析器常用于XML文檔需要頻繁的改變的服務中。

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

3、JDOM

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

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

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

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

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

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

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

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

4、DOM4J

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

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

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

比較

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

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

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