建站
咨詢
售后
建站咨詢
新聞中心
一、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()方法一共出現(xiàn)了兩次，分別是super()和super(name)，請問super() 是什么含義，放在這里又作何解釋？
參考答案：
1.子類的構造過程中必須調(diào)用父類的構造方法。
2.子類可在自己的構造方法中使用super（）來調(diào)用父類的構造方法。
（1）使用this來調(diào)用本類的另外的構造方法。
（2）如果調(diào)用super必須寫在子類構造方法的***行。
3.如果子類的構造方法中沒有顯示的調(diào)用父類的構造方法，則系統(tǒng)默認的調(diào)用父類的無參的構造方法。
4.如果子類的構造方法中既沒有顯示調(diào)用父類的構造方法，而父類中又沒有無參的構造方法，則編譯出錯。
那你這里***個super（）無參的就是調(diào)用了上面Bird類的Bird() 方法！
super(name)這個有參數(shù)就是調(diào)用public Bird(String name){
this.name = name; 這個方法！super() 是調(diào)用父類的構造函數(shù)，你例子中有Bird()和Bird(String name)兩個方法，super()是調(diào)用Bird()構造函數(shù)，而super(name)是調(diào)用Birth(String name)構造函數(shù)。注意super() 調(diào)用的是對應參數(shù)個數(shù)和類型相同的父類構造函數(shù)。 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 變量所需的編碼較少，并且運行時開銷也較少，但是它所能實現(xiàn)的功能也僅是 synchronized 的一部分。
我們知道，在Java中設置變量值的操作，除了long和double類型的變量外都是原子操作，也就是說，對于變量值的簡單讀寫操作沒有必要進行同步。
這在JVM 1.2之前，Java的內(nèi)存模型實現(xiàn)總是從主存讀取變量，是不需要進行特別的注意的。而隨著JVM的成熟和優(yōu)化，現(xiàn)在在多線程環(huán)境下volatile關鍵字的使用變得非常重要。
在當前的Java內(nèi)存模型下，線程可以把變量保存在本地內(nèi)存（比如機器的寄存器）中，而不是直接在主存中進行讀寫。這就可能造成一個線程在主存中修改了一個變量的值，而另外一個線程還繼續(xù)使用它在寄存器中的變量值的拷貝，造成數(shù)據(jù)的不一致。
要解決這個問題，只需要像在本程序中的這樣，把該變量聲明為volatile（不穩(wěn)定的）即可，這就指示JVM，這個變量是不穩(wěn)定的，每次使用它都到主存中進行讀取。一般說來，多任務環(huán)境下各任務間共享的標志都應該加volatile修飾。
Volatile修飾的成員變量在每次被線程訪問時，都強迫從共享內(nèi)存中重讀該成員變量的值。而且，當成員變量發(fā)生變化時，強迫線程將變化值回寫到共享內(nèi)存。這樣在任何時刻，兩個不同的線程總是看到某個成員變量的同一個值。
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(){
- }
- }
鎖標記如果過多，就會出現(xiàn)線程等待其他線程釋放鎖標記，而又都不釋放自己的鎖標記供其他線程運行的狀況。就是死鎖。
死鎖的兩種處理方法：統(tǒng)一排列鎖順序(解決不同方法中對多個共享資源的訪問)。
對象1的方法
synchronized(a) synchronized(b)
對象2的方法
- synchronized(a)
- synchronized(b)
2．線程間通信(也就是線程間的相互協(xié)調(diào))
線程間通信使用的空間稱之為對象的等待池（wait pool），該隊列也是屬于對象的空間的。
進入等待池
使用Object類中wait()的方法，在運行狀態(tài)中，線程調(diào)用wait()，此時表示線程將釋放自己所有的鎖標記和CPU的占用，同時進入這個對象的等待池。等待池的狀態(tài)也是阻塞狀態(tài)，只不過線程釋放自己的鎖標記。
退出等待池進入鎖池
notify()：將從對象的等待池中移走一個任意的線程，并放到鎖池中，那里的對象一直在等待，直到可以獲得對象的鎖標記。
notifyAll()：將從等待池中移走所有等待那個對象的線程并放到鎖池中，只有鎖池中的線程能獲取對象的鎖標記，鎖標記允許線程從上次因調(diào)用wait()而中斷的地方開始繼續(xù)運行。
注意：只能對加鎖的資源進行wait()和notify()。
1) wait()：交出鎖和CPU的占用；
2) notify()：將從對象的等待池中移走一個任意的線程，并放到鎖池中，那里的對象一直在等待，直到可以獲得對象的鎖標記。
3) notifyAll(): 將從等待池中移走所有等待那個對象的線程并放到鎖池中，只有鎖池中的線程能獲取對象的鎖標記，鎖標記允許線程從上次因調(diào)用wait()而中斷的地方開始繼續(xù)運行。
注：在java.io包中Vector 和 HashTable 之所以是線程安全的，是因為每個方法都有synchronized修飾。Static 方法可以加 synchronized , 鎖的是類對象。
但是Vector 是 jdk 1.0 的 ArrayList 是 jdk1.2 所以實際應用還是使用ArrayList
例子：
生產(chǎn)者和消費者
一個柜臺一定數(shù)量的產(chǎn)品,柜臺滿時不能生產(chǎn)，空時不能夠買。
四、Java中流的分類都有哪些？
1）從數(shù)據(jù)類型分為字節(jié)流和字符流
字節(jié)流類：
抽象父類： InputStream,OutputStream
實現(xiàn)類包括如下幾種：
BufferedInputStream 緩沖流－過慮流 BufferedOutputStream ByteArrayInputStream 字節(jié)數(shù)組流－節(jié)點流 ByteArrayOutputStream DataInputStream 處理JAVA標準數(shù)據(jù)流－過慮流 DataOutputStream FileInputStream 處理文件IO流－節(jié)點流 FileOutputStream FilterInputStream 實現(xiàn)過慮流－字節(jié)過慮流父類 FilterOutputStream PipedInputStream 管道流 PipedOutputStream PrintStream 包含print() 和 println() RandomAccessFile 支持隨機文件
抽象父類：Reader, Writer
實現(xiàn)類：
BufferedReader BufferedWriter PrintWriter CharArrayReader CharArrayWriter FileReader FileWriter FilterReader FilterWriter InputStreamReader OutputStreamWriter PipedReader PipedWriter StringReader StringWriter
2) 從數(shù)據(jù)方向分為輸入流和輸出流
InputXXXXX , OutputXXXXX
3) 從流的功能分為節(jié)點流和過濾流
節(jié)點流用來傳輸數(shù)據(jù)。
過濾流用來封裝節(jié)點流或者其他過濾流，從而給節(jié)點流或其他的過濾流增加一個功能。
五、Java中父類和子類關系
父類的非私有化屬性(不同包的子類無法訪問default修飾符)和方法可以默認繼承到子類。
- Class Son extends Father{
- }
而如果父類中的私有方法被子類調(diào)用的話，則編譯報錯。
父類的構造方法子類不可以繼承，更不存在覆蓋的問題。
所以子類構造方法默認調(diào)用父類的無參構造方法。（所以養(yǎng)成寫無參構造的習慣）
如果子類訪問父類的有參構造方法，必須在子類構造方法***行使用super(參數(shù))
當構造一個對象的時候，系統(tǒng)先構造父類對象，再構造子類對象。
- Public class BMWcar extends Car{
- Public BMWcar(){
- Super(int alength); //顯式的調(diào)用父類的構造，默認調(diào)用無參構造
- //所以父類沒有無參構造的話，子類如果不加顯示調(diào)用其他構造就會報錯。這里的super是一個對父類的引用
- }
- }
#p#
六、Java多線程常見面試題
1、定義線程
1）擴展java.lang.Thread類。
此類中有個run()方法，應該注意其用法：
public void run()如果該線程是使用獨立的 Runnable 運行對象構造的，則調(diào)用該 Runnable 對象的 run 方法；否則，該方法不執(zhí)行任何操作并返回。
Thread 的子類應該重寫該方法。
2）實現(xiàn)java.lang.Runnable接口。
void run()
使用實現(xiàn)接口 Runnable 的對象創(chuàng)建一個線程時，啟動該線程將導致在獨立執(zhí)行的線程中調(diào)用對象的 run 方法。
方法 run 的常規(guī)協(xié)定是，它可能執(zhí)行任何所需的操作。
2、實例化線程
1）如果是擴展java.lang.Thread類的線程，則直接new即可。
2）如果是實現(xiàn)了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對象上調(diào)用start()方法，而不是run()或者別的方法。
在調(diào)用start()方法之前：線程處于新狀態(tài)中，新狀態(tài)指有一個Thread對象，但還沒有一個真正的線程。
在調(diào)用start()方法之后：發(fā)生了一系列復雜的事情
啟動新的執(zhí)行線程（具有新的調(diào)用棧）；
該線程從新狀態(tài)轉移到可運行狀態(tài)；
當該線程獲得機會執(zhí)行時，其目標run()方法將運行。
注意：對Java來說，run()方法沒有任何特別之處。像main()方法一樣，它只是新線程知道調(diào)用的方法名稱(和簽名)。因此，在Runnable上或者Thread上調(diào)用run方法是合法的。但并不啟動新的線程。
4、例子
1）實現(xiàn)Runnable接口的多線程例子。
- /**
- * 實現(xiàn)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類實現(xiàn)的多線程程序
- *
- * @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類實現(xiàn)的多線程例子。
- /**
- * 測試擴展Thread類實現(xiàn)的多線程程序
- *
- * @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í)行。對于任何一組啟動的線程來說，調(diào)度程序不能保證其執(zhí)行次序，持續(xù)時間也無法保證。
5）當線程目標run()方法結束時該線程完成。
6）一旦線程啟動，它就永遠不能再重新啟動。只有一個新的線程可以被啟動，并且只能一次。一個可運行的線程或死線程可以被重新啟動。
7）線程的調(diào)度是JVM的一部分，在一個CPU的機器上上，實際上一次只能運行一個線程。一次只有一個線程棧執(zhí)行。JVM線程調(diào)度程序決定實際運行哪個處于可運行狀態(tài)的線程。眾多可運行線程中的某一個會被選中做為當前線程。可運行線程被選擇運行的順序是沒有保障的。
8）盡管通常采用隊列形式，但這是沒有保障的。隊列形式是指當一個線程完成“一輪”時，它移到可運行隊列的尾部等待，直到它最終排隊到該隊列的前端為止，它才能被再次選中。事實上，我們把它稱為可運行池而不是一個可運行隊列，目的是幫助認識線程并不都是以某種有保障的順序排列唱呢個一個隊列的事實。
9）盡管我們沒有無法控制線程調(diào)度程序，但可以通過別的方式來影響線程調(diào)度的方式。
七、java經(jīng)典面試題
總結了一下java的一些企業(yè)常面試的面試題，也可以說是堪稱經(jīng)典吧！大部分企業(yè)的面試題，差不多都會以下我列出的面試題！而且面試題為紅色的題更是企業(yè)經(jīng)常面試的，可以說是屢試不爽，大家如果看到了我的這篇文章，那么請你進來看看，會對你有不小的收獲的。
Java基礎方面：
1、Static Nested Class 和 Inner Class的不同。
Static Nested Class是被聲明為靜態(tài)（static）的內(nèi)部類，它可以不依賴于外部類實例被實例化。而通常的內(nèi)部類需要在外部類實例化后才能實例化。
2、java.lang.String類是否能被繼承和修改，為什么？
java.lang.String類是final類型的，因此不可以繼承這個類、不能修改這個類。為了提高效率節(jié)省空間，我們應該用StringBuffer類
3、int 和 Integer 有什么區(qū)別？
Java 提供兩種不同的類型：引用類型和原始類型（或內(nèi)置類型）。Int是java的原始數(shù)據(jù)類型，Integer是java為int提供的封裝類。Java為每個原始類型提供了封裝類。
原始類型封裝類
booleanBoolean charCharacter byteByte shortShort intInteger longLong floatFloat doubleDouble
引 用類型和原始類型的行為完全不同，并且它們具有不同的語義。引用類型和原始類型具有不同的特征和用法，它們包括：大小和速度問題，這種類型以哪種類型的數(shù) 據(jù)結構存儲，當引用類型和原始類型用作某個類的實例數(shù)據(jù)時所指定的缺省值。對象引用實例變量的缺省值為 null，而原始類型實例變量的缺省值與它們的類型有關。
4、String 和StringBuffer的區(qū)別。
JAVA 平臺提供了兩個類：String和StringBuffer，它們可以儲存和操作字符串，即包含多個字符的字符數(shù)據(jù)。這個String類提供了數(shù)值不可改 變的字符串。而這個StringBuffer類提供的字符串進行修改。當你知道字符數(shù)據(jù)要改變的時候你就可以使用StringBuffer。典型地，你可 以使用StringBuffers來動態(tài)構造字符數(shù)據(jù)。
5、運行時異常與一般異常有何異同？
異常表示程序運行過程中可能出現(xiàn)的非正常狀態(tài)，運行時異常表示虛擬機的通常操作中可能遇到的異常，是一種常見運行錯誤。java編譯器要求方法必須聲明拋出可能發(fā)生的非運行時異常，但是并不要求必須聲明拋出未被捕獲的運行時異常。
6、說出Servlet的生命周期，并說出Servlet和CGI的區(qū)別。
Servlet被服務器實例化后，容器運行其init方法，請求到達時運行其service方法，service方法自動派遣運行與請求對應的doXXX方法（doGet，doPost）等，當服務器決定將實例銷毀的時候調(diào)用其destroy方法。
與cgi的區(qū)別在于servlet處于服務器進程中，它通過多線程方式運行其service方法，一個實例可以服務于多個請求，并且其實例一般不會銷毀，而CGI對每個請求都產(chǎn)生新的進程，服務完成后就銷毀，所以效率上低于servlet。
7、說出ArrayList,Vector, LinkedList的存儲性能和特性。
ArrayList 和Vector都是使用數(shù)組方式存儲數(shù)據(jù)，此數(shù)組元素數(shù)大于實際存儲的數(shù)據(jù)以便增加和插入元素，它們都允許直接按序號索引元素，但是插入元素要涉及數(shù)組元 素移動等內(nèi)存操作，所以索引數(shù)據(jù)快而插入數(shù)據(jù)慢，Vector由于使用了synchronized方法（線程安全），通常性能上較ArrayList差， 而LinkedList使用雙向鏈表實現(xiàn)存儲，按序號索引數(shù)據(jù)需要進行前向或后向遍歷，但是插入數(shù)據(jù)時只需要記錄本項的前后項即可，所以插入速度較快。
8、EJB是基于哪些技術實現(xiàn)的？并說出SessionBean和EntityBean的區(qū)別，StatefulBean和StatelessBean的區(qū)別。
EJB包括Session Bean、Entity Bean、Message Driven Bean，基于JNDI、RMI、JAT等技術實現(xiàn)。
SessionBean在J2EE應用程序中被用來完成一些服務器端的業(yè)務操作，例如訪問數(shù)據(jù)庫、調(diào)用其他EJB組件。EntityBean被用來代表應用系統(tǒng)中用到的數(shù)據(jù)。
對于客戶機，SessionBean是一種非持久性對象，它實現(xiàn)某些在服務器上運行的業(yè)務邏輯。
對于客戶機，EntityBean是一種持久性對象，它代表一個存儲在持久性存儲器中的實體的對象視圖，或是一個由現(xiàn)有企業(yè)應用程序實現(xiàn)的實體。
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。換言之，很可能數(shù)個使用者在執(zhí)行某個 Stateless Session Bean 的 methods 時，會是同一個 Bean 的 Instance 在執(zhí)行。從內(nèi)存方面來看， Stateful Session Bean 與 Stateless Session Bean 比較， Stateful Session Bean 會消耗 J2EE Server 較多的內(nèi)存，然而 Stateful Session Bean 的優(yōu)勢卻在于他可以維持使用者的狀態(tài)。
9、Collection 和 Collections的區(qū)別。
Collection是集合類的上級接口，繼承與他的接口主要有Set 和List.
Collections是針對集合類的一個幫助類，他提供一系列靜態(tài)方法實現(xiàn)對各種集合的搜索、排序、線程安全化等操作。
10、&和&&的區(qū)別。
&是位運算符，表示按位與運算，&&是邏輯運算符，表示邏輯與（and）。
11、HashMap和Hashtable的區(qū)別。
HashMap是Hashtable的輕量級實現(xiàn)（非線程安全的實現(xiàn)），他們都完成了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的一個實現(xiàn)。
***的不同是，Hashtable的方法是Synchronize的，而HashMap不是，在多個線程訪問Hashtable時，不需要自己為它的方法實現(xiàn)同步，而HashMap 就必須為之提供外同步。
Hashtable和HashMap采用的hash/rehash算法都大概一樣，所以性能不會有很大的差異。
12、final, finally, finalize的區(qū)別。
final 用于聲明屬性，方法和類，分別表示屬性不可變，方法不可覆蓋，類不可繼承。
finally是異常處理語句結構的一部分，表示總是執(zhí)行。
finalize是Object類的一個方法，在垃圾收集器執(zhí)行的時候會調(diào)用被回收對象的此方法，可以覆蓋此方法提供垃圾收集時的其他資源回收，例如關閉文件等。
13、sleep() 和 wait() 有什么區(qū)別?
sleep是線程類（Thread）的方法，導致此線程暫停執(zhí)行指定時間，給執(zhí)行機會給其他線程，但是監(jiān)控狀態(tài)依然保持，到時后會自動恢復。調(diào)用sleep不會釋放對象鎖。
wait是Object類的方法，對此對象調(diào)用wait方法導致本線程放棄對象鎖，進入等待此對象的等待鎖定池，只有針對此對象發(fā)出notify方法（或notifyAll）后本線程才進入對象鎖定池準備獲得對象鎖進入運行狀態(tài)。
14、Overload和Override的區(qū)別。Overloaded的方法是否可以改變返回值的類型?
方 法的重寫Overriding和重載Overloading是Java多態(tài)性的不同表現(xiàn)。重寫Overriding是父類與子類之間多態(tài)性的一種表現(xiàn)，重 載Overloading是一個類中多態(tài)性的一種表現(xiàn)。如果在子類中定義某方法與其父類有相同的名稱和參數(shù)，我們說該方法被重寫 (Overriding)。子類的對象使用這個方法時，將調(diào)用子類中的定義，對它而言，父類中的定義如同被”屏蔽”了。如果在一個類中定義了多個同名的方 法，它們或有不同的參數(shù)個數(shù)或有不同的參數(shù)類型，則稱為方法的重載(Overloading)。Overloaded的方法是可以改變返回值的類型。
15、error和exception有什么區(qū)別?
error 表示恢復不是不可能但很困難的情況下的一種嚴重問題。比如說內(nèi)存溢出。不可能指望程序能處理這樣的情況。
exception 表示一種設計或實現(xiàn)問題。也就是說，它表示如果程序運行正常，從不會發(fā)生的情況。
16、同步和異步有何異同，在什么情況下分別使用他們？舉例說明。
如果數(shù)據(jù)將在線程間共享。例如正在寫的數(shù)據(jù)以后可能被另一個線程讀到，或者正在讀的數(shù)據(jù)可能已經(jīng)被另一個線程寫過了，那么這些數(shù)據(jù)就是共享數(shù)據(jù)，必須進行同步存取。
當應用程序在對象上調(diào)用了一個需要花費很長時間來執(zhí)行的方法，并且不希望讓程序等待方法的返回時，就應該使用異步編程，在很多情況下采用異步途徑往往更有效率。
17、abstract class和interface有什么區(qū)別?
聲 明方法的存在而不去實現(xiàn)它的類被叫做抽象類（abstract class），它用于要創(chuàng)建一個體現(xiàn)某些基本行為的類，并為該類聲明方法，但不能在該類中實現(xiàn)該類的情況。不能創(chuàng)建abstract 類的實例。然而可以創(chuàng)建一個變量，其類型是一個抽象類，并讓它指向具體子類的一個實例。不能有抽象構造函數(shù)或抽象靜態(tài)方法。Abstract 類的子類為它們父類中的所有抽象方法提供實現(xiàn)，否則它們也是抽象類為。取而代之，在子類中實現(xiàn)該方法。知道其行為的其它類可以在類中實現(xiàn)這些方法。
接 口（interface）是抽象類的變體。在接口中，所有方法都是抽象的。多繼承性可通過實現(xiàn)這樣的接口而獲得。接口中的所有方法都是抽象的，沒有一個有 程序體。接口只可以定義static final成員變量。接口的實現(xiàn)與子類相似，除了該實現(xiàn)類不能從接口定義中繼承行為。當類實現(xiàn)特殊接口時，它定義（即將程序體給予）所有這種接口的方法。 然后，它可以在實現(xiàn)了該接口的類的任何對象上調(diào)用接口的方法。由于有抽象類，它允許使用接口名作為引用變量的類型。通常的動態(tài)聯(lián)編將生效。引用可以轉換到 接口類型或從接口類型轉換，instanceof 運算符可以用來決定某對象的類是否實現(xiàn)了接口。
18、heap和stack有什么區(qū)別。
棧是一種線形集合，其添加和刪除元素的操作應在同一段完成。棧按照后進先出的方式進行處理。
堆是棧的一個組成元素
19、forward 和redirect的區(qū)別
forward是服務器請求資源，服務器直接訪問目標地址的URL，把那個URL的響應內(nèi)容讀取過來，然后把這些內(nèi)容再發(fā)給瀏覽器，瀏覽器根本不知道服務器發(fā)送的內(nèi)容是從哪兒來的，所以它的地址欄中還是原來的地址。
redirect就是服務端根據(jù)邏輯,發(fā)送一個狀態(tài)碼,告訴瀏覽器重新去請求那個地址，一般來說瀏覽器會用剛才請求的所有參數(shù)重新請求，所以session,request參數(shù)都可以獲取。
20、EJB與JAVA BEAN的區(qū)別？
Java Bean 是可復用的組件，對Java Bean并沒有嚴格的規(guī)范，理論上講，任何一個Java類都可以是一個Bean。但通常情況下，由于Java Bean是被容器所創(chuàng)建（如Tomcat）的，所以Java Bean應具有一個無參的構造器，另外，通常Java Bean還要實現(xiàn)Serializable接口用于實現(xiàn)Bean的持久性。Java Bean實際上相當于微軟COM模型中的本地進程內(nèi)COM組件，它是不能被跨進程訪問的。Enterprise Java Bean 相當于DCOM，即分布式組件。它是基于Java的遠程方法調(diào)用（RMI）技術的，所以EJB可以被遠程訪問（跨進程、跨計算機）。但EJB必須被布署在 諸如Webspere、WebLogic這樣的容器中，EJB客戶從不直接訪問真正的EJB組件，而是通過其容器訪問。EJB容器是EJB組件的代理， EJB組件由容器所創(chuàng)建和管理?？蛻敉ㄟ^容器來訪問真正的EJB組件。
#p#
八、戴爾公司電話面試Java
接到了dell公司項目經(jīng)理的電話面試，我們從java 的接口，abstract函數(shù)，談的c++的虛函數(shù)，然后談到java native interface。談到動態(tài)庫，談到靜態(tài)庫，然后談到了進程間通訊，操作系統(tǒng)是如何管理進程的，已經(jīng)操作系統(tǒng)原理。談到了android的framework的部分原理，談到了aidl接口。
九、一朋友面試失敗后得到的一個回復信 你被涮后有過回復信嗎？
尊敬的應聘者xxx，
非常感謝您到敝公司來面試。經(jīng)過我們對您的表現(xiàn)的認真評估，認為您目前還不適合敝公司的職位。如果您想在Java開發(fā)方面有好的發(fā)展，我們對您有以下建議：
1. 要注重基礎知識的學習，不要只會SSH框架。
2. 多學習一些Linux方面的知識。
3. 推薦您看看Java核心技術，Think in java這兩本書。
4. 建議您閑時上一些技術論壇看看，同大家多交流交流技術。
十、什么是觀察者模式(Observer)？
觀察者模式定義了一種一對多的依賴關系，讓多個觀察者對象同時監(jiān)聽某一個主題對象。這個主題對象在狀態(tài)上發(fā)生變化時，會通知所有觀察者對象，讓他們能夠自動更新自己
觀察者模式的組成
抽象主題角色：把所有對觀察者對象的引用保存在一個集合中，每個抽象主題角色都可以有任意數(shù)量的觀察者。抽象主題提供一個接口，可以增加和刪除觀察者角色。一般用一個抽象類或接口來實現(xiàn)。
抽象觀察者角色：為所有具體的觀察者定義一個接口，在得到主題的通知時更新自己。
從AWT1.1開始圖形系統(tǒng)的事件模型采用觀察者模式，因此觀察者模式在Java語言中的地位極其重要。
在xml解析中的SAX也采用了觀察者模式來實現(xiàn)。
Java也提供了對觀察者模式的內(nèi)置支持。
Observable類用于創(chuàng)建可以觀測到你的程序中其他部分的子類。當這種子類的對象發(fā)生變化時，觀測類被通知。觀測類必須實現(xiàn)定義了update( )方法的Observer接口。當一個觀測程序被通知到一個被觀測對象的改變時，update( )方法被調(diào)用。
一個被觀測的對象必須服從下面的兩個簡單規(guī)則。***，如果它被改變了，它必須調(diào)用setChanged( )方法。第二，當它準備通知觀測程序它的改變時，它必須調(diào)用notifyObservers( )方法。這導致了在觀測對象中對update( )方法的調(diào)用。注意——當對象在調(diào)用notifyObservers( )方法之前，沒有調(diào)用setChanged( )方法，就不會有什么動作發(fā)生。在update( )被調(diào)用之前，被觀測對象必須調(diào)用setChanged( )和notifyObservers( )兩種方法。
注意notifyObservers()有兩種形式：一種帶有參數(shù)而另一種沒有。當用參數(shù)調(diào)用notifyObservers( )方法時，該對象被傳給觀測程序的update( )方法作為其第二個參數(shù)。否則，將給update( )方法傳遞一個null?？梢允褂玫诙€參數(shù)傳遞適合于你的應用程序的任何類型的對象。
為了觀測一個可觀測的對象，必須實現(xiàn)Observer接口。這個接口僅僅定義了如下所示的一個方法。
- void update(Observable observOb, Object arg)
這里，observOb是被觀測的對象，而arg是由notifyObservers( )方法傳遞的值。當被觀測對象發(fā)生了改變，調(diào)用update( )方法。
十一、JavaEE N層架構的好處都有哪些？
JavaEE帶來的好處是雙向的，對于開發(fā)應用的公司和使用它的客戶，優(yōu)點主要在于4個方面。
1、簡化了體系和開發(fā)。相對于傳統(tǒng)的應用開發(fā)，JavaEE提供了簡單的、基于組件的開發(fā)模型。這個模型提供了WORA（Write Once, Run Anywhere）的可移植性，只要符合JavaEE規(guī)范的服務器，就可以運行應用。同時，基于組件的開發(fā)模型也大大提高了生產(chǎn)力。
2、集成現(xiàn)有的企業(yè)信息系統(tǒng)。JavaEE平臺，與JavaSE平臺一樣，提供訪問現(xiàn)有的企業(yè)信息系統(tǒng)的一些工業(yè)標準API；
3、提供可擴展性。當前JavaEE容器向組件提供事務支持、數(shù)據(jù)庫連接、生命周期管理和影響性能的其它特性，從而提供可擴展性（scalability）。
4、安全機制。JavaEE支持豐富的跨越整個體系的一致的安全措施。
十二、四種操作xml的方式：SAX, DOM, JDOM , DOM4J的比較
1、DOM(JAXP Crimson解析器)
DOM是用與平臺和語言無關的方式表示XML文檔的官方W3C標準。DOM是以層次結構組織的節(jié)點或信息片斷的集合。
這個層次結構允許開發(fā)人員在樹中尋找特定信息。分析該結構通常需要加載整個文檔和構造層次結構，然后才能做任何工作。
由于它是基于信息層次的，因而DOM被認為是基于樹或基于對象的。DOM以及廣義的基于樹的處理具有幾個優(yōu)點。
首先，由于樹在內(nèi)存中是持久的，因此可以修改它以便應用程序能對數(shù)據(jù)和結構作出更改。
它還可以在任何時候在樹中上下導航，而不是像SAX那樣是一次性的處理。DOM使用起來也要簡單得多。
2、SAX
SAX處理的優(yōu)點非常類似于流媒體的優(yōu)點。分析能夠立即開始，而不是等待所有的數(shù)據(jù)被處理。而且，由于應用程序只是在讀取數(shù)據(jù)時檢查數(shù)據(jù)，因此不需要將數(shù)據(jù)存儲在內(nèi)存中。這對于大型文檔來說是個巨大的優(yōu)點。事實上，應用程序甚至不必解析整個文檔；它可以在某個條件得到滿足時停止解析。一般來說，SAX還比它的替代者DOM快許多。 選擇DOM還是選擇SAX？ 對于需要自己編寫代碼來處理XML文檔的開發(fā)人員來說，選擇DOM還是SAX解析模型是一個非常重要的設計決策。 DOM采用建立樹形結構的方式訪問XML文檔，而SAX采用的事件模型。
DOM解析器把XML文檔轉化為一個包含其內(nèi)容的樹，并可以對樹進行遍歷。用DOM解析模型的優(yōu)點是編程容易，開發(fā)人員只需要調(diào)用建樹的指令，然后利用navigation APIs訪問所需的樹節(jié)點來完成任務?？梢院苋菀椎奶砑雍托薷臉渲械脑?。然而由于使用DOM解析器的時候需要處理整個XML文檔，所以對性能和內(nèi)存的要求比較高，尤其是遇到很大的XML文件的時候。由于它的遍歷能力，DOM解析器常用于XML文檔需要頻繁的改變的服務中。
SAX解析器采用了基于事件的模型，它在解析XML文檔的時候可以觸發(fā)一系列的事件，當發(fā)現(xiàn)給定的tag的時候，它可以激活一個回調(diào)方法，
告訴該方法制定的標簽已經(jīng)找到。SAX對內(nèi)存的要求通常會比較低，因為它讓開發(fā)人員自己來決定所要處理的tag。
特別是當開發(fā)人員只需要處理文檔中所包含的部分數(shù)據(jù)時，SAX這種擴展能力得到了更好的體現(xiàn)。但用SAX解析器的時候編碼工作會比較困難，
而且很難同時訪問同一個文檔中的多處不同數(shù)據(jù)。
3、JDOM
JDOM的目的是成為Java特定文檔模型，它簡化與XML的交互并且比使用DOM實現(xiàn)更快。由于是***個Java特定模型，JDOM一直得到大力推廣和促進。
正在考慮通過“Java規(guī)范請求JSR-102”將它最終用作“Java標準擴展”。從2000年初就已經(jīng)開始了JDOM開發(fā)。
JDOM與DOM主要有兩方面不同。首先，JDOM僅使用具體類而不使用接口。這在某些方面簡化了API，但是也限制了靈活性。
第二，API大量使用了Collections類，簡化了那些已經(jīng)熟悉這些類的Java開發(fā)者的使用。
JDOM文檔聲明其目的是“使用20%(或更少)的精力解決80%(或更多)Java/XML問題”(根據(jù)學習曲線假定為20%)。JDOM對于大多數(shù)Java/XML應用程序來說當然是有用的，并且大多數(shù)開發(fā)者發(fā)現(xiàn)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更完整的解決方案，實現(xiàn)在本質(zhì)上處理所有Java/XML問題的目標。在完成該目標時，它比JDOM更少強調(diào)防止不正確的應用程序行為。
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在性能測試時表現(xiàn)不佳，在測試10M文檔時內(nèi)存溢出。在小文檔情況下還值得考慮使用DOM和JDOM。雖然JDOM的開發(fā)者已經(jīng)說明他們期望在正式發(fā)行版前專注性能問題，但是從性能觀點來看，它確實沒有值得推薦之處。另外，DOM仍是一個非常好的選擇。DOM實現(xiàn)廣泛應用于多種編程語言。它還是許多其它與XML相關的標準的基礎，因為它正式獲得W3C推薦(與基于非標準的Java模型相對)，所以在某些類型的項目中可能也需要它(如在JavaScript中使用DOM)。
3、SAX表現(xiàn)較好，這要依賴于它特定的解析方式－事件驅動。一個SAX檢測即將到來的XML流，但并沒有載入到內(nèi)存(當然當XML流被讀入時，會有部分文檔暫時隱藏在內(nèi)存中)
新聞標題：11月份的Java面試題新鮮出爐
標題網(wǎng)址：http://www.fisionsoft.com.cn/article/dpcijep.html
