第一篇：Java經典面試題大全-帶答案
Java經典面試題 帶答案
一、單項選擇題
1．Java是從（）語言改進重新設計。
A．Ada
B．C++
C．Pasacal
D．BASIC
答案：B
2．下列語句哪一個正確（）
A． Java程序經編譯后會產生machine code
B．Java程序經編譯后會產生byte code(字節(jié)碼)
C．Java程序經編譯后會產生DLL
D．以上都不正確
答案：B
3．下列說法正確的有（）
A．class中的constructor不可省略
B． constructor必須與class同名，但方法不能與class同名
C．constructor在一個對象被new時執(zhí)行（構造器）
D．一個class只能定義一個constructor
答案：C
4．提供Java存取數(shù)據庫能力的包是（）
A．Java.sql /sql/數(shù)據庫 還有 Oracle 也是一種數(shù)據庫
B．java.awt
C．java.lang
D．java.swing
答案：A
5．下列運算符合法的是（）
A．&&
B．<>
C．if
D．:=
答案：A
6．執(zhí)行如下程序代碼
a=0;c=0;
do{
--c;
a=a-1;
}while(a>0);
后，C的值是（）
A．0
B．1
C．-1
D．死循環(huán)
答案：C
7．下列哪一種敘述是正確的（）
A．abstract修飾符可修飾字段、方法和類
B．抽象方法的body部分必須用一對大括號{}包住
C．聲明抽象方法，大括號可有可無
D．聲明抽象方法不可寫出大括號
答案：D
8．下列語句正確的是（）
A．形式參數(shù)可被視為localvariable
B．形式參數(shù)可被字段修飾符修飾
C．形式參數(shù)為方法被調用時，真正被傳遞的參數(shù)
D．形式參數(shù)不可以是對象
答案：A
9．下列哪種說法是正確的（）
A．實例方法可直接調用超類的實例方法
B．實例方法可直接調用超類的類方法
C．實例方法可直接調用其他類的實例方法
D．實例方法可直接調用本類的類方法
答案：D
二、多項選擇題
1．Java程序的種類有（）
A．類（Class）
B．Applet
C．Application
D．Servlet
2．下列說法正確的有（）
A．環(huán)境變量可在編譯sourcecode時指定
B．在編譯程序時，所能指定的環(huán)境變量不包括class path
C．javac一次可同時編譯數(shù)個Java源文件
D．javac.exe能指定編譯結果要置于哪個目錄（directory）
答案：BCD
3．下列標識符不合法的有（）
A．new
B．$Usdollars
C．1234
D．car.taxi
答案：ACD
4．下列說法錯誤的有（）
A．數(shù)組是一種對象
B．數(shù)組屬于一種原生類
C．intnumber=[]={31,23,33,43,35,63}
D．數(shù)組的大小可以任意改變
答案：BCD
5．不能用來修飾interface的有（）
A．private
B．public
C．protected
D．static
答案：ACD
6．下列正確的有（）
A． call byvalue不會改變實際參數(shù)的數(shù)值
B． call by reference能改變實際參數(shù)的參考地址
C． call byreference不能改變實際參數(shù)的參考地址
D． call byreference能改變實際參數(shù)的內容
答案：ACD
7．下列說法錯誤的有（）
A．在類方法中可用this來調用本類的類方法
B．在類方法中調用本類的類方法時可直接調用
C．在類方法中只能調用本類中的類方法
D．在類方法中絕對不能調用實例方法
答案：ACD
8．下列說法錯誤的有（）
A．Java面向對象語言容許單獨的過程與函數(shù)存在 B． Java面向對象語言容許單獨的方法存在
C．Java語言中的方法屬于類中的成員（member）
D．Java語言中的方法必定隸屬于某一類（對象），調用方法與過程或函數(shù)相同
答案：ABC
9．下列說法錯誤的有（）
A．能被java.exe成功運行的javaclass文件必須有main()方法
B． J2SDK就是Java API
C．Appletviewer.exe可利用jar選項運行.jar文件
D．能被Appletviewer成功運行的javaclass文件必須有main()方法
答案：BCD
三、判斷題
1．Java程序中的起始類名稱必須與存放該類的文件名相同。（）
答案：正確
2．Unicode是用16位來表示一個字的。（）
答案：正確
3．原生類中的數(shù)據類型均可任意轉換。（）
答案：錯誤
1.分別寫出BOOL,int,float,指針類型的變量a 與“零”的比較語句。
答案：
BOOL : if(!a)orif(a)
int : if(a == 0)
float : const EXPRESSION EXP = 0.000001
if(a < EXP && a >-EXP)
pointer : if(a!=NULL)or if(a == NULL)
2.請說出const與#define 相比，有何優(yōu)點？
答案：1）const常量有數(shù)據類型，而宏常量沒有數(shù)據類型。編譯器可以對前者進行類型安全檢查。而對后者只進行字符替換，沒有類型安全檢查，并且在字符替換可能會產生意料不到的錯誤。
2）有些集成化的調試工具可以對const 常量進行調試，但是不能對宏常量進行調試。
3.簡述數(shù)組與指針的區(qū)別？
數(shù)組要么在靜態(tài)存儲區(qū)被創(chuàng)建（如全局數(shù)組），要么在棧上被創(chuàng)建。指針可以隨時指向任意類型的內存塊。
(1)修改內容上的差別
char a[]= “hello”;
a[0] = ?X?;
char *p = “world”;// 注意p 指向常量字符串
p[0] = ?X?;// 編譯器不能發(fā)現(xiàn)該錯誤，運行時錯誤
(2)用運算符sizeof 可以計算出數(shù)組的容量（字節(jié)數(shù)）。sizeof(p),p為指針得到的是一個指針變量的字節(jié)數(shù)，而不是p 所指的內存容量。C++/C語言沒有辦法知道指針所指的內存容量，除非在申請內存時記住它。注意當數(shù)組作為函數(shù)的參數(shù)進行傳遞時，該數(shù)組自動退化為同類型的指針。
char a[] =“hello world”;
char *p = a;
cout<< sizeof(a)<< endl;// 12字節(jié)
cout<< sizeof(p)<< endl;// 4 字節(jié)
計算數(shù)組和指針的內存容量
voidFunc(char a[100])
{
cout<< sizeof(a)<< endl;// 4 字節(jié)而不是100字節(jié)
}
4.類成員函數(shù)的重載、覆蓋和隱藏區(qū)別？
答案：
a.成員函數(shù)被重載的特征：
（1）相同的范圍（在同一個類中）；
（2）函數(shù)名字相同；
（3）參數(shù)不同；
（4）virtual 關鍵字可有可無。
b.覆蓋是指派生類函數(shù)覆蓋基類函數(shù)，特征是：
（1）不同的范圍（分別位于派生類與基類）；
（2）函數(shù)名字相同；
（3）參數(shù)相同；
（4）基類函數(shù)必須有virtual 關鍵字。
c.“隱藏”是指派生類的函數(shù)屏蔽了與其同名的基類函數(shù)，規(guī)則如下：
（1）如果派生類的函數(shù)與基類的函數(shù)同名，但是參數(shù)不同。此時，不論有無virtual關鍵字，基類的函數(shù)將被隱藏（注意別與重載混淆）。
（2）如果派生類的函數(shù)與基類的函數(shù)同名，并且參數(shù)也相同，但是基類函數(shù)沒有virtual 關鍵字。此時，基類的函數(shù)被隱藏（注意別與覆蓋混淆）
5.There are two int variables: a and b, don?t use “if”, “? :”, “switch”orother judgement statements, find out the biggest one of the two numbers.答案：((a + b)+ abs(ai-1;j++){ if(data[j] > data[j+1]){ tag = true;int temp = data[j];data[j] = data[j+1];data[j+1] = temp;} } if(!tag)break;} } void main(void){ vectordata;ifstreamin(“c:data.txt”);if(!in){ cout<<“file error!”;exit(1);} int temp;while(!in.eof()){ in>>temp;data.push_back(temp);
}
in.close();//關閉輸入文件流
Order(data);
ofstream out(“c:result.txt”);
if(!out)
{
cout<<“fileerror!”;
exit(1);
}
for(i = 0;i < data.size();i++)
out< 10.鏈表題：一個鏈表的結點結構 struct Node { int data; Node *next; }; typedef struct Node Node; (1)已知鏈表的頭結點head,寫一個函數(shù)把這個鏈表逆序(Intel) Node * ReverseList(Node*head)//鏈表逆序 { if(head == NULL || head->next == NULL) returnhead; Node *p1 = head; Node *p2 = p1->next; Node *p3 =p2->next; p1->next = NULL; while(p3!= NULL) { p2->next = p1; p1 = p2; p2 = p3; p3 = p3->next; } p2->next = p1; head = p2; return head; } 2)已知兩個鏈表head1 和head2 各自有序，請把它們合并成一個鏈表依然有序。(保留所有結點，即便大小相同） Node *Merge(Node *head1 , Node *head2) { if(head1 == NULL) return head2; if(head2 == NULL) return head1; Node *head = NULL; Node*p1 = NULL; Node *p2 = NULL; if(head1->data < head2->data) { head = head1; p1 = head1->next; p2 = head2; } else { head = head2; p2 = head2->next; p1 = head1; } Node *pcurrent = head; while(p1!= NULL && p2!= NULL) { if(p1->data <= p2->data) { pcurrent->next = p1; pcurrent = p1; p1 = p1->next; } else { pcurrent->next = p2; pcurrent = p2; p2 = p2->next; } } if(p1!= NULL) pcurrent->next = p1; if(p2!= NULL) pcurrent->next = p2; return head; } (3)已知兩個鏈表head1 和head2各自有序，請把它們合并成一個鏈表依然有序，這次要求用遞歸方法進行。(Autodesk) 答案： Node *MergeRecursive(Node *head1 , Node *head2) { if(head1 == NULL)return head2;if(head2 == NULL)return head1;Node *head =NULL;if(head1->data < head2->data){ head = head1;head->next = MergeRecursive(head1->next,head2);} else { head = head2;head->next = MergeRecursive(head1,head2->next);} return head;} Substring charAt 大小寫轉換 熟練使用dbcp、c3p0 druid 解釋get和post的區(qū)別？ 1、安全性、如果使用get方式發(fā)送到服務器數(shù)據會拼接到url的后面，這樣的話會完全暴露出發(fā)送到服務器的數(shù)據，因此不安全，而post會把發(fā)送到服務器的數(shù)據放到請求體中，相對來說比較安全 2、get方式發(fā)送到服務器的數(shù)據有限制，而post的方式發(fā)送到服務器原則上是沒有限制 介紹tcp和upd的區(qū)別 Tcp：傳輸控制協(xié)議 Udp---user data protocol：用戶數(shù)據報協(xié)議 共同點：都是用來在2臺設備直接傳遞數(shù)據的協(xié)議 不同點： Tcp協(xié)議會在傳遞數(shù)據之前要3次握手，之后建立連接。這樣的話就可以傳遞數(shù)據。是一種可靠的傳輸協(xié)議，就是說可以保證百分百把數(shù)據傳遞到對方設備，傳輸效率低 Udp：不可靠傳輸，不能保證把數(shù)據百分百把數(shù)據傳輸?shù)綄Ψ皆O備上，傳輸效率高 表：銷售表，客戶表。兩個表的關系，一個賣一個買共同的產物表：ID name 單子表 一對一 本人最近參加了大大小小很多公司的面試，在這里我把自己面試遇到的問題給大家說一下 JAVA基礎篇 1、在java類加載器中，系統(tǒng)類加載器和用戶自定義加載器那個先加載？（遇到這個問題時感覺很意外，沒有想到會問這樣的問題） 先加載系統(tǒng)類加載器 Java類加載器加載類順序依次為： JVM類加載器：這個模式會加載JAVA_HOME/lib下的jar包 擴展類加載器：會加載JAVA_HOME/lib/ext下的jar包 系統(tǒng)類加載器：這個會去加載指定了classpath參數(shù)指定的jar文件 用戶自定義類加載器：sun提供的ClassLoader是可以被繼承的，允許用戶自己實現(xiàn)類加載器 2、堆和棧分別存放什么？ 棧：基本數(shù)據類型和對象的引用 堆：對象和數(shù)組 3、String、StringBuffer、StringBuilder的區(qū)別 （1）String是不可變對象，也就是說每次修改String都是新建了一個對象并賦值（2）StringBuffer是字符緩沖區(qū)，修改它不會新建對象，可以使用append()方法和delete()方法修改StringBuffer的值 （3）StringBuilder可以替代StringBuffer，它是一個單線程使用的類，和StringBuffer比速度快、效率高，但是是非安全的 （4）三者都是被final修飾的（這一點面試官的問我的時候一直在說，你確定嗎？搞得我有點虛） 4、Java的異常和錯誤有什么區(qū)別？ （1）Error Error是JVM的錯誤，這種錯誤會嚴重影響程序的運行，設計者不會設計程序代碼去捕捉這種錯誤，因為即使捕捉到也無法給予適當?shù)奶幚?，比如內存溢出。?）Exception Exception包含了一般性的異常，這些異常同在在捕捉到之后便可做妥善的處理，以確保程序繼續(xù)運行。Exception有很多種分類，從Exception產生的時機上我們可以把Exception分為 ①運行時異常 運行時異常是指程序運行過程中可能出現(xiàn)的非正常狀態(tài) ②非運行時異常 非運行時異常是指方法聲明時throws的異常 5、&和&&的區(qū)別 &是位運算符，表示按位與運算。&&是邏輯運算符，表示邏輯與。在條件判斷的時候&必須逐一檢查各個條件，&&具有短路功能，只要一個條件為false則不會進行后續(xù)的判斷。 6、abstract class和interface的區(qū)別 （1）abstract class是抽象類，聲明方法的存在而不去實現(xiàn)它的類叫做抽象類，它用于創(chuàng)建一個體現(xiàn)某些基本行為的類。抽象類中不能有構造方法、不能有靜態(tài)方法，抽象類不能被實例化。抽象類中可以有變量、可以有普通方法、可以有抽象方法，在繼承抽象方法后，必須實現(xiàn)它的所有抽象方法。 （2）interface是接口，接口中的變量必須是靜態(tài)常量（static final），接口中的方法必須都是抽象方法（abstract），不過由于接口中所有變量、方法修飾符都一致，因可以不寫。接口的實現(xiàn)必須實現(xiàn)接口中所有的方法。 7、final、finally、finalize的區(qū)別 （1）final是用來描述變量、方法、類的關鍵字，表示變量值不可變、方法不可被重寫、類不可被繼承 （2）finally是異常處理的關鍵字，表示finally塊里面的代碼一定會被運行到（3）finalize是Object類中的protected方法，垃圾回收器執(zhí)行的時候會調用被回收的類的此方法。 8、接口是否可以繼承接口？抽象類是否可以實現(xiàn)接口？抽象類是否可以實現(xiàn)實體類？ （1）接口可以繼承接口 （2）抽象類里可以有普通方法，因此抽象類可以實現(xiàn)接口，只需要實現(xiàn)接口內所有方法就可以了 （3）抽象類里可以有普通方法，變量也不需要是常量，因此抽象類可以實現(xiàn)實體類 9、一個”.java”源文件中是否可以包含多個類（非內部類）？有什么限制？ 可以。必須只有一個類名與文件名相同且該類以public修飾 10、java是怎么通過包名.類名來獲得該類的實例的？ 通過Class.forName()方法 11、介紹一下集合？ ①Collection：是最基本的集合接口，一個collection代表一組Object，即collection的元素。 ②List：是collection的擴展，作用是收集對象，并以索引方式保留收集對象的順序。其元素有放入順序，元素可重復。 1）ArrayList：利用類似于數(shù)組的形式來存儲數(shù)據，它的隨機訪問速度極快。 2）LinkedList：內部實現(xiàn)是鏈表，它適合于在鏈表中間需要頻繁的插入和刪除操作。 3）Vector：與ArrayList相似，但是兩者不同，Vector主要用在事先不知道數(shù)組的大小，或者只是需要一個可以改變大小的數(shù)組的情況。 4）ArrayList與Vector的區(qū)別： ArrayList是非線程安全的，效率高 Vector是基于線程安全的，效率低。 ③Set：也是collection的擴展，在Set中的元素對象要求不能重復（注意：元素雖然無放入順序，但是元素在set中的位置是有該元素的HashCode決定的，其位置其實是固定的）。常用實現(xiàn)類有HashSet和TreeSet。 1）HashSet：其核心是HashMap，HashSet中存放的值為HashMap中的key，這也就是HashSet不允許重復的原因。 2）TreeSet：底層由平衡二叉樹實現(xiàn)，它會將投入其中的元素自動排序，這就要求投入其中的元素是可排序的，也就是說，存放的必須是同一種數(shù)據類型。其實現(xiàn)自動排序的實質是compareable public int compareTo(Object obj){ if(equals(obj)){ return 0;}else{ Return 1;} } 這個方法稱為比較器，可以比較兩個對象，如果對象都一致相等，則返回0 ④Map：沒有繼承collection接口，提供key到value的映射，也就是說，它是一種把鍵對象和值對象進行關聯(lián)的容器。 1）HashMap：key不允許重復，如果后面的key重復，則會覆蓋前面的值，key允許為null，但是只能有一個。 2）TreeMap：key如果是一個對象的話，這個對象所在的類一定要實現(xiàn)compareable接口，并且重寫compareTo方法。3）HashMap與HashTable比較： HashMap：非線程安全，高效率，支持null HashTable：線程安全，低效率，不支持null 12、list、set和map的遍歷方法比較： List：可以用for循環(huán)、for each循環(huán)和Iterator迭代。 Set：可以用for each循環(huán)和Iterator迭代。 Map：HashMap只能用Iterator迭代。 13、寫一個單例設計模式： Public class Apple{ Private static Apple apple;Private Apple(){ } Public static Apple getApple(){ If(null == apple){ apple = new Apple();return apple;}else{ return apple;} } } 14、說說static關鍵字： Static表示“全局”或“靜態(tài)”的意思，可以用來修飾成員變量和成員方法，也可以形成靜態(tài)代碼塊，還可以用來修飾類，但只能修飾內部類。 ①static變量：被static修飾的變量叫靜態(tài)變量或者類變量；沒有被static修飾的變量叫實例變量。二者的區(qū)別是： 靜態(tài)變量：在內存中只有一個拷貝（節(jié)省內存），jvm只會為靜態(tài)分配一次內存，而且在加載類的過程中就完成靜態(tài)變量的內存分配。可用類名直接訪問（方便），也可以用對象來訪問（不推薦）。靜態(tài)變量一般用于對象之間需要共享值時。 實例變量：每創(chuàng)建一個實例，就會為實例分配一次內存，實例變量在內存中可以有多個拷貝，互不影響（靈活）。 ②靜態(tài)方法：它可以直接通過“類名.靜態(tài)方法”來訪問，任何的實例亦可以調用。靜態(tài)方法中不能用this和super關鍵字。不能直接訪問所屬類的實例變量和實例方法，只能訪問所屬類的靜態(tài)變量和成員方法。 ③static代碼塊：static代碼塊也叫靜態(tài)代碼塊，是在類中獨立于類成員的static語句塊，可以有多個，位置也可以隨便放，它不在任何的方法體內，jvm在加載類時會執(zhí)行這些靜態(tài)代碼塊，如果有多個，則會按照他們在類中出現(xiàn)的先后順序一次執(zhí)行它們，而且每個代碼塊只會執(zhí)行一次。 15、Servlet的生命周期： ①加載和實例化：在Servlet容器檢測到需要這個Servlet來響應第一個請求時，創(chuàng)建Servlet實例。 ②初始化：在Servlet實例化后，容器將調用Servlet的init（）方法初始化這個對象。 ③請求處理：Servlet容器將調用Servlet的service（）方法對請求進行處理。 ④服務終止：當容器檢測到一個Servlet的實例應該從服務中被移除的時候，容器就會調用實例的destroy（）方法 16、jsp九大內置對象范圍比較： 排序為：Application > Session > Request > Page = Response = out = PageContext = config = exception。 Application：服務器啟動到停止這段時間。 Session：Http會話開始到結束這段時間（瀏覽器打開到關閉） Request：Http請求開始到結束這段時間，即一個jsp頁面發(fā)出請求到另一個jsp頁面之間。 Page：頁面執(zhí)行，當前頁面從打開到關閉這段時間，它只能在同一個頁面中有效 Response：頁面執(zhí)行，包含了客戶請求的有關信息，但jsp中很少用到它。 Out：頁面執(zhí)行，向客戶端輸入內容時常用的對象 PageContext：頁面執(zhí)行，取得任何范圍的參數(shù)，通過它可以獲得out、Requset、Response、Session、application等對象。 Config：頁面執(zhí)行,取得服務器的配置信息。 Exception：僅在錯誤處理頁面 17、jsp和servlet的區(qū)別與聯(lián)系： ①JSP第一次運行的時候會編譯成Servlet，駐留在內存中以供調用 ②JSP是web開發(fā)技術，Servlet是服務器端運用的小程序 ③JSP更多的是進行頁面顯示，Servlet更多的是處理業(yè)務，即JSP是頁面，Servlet是實現(xiàn)JSP方法 ④開發(fā)界面是JSP時，可以直接編寫：第二篇：Java面試題個人總結 + 答案
[數(shù)據]
;而Servlet中則需要這樣寫：
out.println(“
18、final關鍵字的作用
（1）final修飾的基本數(shù)據類型的值不可被改變，final修飾的引用類型的引用不可變而引用的值還是可以變的
（2）final修飾的方法不可被重寫（3）final修飾的類不可被繼承
（4）final修飾的基本數(shù)據類型的形參在方法體內不可以被重新賦值，final修飾的引用類型的形參不可以被賦予一個新的引用
數(shù)據庫方面
1、問你怎么同時更新一個表中的兩個字段？（假設表名為A，要更新的字段分別為name、age）
update A set name = ‘ 姚明’ , age = 35 where id = 10;
2、給student添加一個來自classes的外鍵：（這個很容易被我們自己忽視）
alter table student add constraint fk_stu_cls foreign key(cid)references classes(cid);
3、數(shù)據庫三范式：屬性唯
一、記錄唯
一、表唯一
4、查詢結果按tid排序（降序）：select * from test order by tid desc;（默認是按升序的）
5、oracle的左外連接
Select * from dept d left outer join emp e on d.deptno = e.deptno
order by d.deptno,e.ename;
SSH框架
1、hibernate和JDBC相比有什么優(yōu)勢？
1.對JDBC訪問數(shù)據庫的代碼做了封裝，大大簡化了數(shù)據訪問層繁瑣的重復性代碼。2.Hibernate是一個基于JDBC的主流持久化框架，是一個優(yōu)秀的ORM實現(xiàn)。他很大程度的簡化DAO層的編碼工作
3.hibernate使用Java反射機制，而不是字節(jié)碼增強程序來實現(xiàn)透明性。
4.hibernate的性能非常好，因為它是個輕量級框架。映射的靈活性很出色。它支持各種關系數(shù)據庫，從一對一到多對多的各種復雜關系。
2、為什么要用struts？
JSP、Servlet、JavaBean技術的出現(xiàn)給我們構建強大的企業(yè)應用系統(tǒng)提供了可能。但用這些技術構建的系統(tǒng)非常的繁亂，所以在此之上，我們需要一個規(guī)則、一個把這些技術組織起來的規(guī)則，這就是框架，Struts便應運而生。
3、為什么要用spring？
AOP 讓開發(fā)人員可以創(chuàng)建非行為性的關注點，稱為橫切關注點，并將它們插入到應用程序代碼中。使用 AOP 后，公共服務（比如日志、持久性、事務等）就可以分解成方面并應用到域對象上，同時不會增加域對象的對象模型的復雜性。
IOC 允許創(chuàng)建一個可以構造對象的應用環(huán)境，然后向這些對象傳遞它們的協(xié)作對象。正如單詞倒置所表明的，IOC 就像反過來的 JNDI。沒有使用一堆抽象工廠、服務定位器、單元素（singleton）和直接構造（straight construction），每一個對象都是用其協(xié)作對象構造的。因此是由容器管理協(xié)作對象（collaborator）。
Spring即使一個AOP框架，也是一IOC容器。Spring 最好的地方是它有助于您替換對象。有了 Spring，只要用 JavaBean 屬性和配置文件加入依賴性（協(xié)作對象）。然后可以很容易地在需要時替換具有類似接口的協(xié)作對象。
4、什么是MVC模式？有什么作用？
MVC全名Model View Controller，即模型-視圖-控制器，是一種非常經典的軟件架構模 式。從設計角度看，它將多個設計模式在一種解決方案中結合起來，用來解決許多設計問題。MVC模式把用戶界面交互分拆到不同的三個角色中，即：
（1）模型：持有所有的數(shù)據、狀態(tài)和程序邏輯，獨立于視圖和控制器。
（2）視圖：用來呈現(xiàn)模型。視圖通常直接從模型中取得它要顯示的狀態(tài)和數(shù)據。對于相同 的信息可以有多個不同的顯示形式或視圖。（3）控制器：位于視圖和模型中間，負責接收用戶的輸入，將輸入進行解析并反饋給模型，通常有一個模型具有一個控制器。
5、hibernate的三種狀態(tài)：
瞬時狀態(tài)
持久狀態(tài)
游離狀態(tài)
6、C/S和B/S的區(qū)別：
優(yōu)點：
C/S：占用網速小，對于一些網速比較慢的電腦有明顯的優(yōu)勢。
B/S：不需要安裝客戶端，只需要瀏覽器就能打開。缺點：
C/S：需要安裝客戶端，有時候需要更新。
B/S：對網速的需求大，對于一些網速慢的電腦不適合。
7、struts2 的核心是什么？它與struts1有什么關系？
struts2的核心是WebWork，與struts1沒關系
8、列舉五個struts2中的攔截器： ①alias：實現(xiàn)在不同請求中相似參數(shù)別名的轉換。②autowiring：自動裝配的攔截器，主要用于當struts2和spring整合時，struts2可以使用自動裝配的方式來訪問spring容器中的bean。
③createSession：該攔截器負責創(chuàng)建一個httpSession對象，主要用于那些需要有httpSession對象才能正常工作的攔截器。
④debugging：當使用struts2的開發(fā)模式時，這個攔截器會提供更多的調試信息。
⑤exception：這個攔截器負責處理異常，它將異常映射為結果。
⑥fileUpload：這個攔截器主要用于文件上傳，它負責解析表單文件域中的內容。
⑦i18n：支持國際化的攔截器，它負責把所選的語言、區(qū)域放入用戶session中。
⑧params：這是一個最基本的攔截器，它負責解析HTTP請求中的參數(shù)，并將參數(shù)值設置成對應的Action屬性值。⑨t(yī)oken：防止重復提交，它檢查傳到Action中的token，從而防止多次提交。⑩validation：通過執(zhí)行XXXAction-validation.xml中定義的校驗器，從而完成數(shù)據校驗。
9、Spring注入方法：
①設值注入：通過setter訪問容器實現(xiàn)
②構造注入：通過構造函數(shù)實現(xiàn)
③P命名空間注入
10、spring實現(xiàn)注解的配置：
第三篇：java程序員部分面試題答案
一、你對MVC的理解，MVC有什么優(yōu)缺點？結合Struts，說明在一個Web應用如何去使用？ 答：
MVC設計模式（應用觀察者模式的框架模式）M: Model(Business process layer)，模型，操作數(shù)據的業(yè)務處理層,并獨立于表現(xiàn)層(Independent of presentation)。
V: View(Presentation layer)，視圖，通過客戶端數(shù)據類型顯示數(shù)據,并回顯模型層的執(zhí)行結果。C: Controller(Control layer)，控制器，也就是視圖層和模型層橋梁，控制數(shù)據的流向，接受視圖層發(fā)出的事件，并重繪視圖
MVC框架的一種實現(xiàn)模型 模型二(Servlet-centric)：
JSP+Servlet+JavaBean，以控制為核心，JSP只負責顯示和收集數(shù)據，Sevlet，連接視圖和模型，將視圖層數(shù)據，發(fā)送給模型層，JavaBean，分為業(yè)務類和數(shù)據實體，業(yè)務類處理業(yè)務數(shù)據，數(shù)據實體，承載數(shù)據，基本上大多數(shù)的項目都是使用這種MVC的實現(xiàn)模式。
StrutsMVC框架(Web application frameworks)
Struts是使用MVC的實現(xiàn)模式二來實現(xiàn)的，也就是以控制器為核心。
Struts提供了一些組件使用MVC開發(fā)應用程序：
Model：Struts沒有提供model類。這個商業(yè)邏輯必須由Web應用程序的開發(fā)者以JavaBean或EJB的形式提供
View：Struts提供了action form創(chuàng)建form bean, 用于在controller和view間傳輸數(shù)據。此外，Struts提供了自定義JSP標簽庫，輔助開發(fā)者用JSP創(chuàng)建交互式的以表單為基礎的應用程序，應用程序資源文件保留了一些文本常量和錯誤消息，可轉變?yōu)槠渌Z言，可用于JSP中。
Controller：Struts提供了一個核心的控制器ActionServlet，通過這個核心的控制器來調用其他用戶注冊了的自定義的控制器Action，自定義Action需要符合Struts的自定義Action規(guī)范，還需要在struts-config.xml的特定配置文件中進行配置，接收JSP輸入字段形成Action form，然后調用一個Action控制器。Action控制器中提供了model的邏輯接口。
二、什么是WebService？
答：
WebService是一個SOA（面向服務的編程）的架構，它是不依賴于語言，不依賴于平臺，可以實現(xiàn)不同的語言間的相互調用，通過Internet進行基于Http協(xié)議的網絡應用間的交互。
WebService實現(xiàn)不同語言間的調用，是依托于一個標準，webservice是需要遵守WSDL（web服務定義語言）/SOAP（簡單請求協(xié)議）規(guī)范的。WebService=WSDL+SOAP+UDDI（webservice的注冊）
Soap是由Soap的part和0個或多個附件組成，一般只有part，在part中有Envelope和Body。
Web Service是通過提供標準的協(xié)議和接口，可以讓不同的程序集成的一種SOA架構。
Web Service的優(yōu)點
(1)可以讓異構的程序相互訪問（跨平臺）
(2)松耦合
(3)基于標準協(xié)議（通用語言，允許其他程序訪問）Web Service的基本原理
(1)Service Provider采用WSDL描述服務
(2)Service Provider 采用UDDI將服務的描述文件發(fā)布到UDDI服務器（Register server）
(3)Service Requestor在UDDI服務器上查詢并 獲取WSDL文件
(4)Service requestor將請求綁定到SOAP，并訪問相應的服務。
三、什么是中間件？
中間件就是程序中可織入的，可重用的，與業(yè)務邏輯無關的各種組件。
中間件（middleware）是基礎軟件的一大類，屬于可復用軟件的范疇。顧名思義，中間件處于操作系統(tǒng)軟件與用戶的應用軟件的中間。中間件在操作系統(tǒng)、網絡和數(shù)據庫之上，應用軟件的下層，總的作用是為處于自己上層的應用軟件提供運行與開發(fā)的環(huán)境，幫助用戶靈活、高效地開發(fā)和集成復雜的應用軟件。
在眾多關于中間件的定義中，比較普遍被接受的是IDC表述的：中間件是一種獨立的系統(tǒng)軟件或服務程序，分布式應用軟件借助這種軟件在不同的技術之間共享資源，中間件位于客戶機服務器的操作系統(tǒng)之上，管理計算資源和網絡通信。
分類：數(shù)據訪問中間件，遠程調用中間件，消息中間件，交易中間件，對象中間件。舉例：
1，RMI（Remote Method Invocations, 遠程調用）
2，Load Balancing(負載均衡，將訪問負荷分散到各個服務器中)3，Transparent Fail-over(透明的故障切換)4，Clustering(集群,用多個小的服務器代替大型機）
5，Back-end-Integration(后端集成，用現(xiàn)有的、新開發(fā)的系統(tǒng)如何去集成遺留的系統(tǒng))6，Transaction事務（全局/局部）全局事務（分布式事務）局部事務（在同一數(shù)據庫聯(lián)接內的事務）
7，Dynamic Redeployment(動態(tài)重新部署,在不停止原系統(tǒng)的情況下，部署新的系統(tǒng)）8，System Management(系統(tǒng)管理)9，Threading(多線程處理)10，Message-oriented Middleware面向消息的中間件（異步的調用編程）11，Component Life Cycle(組件的生命周期管理)12，Resource pooling（資源池）13，Security（安全）14，Caching（緩存）
四、什么是典型的軟件三層結構？軟件設計為什么要分層？軟件分層有什么好處？ 答：(1)Presentation layer（表示層）
(1)表示邏輯（生成界面代碼）
(2)接收請求
(3)處理業(yè)務層拋出的異常
(4)負責規(guī)則驗證（數(shù)據格式，數(shù)據非空等）
(5)流程控制
(2)Service layer（服務層/業(yè)務層）
(1)封裝業(yè)務邏輯處理，并且對外暴露接口
(2)負責事務，安全等服務(3)Persistence layer（持久層）
(1)封裝數(shù)據訪問的邏輯，暴露接口
(2)提供方便的數(shù)據訪問的方案（查詢語言，API，映射機制等）Domain layer（域層）
(1)業(yè)務對象以及業(yè)務關系的表示
(2)處理簡單的業(yè)務邏輯
(3)域層的對象可以穿越表示層，業(yè)務層，持久層
軟件分層結構使得代碼維護非常方便，設計明確，各層獨立，專注自己擅長的領域。
五、什么是OOP？OOP相對于面向過程編程有哪些優(yōu)點？
OOP，Object-Oriented Programming，面向對象編程不同于面向過程編程：
（1）OOP關注對象和角色，也就是事物的本質
1）OOP把客觀世界中的對象抽象成對應的類；
2）通過類構造實例；
3）通過依賴、繼承、實現(xiàn)等形式建立對象間的通信關系
（2）OOP易于擴展，增加或改變業(yè)務的功能，無需大幅改動改變源代碼
（3）OOP易于建模，OOP就是軟件架構師在計算機高級語言中對客觀世界的抽象和再現(xiàn)，人們可以很好地理解和建立起計算機中的抽象模型
六、談談Overload和Override的區(qū)別。
答：
方法的重寫Overriding和重載Overloading是Java多態(tài)性的不同表現(xiàn)。重寫Overriding是父類與子類之間多態(tài)性的一種表現(xiàn)，重載Overloading是一個類中多態(tài)性的一種表現(xiàn)。如果在子類中定義某方法與其父類有相同的名稱和參數(shù)，我們說該方法被重寫(Overriding)。子類的對象使用這個方法時，將調用子類中的定義，對它而言，父類中的定義如同被“屏蔽”了。如果在一個類中定義了多個同名的方法，它們或有不同的參數(shù)個數(shù)或有不同的參數(shù)類型，則稱為方法的重載(Overloading)。Overloaded的方法是可以改變返回值的類型。
七、談談HashMap和Hashtable的區(qū)別。
答：
HashMap是輕量級的（線程不安全的，效率高的）集合，Hashtable是重量級的（線程安全的，效率低的）集合。
都屬于Map接口的類，實現(xiàn)了將惟一鍵映射到特定的值上。
HashMap 類沒有分類或者排序。它允許一個 null 鍵和多個 null 值。
Hashtable 類似于 HashMap，但是不允許 null 鍵和 null 值。它也比 HashMap 慢，因為它是同步的。
八、請問abstract class和interface有什么區(qū)別？ 答：
1)接口沒有任何的實現(xiàn),而抽象類它可以有部分的實現(xiàn)也可以沒有;
2)如果需要復用或者共享部分代碼,應該用抽象類而不是接口;
3)繼承無法解決類型的轉換問題,接口就是為了解決這一問題而產生的(Java的單繼
承是接口產生的根本原因)接口是一種抽象的 DML
[Data Manipulation Language, 數(shù)據操作語言] WYSIWYG
所見即所得 [What You See is What You Get] CMP CMT B2B C2C B2C IDE DOM Client/Server CMM ORM MIS MVC
MVC是Model－View－Controller的簡寫?！癕odel” 代表的是應用的業(yè)務邏輯（通過JavaBean，EJB組件實現(xiàn)），“View” 是應用的表示面（由JSP頁面產生），“Controller” 是提供應用的處理過程控制（一般是一個Servlet），通過這種設計模型把應用邏輯，處理過程 和顯示邏輯分成不同的組件實現(xiàn)。這些組件可以進行交互和重用。OLE CORBA
CORBA 標準是公共對象請求代理結構(Common Object Request Broker Architecture)，由對象管理組織(Object Management Group，縮寫為 OMG)標準化。它的組成是接口定義語言(IDL), 語言綁定(binding:也譯為聯(lián)編)和允許應用程序間互操作的協(xié)議。其目的為： 用不同的程序設計語言書寫
在不同的進程中運行
為不同的操作系統(tǒng)開發(fā)。UML
UML，標準建模語言，包含用例圖,靜態(tài)圖(包括類圖、對象圖和包圖),行為圖,交互圖(順序圖,合作圖),實現(xiàn)圖等。XML CMMI JRE J2EE J2EE是Sun公司提出的多層(multi-diered),分布式(distributed),基于組件(component-base)的企業(yè)級應用
模型(enterpriese application model).在這樣的一個應用系統(tǒng)中，可按照功能劃分為不同的組件，這些組件又可在不同計算機上，并且處于相應的層次(tier)中。所屬層次包括客戶層(clietn tier)組件,web層和組件,Business層和組件,企業(yè)信息系統(tǒng)(EIS)層。JDK AOP OO Container W3C JMS Domain POJO JVM JNDI JTA SOAP
[Simple Object Access Protocol，簡單對象訪問協(xié)議] WSDL JDO
JDO是Java對象持久化的新的規(guī)范，為Java Data Object的簡稱,也是一個用于存取某種數(shù)據倉庫中的對
象的標準化API。JDO提供了透明的對象存儲，因此對開發(fā)人員來說，存儲數(shù)據對象完全不需要額外的代碼（如JDBC API的使用）。這些繁瑣的例行工作已經轉移到JDO產品提供商身上，使開發(fā)人員解脫出來，從而集中時間和精力在業(yè)務邏輯上。另外，JDO很靈活，因為它可以在任何數(shù)據底層上運行。JDBC只是面向關系數(shù)據庫（RDBMS)JDO更通用，提供到任何數(shù)據底層的存儲功能，比如關系數(shù)據庫、文件、XML以及對象數(shù)據庫（ODBMS）等等，使得應用可移植性更強。TDD DAO IoC
[Inversion of Control, 控制反轉] RMI DNS
[Internet Domain Name System, 因特網域名系統(tǒng)] URL URI
二十四、數(shù)據庫連接池的工作機制 二
十五、互聯(lián)網提供哪些服務？
二
十六、請寫出JSP的幾個隱含內置對象 答：JSP中隱含內置對象
名稱
類型
注釋和范圍
request
javax.servlet.http.HttpServletRequest
request
response
javax.servlet.http.HttpServletResponse
response
page
javax.lang.Object
page
Exception
java.lang.Throwable
page
pageContext javax.servlet.jsp.PageContext
page
session
javax.servlet.http.HttpSession
session
application javax.servlet.ServletContext
ServletContext
out
javax.servlet.jsp.JspWriter
OutputStream
config
javax.servlet.ServletConfig
ServletConfig
JSP共有以下9種基本內置組件（可與ASP的6種內部組件相對應）：
request
用戶端請求，此請求會包含來自GET/POST請求的參數(shù)
response
網頁傳回用戶端的回應
page JSP
網頁本身
exception
針對錯誤網頁，未捕捉的例外 pageContext
網頁的屬性是在這里管理
session
與請求有關的會話期
application servlet 正在執(zhí)行的內容
out
用來傳送回應的輸出
config
Servlet的構架部件
二十七、請你談談SSH整合 答：SSH：
Struts（表示層）+Spring（業(yè)務層）+Hibernate（持久層）
Struts：
Struts是一個表示層框架，主要作用是界面展示，接收請求，分發(fā)請求。
在MVC框架中，Struts屬于VC層次，負責界面表現(xiàn)，負責MVC關系的分發(fā)。（View：沿用JSP，HTTP，F(xiàn)orm，Tag，Resourse ；Controller：ActionServlet，struts-config.xml，Action）
Hibernate：
Hibernate是一個持久層框架，它只負責與關系數(shù)據庫的操作。
Spring：
Spring是一個業(yè)務層框架，是一個整合的框架，能夠很好地黏合表示層與持久層。
二十八、應用服務器與Web Server的區(qū)別
二十九、Java Servlet API中forward()與redirect()的區(qū)別 答：
前者僅是容器中控制權的轉向，在客戶端瀏覽器地址欄中不會顯示出轉向后的地址；后者則是完全的跳轉，瀏覽器將會得到跳轉的地址，并重新發(fā)送請求鏈接。這樣，從瀏覽器的地址欄中可以看到跳轉后的鏈接地址。所以，前者更加高效，在前者可以滿足需要時，盡量使用forward()方法，并且，這樣也有助于隱藏實際的鏈接。在有些情況下，比如，需要跳轉到一個其它服務器上的資源，則必須使用sendRedirect()方法。
三
十、寫一個簡單的C/S結構程序，Java 的通信編程，編程題(或問答)，用JAVA SOCKET編程，讀服務器幾個字符，再寫入本地顯示？
答:Server端程序: package test;import java.net.*;import java.io.*;public class Server { private ServerSocket ss;private Socket socket;private BufferedReader in;private PrintWriter out;public Server(){ try { ss=new ServerSocket(10000);while(true){ socket = ss.accept();String RemoteIP = socket.getInetAddress().getHostAddress();String RemotePort = “:”+socket.getLocalPort();System.out.println(“A client come
in!IP:”+RemoteIP+RemotePort);in = new BufferedReader(new InputStreamReader(socket.getInputStream()));String line = in.readLine();System.out.println(“Cleint send is :” + line);out = new PrintWriter(socket.getOutputStream(),true);out.println(“Your Message Received!”);out.close();in.close();socket.close();} }catch(IOException e){ out.println(“wrong”);} } public static void main(String[] args){ new Server();} };
Client端程序: package test;import java.io.*;import java.net.*;public class Client { Socket socket;BufferedReader in;PrintWriter out;public Client(){ try { System.out.println(“Try to Connect to 127.0.0.1:10000”);socket = new Socket(“127.0.0.1”,10000);System.out.println(“The Server Connected!”);System.out.println(“Please enter some Character:”);BufferedReader line = new BufferedReader(new InputStreamReader(System.in));out = new PrintWriter(socket.getOutputStream(),true);out.println(line.readLine());in = new BufferedReader(new InputStreamReader(socket.getInputStream()));System.out.println(in.readLine());out.close();in.close();socket.close();}catch(IOException e){ out.println(“Wrong”);} } public static void main(String[] args){ new Client();} };
第四篇：Java面試題(答案版)
作者:楊金輝
1、一個“.java”源文件中是否可以包括多個類（不是內部類）？有什么限制？
可以，但是只能有一個類用public修飾，并且用public修飾的類名與文件名要一致
2、&和&&的區(qū)別。
&和&&都可以用作邏輯與;&&還具有短路功能，即如果第一個表達式的結果為false，則不再計算第二個表達式;&還可以用作位運算符，當&操作符兩邊的表達式不是boolean類型時，&表示按位與操作。
3、Java有沒有goto? java中的保留字，現(xiàn)在沒有在java中使用。
4、在JAVA中，如何跳出當前的多重嵌套循環(huán)？
break+變量控制 與 return
5、switch是否能作用在byte(拜特)上，是否能作用在long上，是否能作用在String上?
Switch可以作用在int上，而byte可以隱式轉換為int 所以能作用在byte上
不能作用在long上，也不能作用在String上
6、short s1 = 1;s1 = s1 + 1;有什么錯? short s1 = 1;s1 += 1;有什么錯?
1在java中為int數(shù)據類型，short+int=int，大類型轉為小類型，編譯時，會報告需要強制轉換類型的錯誤。s1+=1不會報，因為JVM會對它特殊處理(自動強轉)
7、char型變量中能不能存貯一個中文漢字?為什么? 可以，char型變量是用來存儲unicode(依妮Q特)編碼的，而unicode編碼包含了中文，所以是可以保存的
8、編程題: 用最有效率的方法算出2乘以8等於幾?
2<<3，表示將2左移3位；一個數(shù)左移幾位就表示這個數(shù)乘以了2的幾次方，左移運算，CPU直接支持，所以是最有效率的
9、請設計一個一百億的計算器
思路:用兩個數(shù)組分別保存兩個操作數(shù)，再新建一個數(shù)組保存結果。
10、使用final關鍵字修飾一個變量時，是引用不能變，還是引用的對象不能變？
引用變量不能變
11、“==”和equals方法究竟有什么區(qū)別？
==和equals方法都可以用來比較兩個對象是否是同一個對象。
==還可以比較兩個變量的值是否相等。
equals是Object類中的方法，可以由子類重寫此方法，實現(xiàn)內容相等。
12、靜態(tài)變量和實例變量的區(qū)別？
語法上不同: 靜態(tài)變量前要加static關鍵字，實例變量不需要
程序運行時不同: 實例變量是屬于某個對象的，只有創(chuàng)建了對象，才會為這個對象的實例變量分配空間。靜態(tài)變量是屬于類的，當程序加載了這個類的字節(jié)碼文件，就會為靜態(tài)變量分配空間，并且所有對象共享這個變量
13、是否可以從一個static方法內部發(fā)出對非static方法的調用？
不可以，非static方法需要與對象關聯(lián)在一起的，而static方法調用時不需要對象，可以直接調用，也就是說調用static方法時，可能還沒有創(chuàng)建任何實例
14、Integer與int的區(qū)別
int是java中的8種基本數(shù)據類型之一，默認值是0，Integer是int的包裝類，默認值是null，即Integer可以表示未賦值和賦值為0
15、(麥死)Math.round（亂的）(11.5)等於多少? Math.round(-11.5)等於多少?
作者:楊金輝
12,-11,Math.round()方法的實現(xiàn)是: Math.floor(n+0.5);
16、作用域public，private，protected，以及不寫時的區(qū)別
本類 同包 子類 其他類
public ?
?
?
? protected ?
?
?
? friendly ?
?
?
? private ?
?
?
?
17、Overload(喔我樓的)和Override的區(qū)別。Overloaded的方法是否可以改變返回值的類型?
Overload是重載，Override是重寫。
Overload是指在一個類中，方法名相同，參數(shù)列表不同，那么這些方法之間構成重載。
Override是指在父子類之間，子類的方法簽名和父類的方法簽名完全一樣，那么這兩個方法構成重寫。
Overload的方法可以改變返回值。因為調用方法時，返回值可以接受也可以不接受，所以編譯器無法根據返回值來判斷是否重載。
18、構造器Constructor(看似爪克特)是否可被override?
Constructor不能被繼承，所以不能override
19、接口是否可繼承接口? 抽象類是否可實現(xiàn)(implements)接口? 抽象類是否可繼承具體類(concrete class)? 抽象類中是否可以有靜態(tài)的main方法？
接口可以繼承接口，抽象類可以實現(xiàn)接口，抽象類可以繼承具體類，抽象類中可以有靜態(tài)的main方法
20、寫clone()方法時，通常都有一行代碼，是什么？
super.clone();克隆時，首先得將父類的成員克隆完。
21、面向對象的特征有哪些方面
封裝
封裝是把過程和數(shù)據包圍起來，對數(shù)據的訪問只能通過已定義的界面。面向對象計算始于這個基本概念，即現(xiàn)實世界可以被描繪成一系列完全自治、封裝的對象，這些對象通過一個受保護的接口訪問其他對象。
繼承
繼承是一種聯(lián)結類的層次模型，并且允許和鼓勵類的重用，它提供了一種明確表述共性的方法。對象的一個新類可以從現(xiàn)有的類中派生，這個過程稱為類繼承。新類 繼承了原始類的特性，新類稱為原始類的派生類（子類），而原始類稱為新類的基類（父類）。派生類可以從它的基類那里繼承方法和實例變量，并且類可以修改或 增加新的方法使之更適合特殊的需要。
抽象
抽象就是忽略一個主題中與當前目標無關的那些方面，以便更充分地注意與當前目標有關的方面。抽象并不打算了解全部問題，而只是選擇其中的一部分，暫時不用部分細節(jié)。抽象包括兩個方面，一是過程抽象，二是數(shù)據抽象。
多態(tài)
多態(tài)性是指允許不同類的對象對同一消息作出響應。多態(tài)性包括參數(shù)化多態(tài)性和包含多態(tài)性。多態(tài)性語言具有靈活、抽象、行為共享、代碼共享的優(yōu)勢，很好的解決了應用程序函數(shù)同名問題。
作者:楊金輝
22、java中實現(xiàn)多態(tài)的機制是什么？
靠的是父類或接口能夠指向子類或實現(xiàn)類。程序運行時，JVM會根據內存中實際的對象調用方法。
23、abstract（抽象）class和interface有什么區(qū)別?
1、abstract class 本質是類,用abstract修飾類,而interface是接口，將class替換為interface
2、abstract class可以有構造方法，interface不能有
3、abstract class中可以包含普通變量，interface所有的變量都是final static的4、abstract class中可以包含普通方法，interface中所有的方法都是抽象的。
5、abstract class中除抽象方法不可以是private修飾符外，其它成員任意；而interface中所有成員的修飾符都為public
6、abstract class可以繼承一個類實現(xiàn)多個接口，interface只能繼承接口
24、abstract的method是否可同時是static,是否可同時是native，是否可同時是synchronized?
abstract的方法不可以是static，abstract方法必須由子類去實現(xiàn)，而static方法可以由當前類調用。
abstract的方法不可以是native，abstract方法必須由子類去實現(xiàn)，而native是調用其它程序語言的代碼，所以不存在由子類去實現(xiàn)的問題，矛盾。
關于abstract和synchronized同用的問題，我覺得也不行，因為在這幾年的開發(fā)中，從沒見過這種情況，而且我覺得synchronized應該是作用在一個具體的方法上才有意義。
25、什么是內部類？
在一個類的內部定義的類叫做內部類。
26、內部類可以引用外部類的成員嗎？有沒有什么限制？
如果不是靜態(tài)內部類，完全可以。
27、Static Nested Class 和 Inner Class的不同。
Nested Class一般是C++的說法，Inner Class一般是Java的說法，指的是同一意思。
內部類分為靜態(tài)內部類和非靜態(tài)內部類。
靜態(tài)內部類中可以包含靜態(tài)成員，非靜態(tài)內部類中不可以包含靜態(tài)成員。
靜態(tài)內部類中不能引用外部類中的實例成員。非靜態(tài)內部類則沒有這個限制。
28、Anonymous Inner Class(匿名內部類)是否可以extends(繼承)其它類，是否可以implements(實現(xiàn))interface(接口)?
可以繼承其它類，可以實現(xiàn)接口
29、String是最基本的數(shù)據類型嗎?
不是，基本數(shù)據類型是:byte short int long float double char boolean 30、String s = “Hello”;s = s + “ world!”;這兩行代碼執(zhí)行后，原始的String對象中的內容到底變了沒有？
沒有，String類被設計為不可變的類。所以它的所有對象都不可變。
31、是否可以繼承String類?
不可以。String被final修飾，被final修飾的類不可被繼承。
32、String s = new String(“xyz”);創(chuàng)建了幾個String Object? 二者之間有什么區(qū)別？
2個對象。一個放在常量區(qū)，不管寫多少遍，永遠只有一個。一個放在堆內存中。每次new String就產生一個新的。
33、String 和StringBuffer的區(qū)別
String和StringBuffer都是操作字符串的類。
String類被設計為不可變，而StringBuffer可變。
34、如何把一段逗號分割的字符串轉換成一個數(shù)組?
作者:楊金輝
第一種用正則表達式的方式：String類的split方法
第二種方式:StringTokenizer,代碼為: new StringTokenizer(“1,2,3,4”,”,”);
35、數(shù)組有沒有l(wèi)ength()這個方法? String有沒有l(wèi)ength()這個方法？
數(shù)組是length屬性，String有l(wèi)ength()這個方法
36、try {}里有一個return語句，那么緊跟在這個try后的finally {}里的code會不會被執(zhí)行，什么時候被執(zhí)行，在return前還是后?
會，return前
38、final, finally, finalize的區(qū)別。
final用來修飾類，變量，方法的。修飾類表示類不可被繼承，修飾變量表示變量的引用不可變，修飾方法表示方法不可被重寫。
finally是異常處理結構中的一部分，表示一定會執(zhí)行。
finalize是Object類的方法，當垃圾收集器執(zhí)行的時候會調用此對象的這個方法。
39、運行時異常與一般異常有何異同？
一般異常強制要求捕獲或聲明。
運行時異常可以捕獲，也可以不捕獲。40、error和exception有什么區(qū)別?
error表示恢復不是不可能但是很困難的情況下的一種嚴重問題。例如：內存溢出
exception表示程序的設計或實現(xiàn)有問題。也就是說如果程序正常運行，不會發(fā)生的情況。
41、Java中的異常處理機制的簡單原理和應用。
當Java程序違反了Java的語義規(guī)則時，JVM就會將發(fā)生的錯誤表示為一個異常。違反語義規(guī)則包括兩種：一種是Java類庫內置的語義檢查，另一種是程序員自己定義的異常。
42、給我一個你最常見到的runtime（茹二樓）exception。
ArithMaticException NullPointException IndexOfBoundException HibernateException(子類:CacheException,LazyInitializationException,MappingException)NestedRuntimeException(AopConfigException,AopInvocationException)
43、JAVA語言如何進行異常處理，關鍵字：throws,throw,try,catch,finally分別代表什么意義？在try塊中可以拋出異常嗎？
throws 用來表名方法可能拋出異常。throw 用來明確的拋一個異常。
try 用來監(jiān)控一段可能出現(xiàn)異常的代碼。當出現(xiàn)異常后進入catch塊，進行異常類型匹配
finally表示無論是否出現(xiàn)異常都要執(zhí)行的代碼。
44、java中有幾種方法可以實現(xiàn)一個線程？用什么關鍵字修飾同步方法? stop()和suspend()方法為何不推薦使用？
有兩種實現(xiàn)方法，分別是繼承Thread（斯 read）類與實現(xiàn)Runnable（軟的包）接口
用synchronized（新鬼耐斯特）關鍵字修飾同步方法
因為他們是線程的方法，不安全，當已啟動后，就想脫韁野馬難以把控
45、sleep()(斯瑞譜)和 wait()（外特）有什么區(qū)別?
1、sleep是線程類的方法 wait 是Object類的方法
2、sleep會自動醒來 wait需要notify喚醒
3、sleep不會釋放鎖 wait會釋放鎖
46、同步和異步有何異同，在什么情況下分別使用他們？舉例說明。
作者:楊金輝
48、多線程有幾種實現(xiàn)方法?同步有幾種實現(xiàn)方法?
多線程有兩種實現(xiàn)方法，分別是繼承Thread類與實現(xiàn)Runnable接口
同步的實現(xiàn)方面有三種:
1、同步代碼塊
2、同步方法
3、Lock
49、啟動一個線程是用run()還是start()?.Start()（斯達特）
50、當一個線程進入一個對象的一個synchronized方法后，其它線程是否可進入此對象的其它方法?
分幾種情況：
1.其他方法前是否加了synchronized關鍵字，如果沒加，則能。
2.如果這個方法內部調用了wait，則可以進入其他synchronized方法。
3.如果其他個方法都加了synchronized關鍵字，并且內部沒有調用wait，則不能。
51、線程的基本概念、線程的基本狀態(tài)以及狀態(tài)之間的關系
線程就是進程中的一個執(zhí)行線路。
新建new Thread();就緒:thread.start();運行，阻塞，掛起，結束。
創(chuàng)建一個線程，這時狀態(tài)為新建，當調用start方法后轉為就緒，再由線程調度器將就緒狀態(tài)轉為運行狀態(tài)，遇到synchronized語句后，可能由運行狀態(tài)改為阻塞狀態(tài)，當獲得synchronized鎖后由阻塞狀態(tài)轉為運行，這時調用wait方法轉為掛起狀態(tài)。當線程關聯(lián)的代碼執(zhí)行完成后。線程轉為結束。
52、簡述synchronized和java.util.concurrent.locks.Lock的異同 ？
主要相同點：Lock（拉克）能完成synchronized所實現(xiàn)的所有功能
主要不同點：Lock有比synchronized更精確的線程語義和更好的性能。synchronized會自動釋放鎖，而Lock一定要求程序員手工釋放，并且必須在finally從句中釋放。
54、ArrayList和Vector的區(qū)別
ArrayList和Vector都實現(xiàn)了List接口。
ArrayList是線程不安全的，Vector是線程安全的。
ArrayList的增長方式為*3/2+1 Vector的增長方式為*2,Vector還可以設置增長量。
55、HashMap和Hashtable的區(qū)別
Hashtable和HashMap都實現(xiàn)了Map接口。
Hashtable是線程安全的，HashMap是線程不安全的。
Hashtable不允許鍵值為null，HashMap允許。
Hashtable自JDK1.0就有了，HashMap到1.2才出來。
Map中有2個方法分別是containsKey(康騰思Key)和containsValue；Hashtable中還有個contains方法，容易讓人誤解，HashMap沒有。
56、List 和 Map 區(qū)別? List是存儲單列數(shù)據的有序集合，允許重復。而Map是鍵值對雙列數(shù)據的集合。鍵不允許重復，值可以重復。
57、List, Set, Map是否繼承自Collection接口?
Collection(克萊克神)是集合類的頂級接口，其子接口分別是List和Set List下有ArrayList,LinkedList Set下有HashSet TreeSet Collection和Map沒有關系，Map是HashMap的父接口
58、List、Map、Set三個接口，存取元素時，各有什么特點？
作者:楊金輝
List以特定的次序來持有元素，允許重復。
Set無法擁有重復元素，內部排序。
Map保存key-value值，key不可重復，value可重復。
59、說出ArrayList,Vector, LinkedList的存儲性能和特性
ArrayList和Vector都是使用數(shù)組存儲數(shù)據。查找快，插入慢。由于Vector是線程安全的，所以性能上比ArrayList差。
LinkedList是鏈表結構。插入快，查找慢。60、去掉一個Vector集合中重復的元素
最簡單的方式:HashSet set = new HashSet(vector);61、Collection 和 Collections的區(qū)別。
Collection是集合類的頂級接口，而Collections是集合類的輔助類，如:將一個數(shù)組的元素copy到另一個集合。
62、Set里的元素是不能重復的，那么用什么方法來區(qū)分重復與否呢? 是用==還是equals()? 它們有何區(qū)別?
equals，區(qū)別見11題
63、你所知道的集合類都有哪些？主要方法？
集合類有(畫集合類的體系結構)ArrayList的主要方法:add,get,remove,contains,indexOf,isEmpty,toArray,iterator LinkedList的主要方法:add,get,remove,addFirst,addLast,getFirst,getLast,iterator HashSet的主要方法:add,iterator,remove HashMap的主要方法:put,get,remove,entrySet,keyset,values 64、兩個對象值相同(x.equals(y)== true)，但卻可有不同的hash code，這句話對不對?
對。+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 65、java中有幾種類型的流？JDK為每種類型的流提供了一些抽象類以供繼承，請說出他們分別是哪些類？
根據功能分:輸入流，輸出流 根據類型分:字節(jié)流，字符流
輸入字節(jié)流的抽象類:InputStream 輸出字節(jié)流的抽象類:OutputStream（Stream斯俊木）
輸入字符流的抽象類:Reader（瑞得）
輸出字符流的抽象類:Writer（ruai 的）66、什么是java序列化，如何實現(xiàn)java序列化？
序列化就是指將內存中的一個對象存儲到硬盤中或者轉為字節(jié)碼作網絡傳輸。
實現(xiàn)Serializable(修兒奈斯啵)接口。
67、描述一下JVM加載class文件的原理機制?
JVM中類的加載是由ClassLoader和它的子類來實現(xiàn)的。Java Class Loader是一個重要的Java運行時系統(tǒng)組件。它是一個負責查找和裝入類文件的類。68、heap（細譜）和stack（死大克）有什么區(qū)別。
stack是用來保存基本數(shù)據類型，以及變量的引用。小，速度快
heap是用來保存new 出來的對象。大，速度慢。69、GC是什么? 為什么要有GC?
GC是Garbage Collection(垃圾回收)。內存處理是程序員容易出現(xiàn)問題的地方。忘記回收或錯誤的內存回收會導致程序或系統(tǒng)的不穩(wěn)定甚至崩潰。Java提供的GC可以自動檢測對象是否已經死亡，從而進行回收內存。
70、垃圾回收的優(yōu)點和原理。并考慮2種回收機制。
垃圾回收機制使得程序員不需要關注內存的回收和釋放，提高了程序的健壯性。
作者:楊金輝
垃圾回收器通常是作為一個單獨的低級別線程運行。當程序員創(chuàng)建對象時，GC就開始監(jiān)測這個對象的地址、大小及使用情況，通常，GC采用有向圖的方式記錄和管理堆中的所有對象。通過這種方式確定哪些對象是”不可達”時，GC就有責任回收這些內存空間。
標記垃圾回收機制和分帶復制垃圾回收機制。71、垃圾回收器的基本原理是什么？垃圾回收器可以馬上回收內存嗎？有什么辦法主動通知虛擬機進行垃圾回收？
垃圾回收器通常是作為一個單獨的低級別線程運行。當程序員創(chuàng)建對象時，GC就開始監(jiān)測這個對象的地址、大小及使用情況，通常，GC采用有向圖的方式記錄和管理堆中的所有對象。通過這種方式確定哪些對象是”不可達”時，GC就有責任回收這些內存空間。
可以。通過System.gc();或者Runtime.getRuntime().gc();來通知GC回收內存，但是Java語言規(guī)范不保證GC一定會執(zhí)行。72、什么時候用assert（額色特）。
assert(斷言)是程序開發(fā)中一種常見的調試方式。73、java中會存在內存泄漏嗎，請簡單描述。
會。內存泄漏就是指一個不再被程序使用的對象一直占據著內存。
長生命周期的對象持有短生命周期對象的引用就很可能發(fā)生內存泄露，盡管短生命周期對象已經不再需要，但是因為長生命周期對象持有它的引用而導致不能被回收，這就是java中內存泄露的發(fā)生場景
75、說出一些常用的類，包，接口，請各舉5個
包:(Spring)org.springframework.context,org.springframework.web.context, org.springframework.web.context.filter,org.springframework.orm.hibernate3.support
(Hibernate)org.hibernate,org.hibernate.cfg
(Struts)org.apache.struts.actions,org.apache.struts.upload
(DWR)org.directwebremoting.servlet
接口:(Spring)ApplicationContext，(Hibernate)SessionFactory,Session,Query,Criteria,SQLQuery,Transaction
(Struts)FormFile
類:(Spring)ClassPathApplicationContext, OpenSessionInViewFilter,CharacterEncodingFilter
(Hibernate)Configuration,Hibernate
(Struts)ActionForm,Action,DispatchAction,MappingDisactionAction
(DWR)DwrServlet 77、能不能自己寫個類，也叫java.lang.String？
能，但是沒什么價值。
79、說明生活中遇到的二叉樹，用java實現(xiàn)二叉樹 81、寫一個Singleton（省構騰）出來。
1、構造私有
2、一個靜態(tài)的自身屬性，初始化
3、提供共有的訪問自身屬性的方法
84、排序都有哪幾種方法？請列舉。用JAVA實現(xiàn)一個快速排序。
冒泡排序，插入排序，選擇排序，快速排序 90、HTTP請求的GET與POST方式的區(qū)別
1、Get方式請求的字符串長度不能超過255，Post理論上沒有限制。
作者:楊金輝
2、Get方式會將請求的內容在地址欄顯示，Post不會。所以Get方式不安全，Post方式安全。
91、解釋一下什么是servlet;servlet就是運行在服務器端的java小程序。92、說一說Servlet的生命周期?
出生(new),學習(init),服務(service),死亡(destroy)93、Servlet的基本架構
public MyServlet extends HttpServlet{ public void doGet(HttpServletRequest req,HttpServletResponse resp)throws IOException,ServletException{} public void doPost(HttpServletRequest req,HttpServletResponse resp)throws ServletException,IOException{} } 94、SERVLET API中forward()與redirect()（瑞滴ruai克特）的區(qū)別？
1、forward是請求對象的方法，redirect是響應對象的方法;
2、forward是轉發(fā)，地址欄不會顯示轉發(fā)后的路徑,redirect是重定向，地址欄會顯示
3、forward比redirect效率更高
4、forward是1次請求，redirect是2次請求
5、forward只能在本工程內轉向，redirect可以跳轉到其他工程 95、什么情況下調用doGet()和doPost()？
jsp頁面中的form標簽里的method屬性為get時調用doGet()，為post時調用doPost()。96、Request對象的主要方法：
setAttribute(String name,Object)：設置名字為name的request的參數(shù)值
getAttribute(String name)：返回由name指定的屬性值
getAttributeNames()：返回request對象所有屬性的名字集合，結果是一個枚舉的實例
getCookies()：返回客戶端的所有Cookie對象，結果是一個Cookie數(shù)組
getCharacterEncoding()：返回請求中的字符編碼方式
getContentLength()：返回請求的Body的長度
getHeader(String name)：獲得HTTP協(xié)議定義的文件頭信息
getHeaders(String name)：返回指定名字的request Header的所有值，結果是一個枚舉的實例
getHeaderNames()：返回所以request Header的名字，結果是一個枚舉的實例
getInputStream()：返回請求的輸入流，用于獲得請求中的數(shù)據
getMethod()：獲得客戶端向服務器端傳送數(shù)據的方法
getParameter(String name)：獲得客戶端傳送給服務器端的有name指定的參數(shù)值
getParameterNames()：獲得客戶端傳送給服務器端的所有參數(shù)的名字，結果是一個枚舉的實例
getParametervalues(String name)：獲得有name指定的參數(shù)的所有值
getProtocol()：獲取客戶端向服務器端傳送數(shù)據所依據的協(xié)議名稱
getQueryString()：獲得查詢字符串
getRequestURI()：獲取發(fā)出請求字符串的客戶端地址
getRemoteAddr()：獲取客戶端的IP地址
getRemoteHost()：獲取客戶端的名字
getSession([Boolean create])：返回和請求相關Session
作者:楊金輝
getServerName()：獲取服務器的名字
getServletPath()：獲取客戶端所請求的腳本文件的路徑
getServerPort()：獲取服務器的端口號
removeAttribute(String name)：刪除請求中的一個屬性
97、forward 和redirect的區(qū)別
98、request.getAttribute()和 request.getParameter()有何區(qū)別?
1、request.getParameter()從 請求中的參數(shù)中取值;request.getAttribute()從 請求的作用域中取值
2、request.getParameter()返回 String類型;request.getAttribute()返回Object類型
99、jsp有哪些內置對象?作用分別是什么? 分別有什么方法？
JSP共有以下9個內置的對象：
request----用戶端請求，此請求會包含來自GET/POST請求的參數(shù)
response----網頁傳回用戶端的回應
pageContext----網頁的屬性是在這里管理
session----與請求有關的會話期
application servlet 正在執(zhí)行的內容
out----用來傳送回應的輸出
config----servlet的構架部件
page----JSP網頁本身
exception----針對錯誤網頁，未捕捉的例外 100、jsp有哪些動作?作用分別是什么?
JSP共有以下6種基本動作
jsp:include：在頁面被請求的時候引入一個文件。
jsp:useBean：尋找或者實例化一個JavaBean。
jsp:setProperty：設置JavaBean的屬性。
jsp:getProperty：輸出某個JavaBean的屬性。
jsp:forward：把請求轉到一個新的頁面。
jsp:plugin：根據瀏覽器類型為Java插件生成OBJECT或EMBED標記 101、JSP的常用指令
page指令 屬性: language(指示使用什么語言編譯JSP網頁,暫時只支持Java語言,默認java)、extends(定義JSP網頁產生的Servlet繼承的父類)、import(同Java的import)、session(設置當前網頁是否可以使用Session對象,默認為true)、buffer(設置輸出流是否有緩沖區(qū),默認為8KB)、autoFlush(設置是否自動清除緩沖區(qū),緩沖區(qū)如果溢出會產生異常,默認true)、isThreadSafe(設置當前頁面是否允許處理超過1個以上的請求,不建議更改,默認為true)、info(設置當前JSP網頁的相關信息)、errorPage(設置一旦發(fā)生異常后重新定向哪個url)、isErrorPage(設置該JSP頁面是否為異常處理的頁面)、contentType(置MIME類型和編碼方式:text/html;charset=GBK)、pageEncoding(設置編碼方式)、isELIgnored(設置是否忽略EL表達式,默認值為false)taglib指令
include指令
102、JSP中動態(tài)INCLUDE與靜態(tài)INCLUDE的區(qū)別？
1、靜態(tài)是指令
動態(tài)是動作
2、靜態(tài)只產生一個文件
動態(tài)產生兩個
3、靜態(tài)不可以帶參數(shù)
動態(tài)可以帶參數(shù)
作者:楊金輝
4、靜態(tài)不會動態(tài)更新
動態(tài)可以。
104、頁面間對象傳遞的方法
session、cookie、隱藏表單域、url重寫
105、JSP和Servlet有哪些相同點和不同點，他們之間的聯(lián)系是什么？
JSP 轉義以后就是servlet
1、jsp后綴名是.jsp servlet的后綴名是.java
2、jsp 側重于顯示
servlet側重于邏輯
3、jsp在mvc中屬于view
servlet屬于controller 106、MVC的各個部分都有那些技術來實現(xiàn)?如何實現(xiàn)? MVC 是Model-View-Controller的簡寫.“Model” 代表的是應用的業(yè)務邏輯(通過JavaBean,EJB組件實現(xiàn)), “View” 是應用的表示面(由JSP頁面產生),“Controller” 是提供應用的處理過程控制(一般是一個Servlet),通過這種設計模型把應用邏輯,處理過程和顯示邏輯分成不同的組件實現(xiàn).這些組件可以進行交互和重用。
107、我們在web應用開發(fā)過程中經常遇到輸出某種編碼的字符，如iso8859-1等，如何輸出一個某種編碼的字符串？
new String(str.getByte(“原編碼”),”新編碼”);
108、現(xiàn)在輸入n個數(shù)字，以逗號，分開；然后可選擇升或者降序排序；按提交鍵就在另一頁面顯示按什么排序，結果為，提供reset 109、數(shù)據庫三范式是什么? 第一范式:保證每列的原子性。
第二范式:必須要有主鍵[，并且其它列都依賴于該主鍵];第三范式:取消傳遞依賴
110、說出一些數(shù)據庫優(yōu)化方面的經驗?
1、存儲優(yōu)化
A、通過表空間將數(shù)據分散到不同的硬盤上
B、通過表分區(qū)分散數(shù)據，方便備份還原
2、查詢優(yōu)化
A、通過表分區(qū)方便查詢 B、為表建立索引 C、SQL語句
111、union（優(yōu)妮安）和union all（哦）有什么不同? union去重復
union all不去重復 113、、什么是存儲過程和如何編寫
存儲過程就是存儲在數(shù)據庫中帶有名字的PL/SQL塊，完成一定的功能。
Create or replace procedure procName(參數(shù)in,out,in out)As|is Variable….Begin exception end 114、、注冊Jdbc驅動程序的三種方式
Class.forName(“com.microsoft.sqlserver.jdbc.SQLServerDriver”);System.setProperty(“jdbc.drivers”,” com.microsoft.sqlserver.jdbc.SQLServerDriver”);
作者:楊金輝
DriverManager.registerDriver(new com.microsoft.sqlserver.jdbc.SQLServerDriver());115、、用JDBC如何調用存儲過程
CallableStatement callSta = con.prepareCall(“{call 過程名}”);callSta.execute();116、JDBC中的PreparedStatement相比Statement的好處
速度快，可以防止sql 注入攻擊。118、Class.forName的作用?為什么要用?
加載類文件，創(chuàng)建類對象。注冊驅動。119、大數(shù)據量下的分頁解決方法。
我們一般采用后臺SQL語句分頁
121、說出數(shù)據連接池的工作機制是什么?
因為我們在操作數(shù)據庫的時候，打開連接和關閉連接是耗時，耗性能，我們希望通過一種機制減少這種開銷，這就是數(shù)據連接池的初衷；
J2EE服務器啟動時會建立一定數(shù)量的池連接，并放入到一個池中，當我需要獲得連接的時候，只需要從此池中拿到連接并標記為繁忙，用完之后放回池中并標記為空閑，這樣就能提高我們的訪問性能。
122、為什么要用 ORM? 和 JDBC 有何不一樣?
ORM就是Object Relational Mapping 對象關系映射，因為用jdbc操作數(shù)據庫代碼非常繁瑣，ORM可以將表映射成實體，與我們的OOP編程思想完全一致的，方便程序開發(fā)。但速度比jdbc慢
123、xml有哪些解析技術?區(qū)別是什么? DOM、SAX DOM是一次性將一個文件載入內存，產生DOM樹，適合多次讀寫操作，適合操作小型文檔
SAX 是事件驅動的解析方式，它不是一次性載入整個文件，而是遇到文檔開頭標記等等觸發(fā)事件來處理，適合解析大型文檔
124、你在項目中用到了xml技術的哪些方面?如何實現(xiàn)的?
1、數(shù)據交換
2、配置文件
3、存儲數(shù)據
125、用jdom解析xml文件時如何解決中文問題?如何解析?
import javax.xml.transform.*;Transformer transformer = TransformerFactory.newInstance().newTransformer();transformer.setOutputProperty(javax.xml.transform.OutputKeys.ENCODING, “gb2312”);transformer.setOutputProperty(javax.xml.transform.OutputKeys.INDENT, “yes”);126、編程用JAVA解析XML的方式.127、XML文檔定義有幾種形式？它們之間有何本質區(qū)別？解析XML文檔有哪幾種方式？
a: 兩種形式 dtd schema，（是給帽）
b: 本質區(qū)別:schema本身是xml的，比DTD有更精確的規(guī)則定義;128、BS與CS的聯(lián)系與區(qū)別。
C/S是Client/Server的縮寫。B/Ｓ是Brower/Server的縮寫，1、硬件不同，一個是局域網，一個是廣域網
2、安全不同
C/S安全高
B/S
3、速度不同
C/S速度塊
作者:楊金輝
4、維護
C/S不方便維護
B/S方便維護 129、應用服務器與WEB SERVER的區(qū)別？
1、應用服務器處理業(yè)務邏輯，web服務器則主要是讓客戶可以通過瀏覽器進行訪問。
2、應用服務器處理業(yè)務邏輯，web服務器是用于處理HTML文件的。web服務器通常比應用服務器簡單，如apache就是web服務器，Jboss就是EJB應用服務器。應用服務器：Weblogic、Tomcat、Jboss WEB SERVER：IIS、Apache 130、應用服務器有那些？
BEA WebLogic Server，IBM WebSphere Application Server，Oracle9i Application Server，jBoss，Tomcat 131、J2EE是什么？
J2EE是應用平臺，是標準，是框架
133、請對以下在J2EE中常用的名詞進行解釋(或簡單描述)
Web容器:能解析Jsp和Servlet的應用服務器 EJB 容器:就是能解析EJB組件的應用服務器
JNDI(Java Naming And Directory Interface)Java命名與目錄接口 JMS(Java Message Service)Java 消息服務 JTA(Java Transaction API)Java事務接口
JAF(Java Action Framework)Java 安全認證框架
RMI/IIOP(Remote Method Invocation/Internet Inter Object Request Broker Protocol)遠程方法調用/互聯(lián)網內部對象請求代理協(xié)議
150、WEB SERVICE名詞解釋。JSWDL開發(fā)包的介紹。JAXP、JAXM的解釋。SOAP、UDDI,WSDL解釋。
JAXP(Java API for XML Parsing)JAXM(Java API for XML Messaging)SOAP(Simple Object Access Protocol)UDDI(Universal Description, Discovery and Integration)WSDL(Web Services Description Language)151、CORBA是什么?用途是什么?
CORBA（Common Object Request Broker Architecture,公共對象代理體系結構
為解決分布式處理環(huán)境(DCE)中，硬件和軟件系統(tǒng)的互連而提出的一種解決方案； 152、流行的框架與新技術
Apache Struts,Spring Hibernate,Ibatis, JQuery,ext,JSF 153、談談Struts中的Action servlet。154、Struts優(yōu)缺點
優(yōu)點:簡化了mvc的開發(fā)，標簽庫提高開發(fā)效率 缺點:
1、每個action都要配一個form
2、action、form之間緊耦合
3、action與web對象也是緊耦合
4、它是單實例，多線程的，安全，速度慢
5、擴展不靈活
155、STRUTS的應用(如STRUTS架構)
Struts是采用Servlet和Jsp技術開發(fā)的Web應用程序的framework。
作者:楊金輝
采用Struts能開發(fā)基于MVC設計模式的應用架構，Struts有如下的主要功能，1、包含一個Controller Servlet，將用戶的請求發(fā)送到不同的Action
2、為JSP頁面提供了大量的標簽庫
3、支持國際化
156、hibernate中的update()和saveOrUpdate()的區(qū)別，session的load()和get()的區(qū)別。
update()方法將游離對象轉變?yōu)槌志没瘜ο?，然后計劃?zhí)行一條update語句。saveOrUpdate()方法包含了save()和update()，如果傳入的參數(shù)是自由對象，則調用save()如果是游離對象，則調用update()方法
1、當數(shù)據庫中的記錄不存在時load()方法拋出ObjectNotFoundException()而get()返回null
2、load()默認采用的是延遲加載策略，返回的是代理對象； get()方法總是采用立即檢索策略，返回的是實際對象
157、簡述 Hibernate 和 JDBC 的優(yōu)缺點? 如何書寫一個 one to many 配置文件.Hibernate其實就是對JDBC的封裝。
Hibernate操作簡單，性能差。
JDBC操作復雜，性能好。
158、iBatis與Hibernate有什么不同? iBatis介于Hibernate與JDBC之間，性能比Hibernate好，操作比JDBC簡單，都是持久層的框架。
159、介紹一下Hibernate的二級緩存
緩存就是指把查詢出來的數(shù)據或對象保存在內存（Hashmap）中，以減少查詢除數(shù)。
Session是Hibernate的一級緩存。只能是當前Session共享緩存。
SessionFactory是Hibernate的二級緩存，它可以使多個Session中共享緩存。
160、Spring 的依賴注入是什么意思? 給一個 Bean 的 message 屬性, 字符串類型, 注入值為 “Hello” 的 XML 配置文件該怎么寫? 161、Jdo是什么?
Java Data Object,java數(shù)據對象，比jdbc更通用 162、什么是spring的IOC AOP 163、STRUTS的工作流程！
164、怎樣消除遞歸？
使用棧和循環(huán)。165、UML方面
Unified Modeling Language統(tǒng)一建模語言,用來畫用例圖，靜態(tài)圖(包括類圖，對象圖和包圖)，行為圖，交互圖(順序圖，合作圖)，實現(xiàn)圖，流程圖 166、軟件開發(fā)的
167、j2ee常用的設計模式？說明工廠模式。
工廠模式，代理模式，單例模式，責任鏈，觀察者 168、開發(fā)中都用到了那些設計模式?用在什么場合?
工廠模式，代理模式，單例模式
170、LINUX下線程，GDI類的解釋。
作者:楊金輝
LINUX實現(xiàn)的就是基于核心輕量級進程的“一對一”線程模型,一個線程實體對應一個核心輕量級進程,而線程之間的管理在核外函數(shù)庫中實現(xiàn).GDI類為圖像設備編程接口類庫
172、四種會話跟蹤技術
URL重寫，Cookie，Session，隱藏表單域
173、簡述邏輯操作(&,|,^)與條件操作(&&,||)的區(qū)別。
174、請用英文簡單介紹一下自己.175、請把 http://tomcat.apache.org/ 首頁的這一段話用中文翻譯一下? 176、美資軟件公司JAVA工程師電話面試題目
177、左聯(lián)跟外聯(lián)各指什么？有什么區(qū)別？ 178、javascript怎么創(chuàng)建一個xml document
第五篇：JAVA面試題
1、面向對象的四個特征：封裝、繼承、多態(tài)、抽象
封裝：
繼承：子類繼承父類，除private修飾以外的所以方法和屬性 多態(tài)：一個對象多種狀態(tài)，可以把子類對象當作父類對象來看，一旦這樣做了，就只能
去調用父類中原有定義的屬性和方法，也就是子類中擴展的方法或屬性就不能調用了。
抽象：
2、abstractclass 和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)了該接口的類的任何對象上調用接口的方法。由于有抽象類，它允許使用接口名作為引用變量的類型。通常的動態(tài)聯(lián)編將生效。引用可以轉換到接口類型或從接口類型轉換，instanceof 運算符可以用來決定某對象的類是否實現(xiàn)了接口。
3、final、finally、finalize的區(qū)別
final 用于聲明屬性，方法和類，分別表示屬性不可變，方法不可覆蓋，類不可繼承。finally是異常處理語句結構的一部分，表示總是執(zhí)行。
finalize是Object類的一個方法，在垃圾收集器執(zhí)行的時候會調用被回收對象的此方法，可以覆蓋此方法提供垃圾收集時的其他資源回收，例如關閉文件等。
4、匿名內部類是否可以作為父類被其他類繼承，或做為接口被實現(xiàn)？
匿名內部類不被繼承也不能被實現(xiàn)，因為它沒有名字，而一個內部類只要有名字就可以作為父類被繼承，也可以作為借口被實現(xiàn)。
5、多線程有幾種實現(xiàn)方法，同步有幾種實現(xiàn)方法，都是什么？
多線程有兩種實現(xiàn)方法，分別繼承繼承Thread類與實現(xiàn)runnable借口。
同步的實現(xiàn)方法有兩種，分別是synchronized，wait與notify。
6、string 與 stringbuffer的區(qū)別？
String的長度是不可變的，而stringbuffer的長度是可變的。如果你對字符中的內容經常進行操作，特別是內容修改時，那么就要使用stringbuffer，如果最后需要使用string，那么使用stringbuffer的tostring()方法。
7、解析XML文件的幾種方式和區(qū)別
DOM：處理大型文件時其性能下降的非常厲害
SAX：SAX是事件驅動型的XML解析方式，它是順序讀取XML文件，不需要一次性全部裝載整個文件。
8、sleep()和wait()有什么區(qū)別？
sleep是線程類（Thread）的方法，導致此線程暫停執(zhí)行指定時間，給執(zhí)行機會給其他線程，但是監(jiān)控狀態(tài)依然保持，到時后會自動恢復。調用sleep不會釋放對象鎖。
wait是Object類的方法，對此對象調用wait方法導致本線程放棄對象鎖，進入等待此對象的等待鎖定池，只有針對此對象發(fā)出notify方法（或notifyAll）后本線程才進入對象鎖定池準備獲得對象鎖進入運行狀態(tài)。
9、數(shù)組有沒有l(wèi)ength這個方法？string有沒有l(wèi)ength這個方法？
數(shù)組沒有l(wèi)ength（）這個方法，有l(wèi)ength這個屬性
String有l(wèi)ength（）這個方法
10、LinkedList、ArrayList和Vector的區(qū)別？ ArrayList和Vector是采用數(shù)組方式存儲數(shù)據，此數(shù)組元素總數(shù)大于實際存儲的數(shù)據個數(shù)以便增加和插入元素，二者都允許直接序號索引元素，但是插入數(shù)據要移動數(shù)組元素等內存操作，所以它們索引數(shù)據快、插入數(shù)據慢。
Vector由于使用了synchronized同步方法（如add、insert、remove、set、equals、hashcode等操作），因此是線程安全，性能上比ArrayList要差。
LinkedList使用雙向鏈表實現(xiàn)存儲，按序號索引數(shù)據需要進行向前或向后遍歷，但是插入數(shù)據時只需要記錄本項的前后項即可，所以插入數(shù)度較快！LinkedList雙向鏈表，是指可以從first依次遍歷至last（從頭到尾），也可以從last遍歷至first（從尾到頭），但首尾沒有構成環(huán)，不同于雙向循環(huán)鏈表（注意區(qū)分）：
11、hashmap與hashtable的區(qū)別？
都屬于Map接口的類，實現(xiàn)了將惟一鍵映射到特定的值上。
HashMap類沒有分類或者排序。它允許一個null鍵和多個null值。
Hashtable類似于HashMap，但是不允許null鍵和null值。它也比HashMap慢，因為它是同步的。
12、Jsp有哪些內置對象，作用分別是什么？（至少能說出五個）
request表示HttpServletRequest對象。它包含了有關瀏覽器請求的信息，并且提供了幾個用于獲取cookie, header, 和session數(shù)據的有用的方法。
response表示HttpServletResponse對象，并提供了幾個用于設置送回 瀏覽器的響應的方法（如cookies,頭信息等）
out對象是javax.jsp.JspWriter的一個實例，并提供了幾個方法使你能用于向瀏覽器回送輸出結果。
pageContext表示一個javax.servlet.jsp.PageContext對象。它是用于方便存取各種范圍的名字空間、servlet相關的對象的API，并且包裝了通用的servlet相關功能的方法。
session表示一個請求的javax.servlet.http.HttpSession對象。Session可以存貯用戶的狀態(tài)信息
applicaton 表示一個javax.servle.ServletContext對象。這有助于查找有關servlet引擎和servlet環(huán)境的信息
config表示一個javax.servlet.ServletConfig對象。該對象用于存取servlet實例的初始化參數(shù)。
page表示從該頁面產生的一個servlet實例
13、Javaservletapi中forward()與redirect()的區(qū)別？
前者僅是容器中控制權的轉向，在客戶端瀏覽器地址欄中不會顯示出轉向后的地址；后者則是完全的跳轉，瀏覽器將會得到跳轉的地址，并重新發(fā)送請求鏈接。這樣，從瀏覽器的地址欄中可以看到跳轉后的鏈接地址。所以，前者更加高效，在前者可以滿足需要時，盡量使用forward()方法，并且，這樣也有助于隱藏實際的鏈接。在有些情況下，比如，需要跳轉到一個其它服務器上的資源，則必須使用sendRedirect()方法。
14、重載（overload）與重寫（override）的區(qū)別？
Overload：方法名相同，參數(shù)不同，與返回值無關
Override：方法名相同，參數(shù)相同，相同的返回值，建立在繼承的基礎之上
15、什么是單例模式，在程序中如何使用？
單例模式確保一個類只有一個實例 餓漢式單例類
public class Singleton {
private Singleton(){}
private static Singleton instance = new Singleton();
public static Singleton getInstance(){
return instance;
}
}
懶漢式單例類
public class Singleton {
private static Singleton instance = null;
public static synchronized Singleton getInstance(){
if(instance==null)
instance＝new Singleton();
return instance;
}
}
16、Servlet生命周期？
加載和實例化
初始化init()
請求處理service()
服務終止destroy()
17、spring中IOC與AOP的含義？
IOC:控制反轉，是一種設計模式，一層含義控制權的轉移，由傳統(tǒng)的在程序中控制依賴轉移到由容器來控制，第二層是依賴注入將互相依賴的對象分離，在spring配置文件中描述它們的依賴關心，它們的依賴關系只是在使用的時候才建立
AOP：面向切面，是一種編程思想，oop的延續(xù)，將系統(tǒng)中非核心的業(yè)務提取出來，進行單獨的處理，比如事務、日志和安全等
Spring的AOP和IOC都是為了解決系統(tǒng)代碼耦合度過高的問題，使用代碼重用性高，易于維護，不過AOP和IOC并不是spring中特有的，只是spring把它們應用的更靈活方便。
18、hibernate與JDBC的區(qū)別？
相同點：
1>兩者都是JAVA的數(shù)據庫操作中間件。
2>兩者對于數(shù)據庫進行直接操作的對象都不是線程安全的，都需要及時關閉。
3>兩者都可以對數(shù)據庫的更新操作進行顯式的事務處理。
不同點：
1>使用的SQL語言不同：JDBC使用的是基于關系型數(shù)據庫的標準SQL語言，Hibernate使用的是HQL(Hibernate query language)語言
2>操作的對象不同：JDBC操作的是數(shù)據，將數(shù)據通過SQL語句直接傳送到數(shù)據庫中執(zhí)行，Hibernate操作的是持久化對象，由底層持久化對象的數(shù)據更新到數(shù)據庫中。3>數(shù)據狀態(tài)不同：JDBC操作的數(shù)據是“瞬時”的，變量的值無法與數(shù)據庫中的值保持一致，而Hibernate操作的數(shù)據是可持久的，即持久化對象的數(shù)據屬性的值是可以跟數(shù)據庫中的值保持一致的。
19、struts中的標簽庫有幾種，分別是？
有5種標簽，分別是：bean標簽庫、html標簽庫、logic標簽庫、tiles標簽庫nested標簽庫
20、Error與Exception有什么區(qū)別？
Error表示系統(tǒng)級的錯誤和程序不必處理的異常，Exception表示需要捕捉或者需要程序進行處理的異常。
21、Collection和Collections的區(qū)別。
Collection是集合類的上級接口，繼承與他的接口主要有Set 和List.Collections是針對集合類的一個幫助類，他提供一系列靜態(tài)方法實現(xiàn)對各種集合的搜索、排序、線程安全化等操作
22、GC是什么?為什么要有GC?(基礎)。
GC是垃圾收集器。Java程序員不用擔心內存管理，因為垃圾收集器會自動進行管理。
要請求垃圾收集，可以調用下面的方法之一：
System.gc()
Runtime.getRuntime().gc()
23、啟動一個線程是用run()還是start()?
啟動一個線程是調用start()方法，使線程所代表的虛擬處理機處于可運行狀態(tài)，這意味著它可以由JVM調度并執(zhí)行。這并不意味著線程就會立即運行。run()方法可以產生必須退出的標志來停止一個線程。
24、&和&&的區(qū)別。
&是位運算符，表示按位與運算，&&是邏輯運算符，表示邏輯與（and）。
25、heap和stack有什么區(qū)別。
棧是一種線形集合，其添加和刪除元素的操作應在同一段完成。棧按照后進先出的方
式進行處理。
堆是棧的一個組成元素
26、List, Set, Map是否繼承自Collection接口?
List，Set是，Map不是
27、MVC的各個部分都有那些技術來實現(xiàn)?如何實現(xiàn)?
MVC 是Model－View－Controller的簡寫?！癕odel” 代表的是應用的業(yè)務邏輯（通過JavaBean，EJB組件實現(xiàn)），“View” 是應用的表示面（由JSP頁面產生），“Controller” 是提供應用的處理過程控制（一般是一個Servlet），通過這種設計模型把應用邏輯，處理過程和顯示邏輯分成不同的組件實現(xiàn)。這些組件可以進行交互和重用。
28、Static Nested Class 和 Inner Class的不同。
Static Nested Class是被聲明為靜態(tài)（static）的內部類，它可以不依賴于外部類實例被實例化。而通常的內部類需要在外部類實例化后才能實例化。
29、接口是否可繼承接口? 抽象類是否可實現(xiàn)(implements)接口? 抽象類是否可繼承實體類
(concrete class)?
接口可以繼承接口。抽象類可以實現(xiàn)(implements)接口，抽象類是否可繼承實體類，但前提是實體類必須有明確的構造函數(shù)
30、JSP和Servlet有哪些相同點和不同點，他們之間的聯(lián)系是什么？
JSP 是Servlet技術的擴展，本質上是Servlet的簡易方式，更強調應用的外表表達。JSP編譯后是“類servlet”。Servlet和JSP最主要的不同點在于，Servlet的應用邏輯是在Java文件中，并且完全從表示層中的HTML里分離開來。而JSP的情況是Java和HTML可以組合成一個擴展名為.jsp的文件。JSP側重于視圖，Servlet主要用于控制邏輯
31、當一個線程進入一個對象的一個synchronized方法后，其它線程是否可進入此對象的其它方法? 不能，一個對象的一個synchronized方法只能由一個線程訪問。
32、運行時異常與一般異常有何異同？
異常表示程序運行過程中可能出現(xiàn)的非正常狀態(tài)，運行時異常表示虛擬機的通常操作中可能遇到的異常，是一種常見運行錯誤。java編譯器要求方法必須聲明拋出可能發(fā)生的非運行時異常，但是并不要求必須聲明拋出未被捕獲的運行時異常。
33、JSP中動態(tài)INCLUDE與靜態(tài)INCLUDE的區(qū)別？
動態(tài)INCLUDE用jsp:include動作實現(xiàn)
靜態(tài)INCLUDE用include偽碼實現(xiàn),定不會檢查所含文件的變化，適用于包含靜態(tài)頁面<%@ include file=“included.htm” %>
點擊咨詢 