j2EE經典面試題
1. hibernate中離線查詢去除重複項怎麼加條件？javascript
dc.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);php
2. http協議及端口,smtp協議及端口css
http：超文本傳輸協議 端口 80 html
smtp：簡單郵件傳輸協議 端口25前端
4. Servlet建立過程及生命週期Servlet 在容器中運行時，其實例的建立及銷燬等是由容器進行控制。 node
Servlet 的建立有兩種方法。 mysql
1）. 客戶端請求對應的 Servlet 時，建立 Servlet 實例;大部分Servlet 都是這種 Servlet 。 jquery
2）. 經過在web.xml 中設置load-on-startup來建立servlet實例，這種實例在Web 應用啓動時，當即建立Servlet 實例 linux
Servlet 的運行都遵循以下生命週期：
1）. 建立 Servlet 實例。
2）. Web 容器調用 Servlet 的 init() 方法，對Servlet 進行初始化。
3）. Servlet 初始化後，將一直存在於容器中，用於響應客戶端請求。根據客戶端的請求方式經過Servlet中service()方法去相應的doXXX()方法；
4）. Web 容器銷燬Servlet 時，調用 Servlet 的 destroy() 方法，一般在關閉Web容器之時銷燬Servlet。
5. 用sql語句分頁：
Mysql數據庫：
查詢第3-5條記錄
select * from stu limit 2,3;
(說明：limit n,m表示區間查詢，N表示從第幾條開始，M表示要返回的記錄條數。第3-5條記錄，是從第二條記錄開如，故N爲2; 3-5之間有3條記錄，因此是從第2要記錄開始，返回3條記錄，返回的正是3-5條記錄。)
Sqlserver數據庫：
SELECT TOP 頁大小 * FROM table1 WHERE id NOT IN (
SELECT TOP 頁大小*(頁數-1) id FROM table1 ORDER BY id
) ORDER BY id
select top 3 * from TDJYXX where recid not in (
select top ((2-1)*3) recid from TDJYXX order by recid
) order by recid
Oracle數據庫：
在ORACLE大數據量下的分頁解決方法。通常用截取ID方法，還有是三層嵌套方法。
截取ID的方法
select * from emp a, (select empno,rownum as num from emp)b where a.empno=b.empno and b.num between 5 and 7;
三層嵌套
SELECT * FROM ( SELECT A.*, rownum r FROM ( SELECT * FROM emp ) A WHERE rownum <=7 ) B WHERE r >5）;
6. list.map.set的存儲特色?
List 以特定次序來持有元素,可有重複元素.
Set 沒法擁有重複元素,內部排序.
Map 保存key-value值,value可多值
7. final,finally,finaliz的區別
final—修飾符（關鍵字）
若是一個類被聲明爲final，意味着它不能再派生出新的子類，不能做爲父類被繼承。所以一個類不能既被聲明爲 abstract的，又被聲明爲final的。
將變量或方法聲明爲final，能夠保證它們在使用中不被改變。被聲明爲final的變量必須在聲明時給定初值，而在之後的引用中只能讀取，不可修改 ，被聲明爲final的方法也一樣只能使用，不能重載。
finally—再異常處理時提供 finally 塊來執行任何清除操做。若是拋出一個異常，那麼相匹配的 catch 子句就會執行，而後控制就會進入 finally 塊（若是有的話）。
finalize—方法名。Java 技術容許使用 finalize() 方法在垃圾收集器將對象從內存中清除出去以前作必要的清理工做。這個方法是由垃圾收集器在肯定這個對象沒有被引用時對這個對象調用的。它是在 Object 類中定義的，所以全部的類都繼承了它。子類覆蓋 ；finalize() 方法以整理系統資源或者執行其餘清理工做 finalize() 方法是在垃圾收集器刪除對象以前對這個對象調用的。
8. arraylist和vector的區別?
1).同步性:Vector是線程安全的，也就是說是同步的，而ArrayList是線程不安全的，不是同步的
2).數據增加:當須要增加時,Vector默認增加爲原來一培，而ArrayList倒是原來的一半
9. 說出ArrayList,Vector, LinkedList的存儲性能和特性？
1）. ArrayList 採用的是數組形式來保存對象的，這種方式將對象放在連續的位置中，因此最大的缺點就是插入刪除時很是麻煩 LinkedList 採用的將對象存放在獨立的空間中，並且在每一個空間中還保存下一個連接的索引 可是缺點就是查找很是麻煩 要叢第一個索引開始
2）. ArrayList和Vector都是用數組方式存儲數據,此數組元素數要大於實際的存儲空間以便進行元素增長和插入操做,他們都容許直接用序號索引元素,可是插入數據元素涉及到元素移動等內存操做,因此查詢數據快而插入數據慢.
3）. Vector使用了sychronized方法(線程安全),因此在性能上比ArrayList要差些.
4）. LinkedList使用雙向鏈表方式存儲數據,按序號索引數據須要前向或後向遍歷數據，因此查詢數據慢,是插入數據時只須要記錄先後項便可,因此插入的速度快.
10. HASHMAP,HASHTABLE區別
1.Hashtable是Dictionary的子類，HashMap是Map接口的一個實現類；
2.Hashtable中的方法是同步的，而HashMap中的方法在缺省狀況下是非同步的。
3.在HashMap中，null能夠做爲鍵，這樣的鍵只有一個；能夠有一個或多個鍵所對應的值爲null。
11. .描述Cookie和Session的做用，區別和各自的應用範圍，Session工做原理
Session用於保存每一個用戶的專用信息. 每一個客戶端用戶訪問時，服務器都爲每一個用戶分配一個惟一的會話ID（Session ID) . 她的生存期是用戶持續請求時間再加上一段時間(通常是20分鐘左右).Session中的信息保存在Web服務器內容中,保存的數據量可大可小.當 Session超時或被關閉時將自動釋放保存的數據信息.因爲用戶中止使用應用程序後它仍然在內存中保持一段時間,所以使用Session對象使保存用戶數據的方法效率很低.對於小量的數據,使用Session對象保存仍是一個不錯的選擇
Cookie 用於保存客戶瀏覽器請求服務器頁面的請求信息,程序員也能夠用它存放非敏感性的用戶信息，信息保存的時間能夠根據須要設置.若是沒有設置Cookie失效日期,它們僅保存到關閉瀏覽器程序爲止.若是將Cookie對象的Expires屬性設置爲Minvalue,則表示Cookie永遠不會過時.Cookie存儲的數據量很受限制,大多數瀏覽器支持最大容量爲4K,所以不要用來保存數據集及其餘大量數據.因爲並不是全部的瀏覽器都支持Cookie,而且數據信息是以明文文本的形式保存在客戶端的計算機中,所以最好不要保存敏感的,未加密的數據,不然會影響網站的安全性
session工做原理
(1)當有Session啓動時，服務器生成一個惟一值，稱爲Session ID（好像是經過取進程ID的方式取得的）。
(2)而後，服務器開闢一塊內存，對應於該Session ID。
(3)服務器再將該Session ID寫入瀏覽器的cookie。
(4)服務器內有一進程，監視全部Session的活動情況，若是有Session超時或是主動關閉，服務器就釋放改內存塊。
(5)當瀏覽器連入IIS時並請求的ASP內用到Session時，IIS就讀瀏覽器Cookie中的Session ID。
(6)而後，服務檢查該Session ID所對應的內存是否有效。
(7)若是有效，就讀出內存中的值。
(8)若是無效，就創建新的Session。
12. String和stringbuffer進行字符串鏈接時的區別？
String對項內容是不可改變的，StringBuffer是能夠改變的，且高效；
13. 什麼叫項目？
用有限的資源、有限的時間爲特定客戶完成特定目標的一次性工做
14. .J2EE J是什麼意思？ 2是什麼意思 EE是什麼意思？ Struts的攔截器你是怎麼作的，是獨立開發的，可以獨立開發的到。而後問有哪幾種攔截？
Java 2 Platform，Enterprise Edition
繼承AbstractInterceptor類，覆蓋intercept()方法
有struts本身的攔截器 如timer ,i18n,scop,servletconfig,token
還有自定義攔截器
15. 簡單介紹下java？Spring的AOP，IOC的講述 對struts2的瞭解，1，2的比較 xml的瞭解 J2ee的webserviced的協議？
Spring AOP:代理機制 Spring提供的自動代理機制
Spring的IoC來實組件之間的依賴關係注入, 使控制層與業務實現分離，即客戶經過
調用業務委託接口來調用具體的業務組件的實例，避免控制層與業務層的藕合帶來的維護
或升級困難。由Spring爲DAO生成代理對象來爲DAO添加事務服務，由IoC容器DAO的代理實例注入到業務組件中,業務組件經過DAO的委託接口調用DAO對象，使得上層組件不直接依賴於DAO的實現類，使得持久層更換或修改不影響上層組件。
16. Collections,collection的區別
Collection是個java.util下的接口，它是各類集合結構的父接口。Collections是個java.util下的普通類，它包含有各類有關集合操做的靜態方法。Collections是針對集合類的一個幫助類，它提供一系列的靜態方法實現對各類集合的搜索，排序，線程安全化等操做
17. 如何釋放過分使用的undo表空間
1. 啓動SQLPLUS，並用sys登錄到數據庫。 2. 查找數據庫的UNDO表空間名3. 確認UNDO表空間；SQL> select name from v$tablespace; 4. 檢查數據庫UNDO表空間佔用空間狀況以及數據文件存放位置； 5. 查看回滾段的使用狀況，哪一個用戶正在使用回滾段的資源，若是有用戶最好更換時間 6. 檢查UNDO Segment狀態
18. 數據庫裏面遊標，索引是怎麼用的？ 在oracle數據庫中，用get 和load方法 這2個方法來查沒有的數據 那麼分別會反饋什麼樣的結果？
declare cur cursor keyset for
get返回null,load classnotfoundException
19. .在Oracle中數據庫中的一個表中，這個表沒有主鍵id也沒有特定標示來查數據，怎麼查？
rowid
20. 簡述private、proteced、public、internal修飾符的訪問權限
同一個類 同一個包 不一樣包的子類 不一樣包非子類
private *
default * *
protected * * *
public * * * *
21. 概述反射和序列化
Reflection 是Java被視爲動態（或準動態）語言的一個關鍵性質。這個機制容許程序在運行時透過Reflection APIs取得任何一個已知名稱的class的內部信息，包括其modifiers（諸如public, static 等等）、superclass（例如Object）、實現之interfaces（例如Cloneable），也包括fields和methods的全部信息，並可於運行時改變fields內容或喚起methods。本文藉由實例，大面積示範Reflection APIs。
22. 序列化就是一種用來處理對象流的機制，所謂對象流也就是將對象的內容進行流化。能夠對流化後的對象進行讀寫操做，也可將流化後的對象傳輸於網絡之間。序列化是爲了解決在對對象流進行讀寫操做時所引起的問題。
序列化的實現：將須要被序列化的類實現Serializable接口，該接口沒有須要實現的方法，implements Serializable只是爲了標註該對象是可被序列化的，而後使用一個輸出流(如：FileOutputStream)來構造一個 ObjectOutputStream(對象流)對象，接着，使用ObjectOutputStream對象的writeObject(Object obj)方法就能夠將參數爲obj的對象寫出(即保存其狀態)，要恢復的話則用輸入流
23. ORACLE中not和and和or優先級由高到低？
not and or
24. java 是如何進行異常處理的
Java經過面向對象的方法進行異常處理，把各類不一樣的異常進行分類，並提供了良好的接口。在Java中，每一個異常都是一個對象，它是Throwable類或其它子類的實例。當一個方法出現異常後便拋出一個異常對象，該對象中包含有異常信息，調用這個對象的方法能夠捕獲到這個異常並進行處理。Java的異常處理是經過5個關鍵詞來實現的：try、catch、throw、throws和finally。通常狀況下是用try來執行一段程序，若是出現異常，系統會拋出（throws）一個異常，這時候你能夠經過它的類型來捕捉（catch）它，或最後（finally）由缺省處理器來處理
25. struts2 必備包
commons-fileupload-1.2.1.jar
freemarker-2.3.13.jar
ognl-2.6.11.jar
struts2-core-2.1.6.jar
xwork-2.1.2.jar
26. dao 是什麼及做用
dao 是數據訪問對象 DAO負責管理與數據源的鏈接來獲取和儲存其中的數據
27. ibatis 中的#與$的區別
在Ibatis中咱們使用SqlMap進行Sql查詢時須要引用參數，在參數引用中遇到的符號#和$之間的區分爲，#能夠進行與編譯，進行類型匹配，而$不進行數據類型匹配，例如：
select * from table where id = #id# ，其中若是字段id爲字符型，那麼#id#表示的就是'id'類型，若是id爲整型，那麼#id#就是id類型。
select * from table where id = $id$ ，若是字段id爲整型，Sql語句就不會出錯，可是若是字段id爲字符型，那麼Sql語句應該寫成 select * from table where id = '$id$'
28. struts的實現原理
一、客戶端初始化一個指向Servlet容器（例如Tomcat）的請求
二、這個請求通過一系列的過濾器（Filter）（這些過濾器中有一個叫作ActionContextCleanUp的可選過濾器，這個過濾器對於Struts2和其餘框架的集成頗有幫助，例如：SiteMesh Plugin）；
三、接着FilterDispatcher被調用，FilterDispatcher詢問ActionMapper來決定這個請求是否須要調用某個Action；
四、若是ActionMapper決定須要調用某個Action，FilterDispatcher把請求的處理交給ActionProxy；
五、ActionProxy經過Configuration Manager詢問框架的配置文件，找到須要調用的Action類；
六、ActionProxy建立一個ActionInvocation的實例。
七、ActionInvocation實例使用命名模式來調用，在調用Action的過程先後，涉及到相關攔截器（Intercepter）的調用。
八、一旦Action執行完畢，ActionInvocation負責根據struts.xml中的配置找到對應的返回結果。返回結果一般是（但不老是，也多是另外的一個Action鏈）一個須要被表示的JSP或者FreeMarker的模版。在表示的過程當中能夠使用Struts2框架中繼承的標籤。在這個過程當中須要涉及到ActionMapper
29. 簡述spring 的事務傳播行爲和 隔離級別
spring 的事務傳播行爲： Spring在TransactionDefinition接口中規定了7種類型的事務傳播行爲，它們規定了事務方法和事務方法發生嵌套調用時事務如何進行傳播：
PROPAGATION_REQUIRED： (propagation_required)若是當前沒有事務，就新建一個事務，若是已經存在一個事務中，加入到這個事務中。這是最多見的選擇。
PROPAGATION_SUPPORTS：(propagation_supports)支持當前事務，若是當前沒有事務，就以非事務方式執行。
PROPAGATION_MANDATORY：(propagation_mandatory)使用當前的事務，若是當前沒有事務，就拋出異常。
PROPAGATION_REQUIRES_NEW：(propagation_requires_new)新建事務，若是當前存在事務，把當前事務掛起。
PROPAGATION_NOT_SUPPORTED：(propagation_not_supported)以非事務方式執行操做，若是當前存在事務，就把當前事務掛起。
PROPAGATION_NEVER：(propagation_enver)以非事務方式執行，若是當前存在事務，則拋出異常。
PROPAGATION_NESTED：(propagation_ensted)若是當前存在事務，則在嵌套事務內執行。若是當前沒有事務，則執行與PROPAGATION_REQUIRED相似的操做。
Spring 的隔離級別
一、Serializable：最嚴格的級別，事務串行執行，資源消耗最大；
二、REPEATABLE READ：(repeatable read)保證了一個事務不會修改已經由另外一個事務讀取但未提交（回滾）的數據。避免了「髒讀取」和「不可重複讀取」的狀況，可是帶來了更多的性能損失。
三、READ COMMITTED:大多數主流數據庫的默認事務等級，保證了一個事務不會讀到另外一個並行事務已修改但未提交的數據，避免了「髒讀取」。該級別適用於大多數系統。
四、Read Uncommitted：保證了讀取過程當中不會讀取到非法數據。
30. 寫一段把本地文件formfile拷貝到本地文件tofile的程序
public class ChangeJtdToJava {
public static void main(String[] args) {
File dir = new File("f:/jtd");
File[] files = dir.listFiles();
for (File file : files) {
String fileName = file.getName(); // 獲得文件名
int index = fileName.indexOf(".");// .的索引位置
String fileName2 = fileName.substring(0, index); // 不帶後綴名的文件名
String houZui = fileName.substrinxg(index);
if (houZui.equals(".jtd")) {
// "f:/java/" + fileName2 + ".java"
file.renameTo(new File("f:/java/" + fileName2 + ".java"));
}
}
}
}
31. 寫出刪除表中重複記錄的語句 oracle
delete from people
where peopleId in (select peopleId from people group by peopleId having count(peopleId) > 1) and rowid not in (select min(rowid) from people group by
32. java 類實現序列化的方法（二種）？如在collection框架中，要實現什麼樣的接口
java.io.Serializable接口
Collection框架中實現比較要實現Comparable 接口和 Comparator 接口
33. Struts2實現攔截器的原理？
實現原理：Struts2攔截器是在訪問某個Action或Action的某個方法、字段以前或以後實施攔截，而且Struts2攔截器是可插拔的，攔截器是ＡＯＰ的一種實現。當請求struts2的action時，Struts 2會查找配置文件，並根據其配置實例化相對的攔截器對象，而後串成一個列表，最後一個一個地調用列表中的攔截器。
34. sleep()和wait()區別
sleep() 方法：線程主動放棄CPU，使得線程在指定的時間內進入阻塞狀態，不能獲得CPU 時間，指定的時間一過，線程從新進入可執行狀態。典型地，sleep() 被用在等待某個資源就緒的情形：測試發現條件不知足後，讓線程阻塞一段時間後從新測試，直到條件知足爲止。
wait( ) ：與notify()配套使用，wait()使得線程進入阻塞狀態，它有兩種形式，一種容許指定以毫秒爲單位的一段時間做爲參數，另外一種沒有參數，當指定時間參數時對應的 notify() 被調用或者超出指定時間時線程從新進入可執行狀態，後者則必須對應的 notify() 被調用
35. Servlet的生命週期分爲3個階段:? 和CGI的區別？
Servlet的生命週期主要由3個過程組成。
(1)init()方法：服務器初始化servlet。
(2)service()方法：初始化完畢，servlet對象調用該方法響應客戶的請求。
(3)destroy()方法：調用該方法消滅servlet對象。
其中，init()方法只在servlet第一次被請求加載的時候被調用一次，當有客戶再請求servlet服務時，web服務器將啓動一個新的線程，在該線程中，調用service方法響應客戶的請求。
與cgi的區別在於servlet處於服務器進程中，它經過多線程方式運行其service方法，一個實例能夠服務於多個請求，而且其實例通常不會銷燬，而CGI對每一個請求都產生新的進程，服務完成後就銷燬，因此效率上低於servlet。
36. forward與redirect 的區別?有哪些方式實現
1）. <jsp:forward>重定向後url地址欄地址不變仍是原來的地址；而response.sendRedirect()重定向後url地址欄地址顯示的請求後的新地址。
2）. <jsp:forward>重定向的時候能夠保存回話信息，所以能夠使用request來進行參數傳遞，在新頁面能夠使用request.getAttribute ()來獲得參數。而response.sendRedirect()不支持此經過request進行參數傳遞。它惟一的傳值方式爲response.sendRedirect(「example.jsp?aa=123」)，在新的頁面經過request.getParameter(「aa」)來獲得參數值
37. 多線程、同步實現方法？
1）實現線程有兩種方法： 繼承Thread類或者實現Runnable接口
2） 實現同步也有兩種,一種是用同步方法,一種是用同步塊.. 同步方法就是在方法返回類型後面加上synchronized, 好比:
public void synchronized add(){...}
同步塊就是直接寫:synchronized (這裏寫須要同步的對象){...}
38. 集合類有哪些？有哪些方法？
集合類 ArrayList LinkedList HashSet HashMap
方法：add(),remove(),put(),addAll(),removeAll()
39. java中實現多態的機制是什麼
重寫，重載
方法的重寫Overriding和重載Overloading是Java多態性的不一樣表現。
重寫Overriding是父類與子類之間多態性的一種表現，重載Overloading是一個類中多態性的一種表現。若是在子類中定義某方法與其父類有相同的名稱和參數，咱們說該方法被重寫 (Overriding)。子類的對象使用這個方法時，將調用子類中的定義，對它而言，父類中的定義如同被「屏蔽」了。
果在一個類中定義了多個同名的方法，它們或有不一樣的參數個數或有不一樣的參數類型，則稱爲方法的重載(Overloading)。Overloaded的方法是能夠改變返回值的類型。
40. 靜態的多態和動態的多態的區別
靜態的多態: 即爲重載 ；方法名相同，參數個數或類型不相同。(overloading)
動態的多態: 即爲重寫；子類覆蓋父類的方法，將子類的實例傳與父類的引用調用的是子類的方法 實現接口的實例傳與接口的引用調用的實現類的方法。
41. 做用域Public,private,protected.以及不寫時的區別
public整個java程序中均可以訪問
protected在其餘包中不能夠訪問
friendly只有當前包或當前內能夠訪問，其餘都不行
private只有當前內能夠訪問
不寫的話默認是protected
42. extends和implement的不一樣
extends是繼承父類，只要那個類不是聲明爲final或者那個類定義爲abstract的就能繼承，JAVA中不支持多重繼承，可是能夠用接口來實現，這樣就要用到implements，繼承只能繼承一個類，但implements能夠實現多個接口，用逗號分開就好了 好比 class A extends B implements C,D,E
43. join與left join的區別：
inner join(等值鏈接) 只返回兩個表中聯結字段相等的行
left join(左聯接) 返回包括左表中的全部記錄和右表中聯結字段相等的記錄
right join(右聯接) 返回包括右表中的全部記錄和左表中聯結字段相等的記錄
44. DAO設計模式與DELEGATE(delegate)模式
DAO(Data Access Object)模式其實是兩個模式的組合，即Data Accessor 模式和 Active Domain Object 模式，其中 Data Accessor 模式實現了數據訪問和業務邏輯的分離，而Active Domain Object 模式實現了業務數據的對象化封裝，通常咱們將這兩個模式組合使用。
DAO 模式經過對底層數據的封裝，爲業務層提供一個面向對象的接口，使得業務邏輯開發員能夠面向業務中的實體進行編碼。經過引入DAO模式，業務邏輯更加清晰，且富於形象性和描述性，這將爲往後的維護帶來極大的便利。試想，在業務曾經過Customer.getName方法得到客戶姓名，相對於直接經過SQL語句訪問數據庫表並從ResultSet中得到某個字符型字段而言，哪一種方式更加易於業務邏輯的形象化和簡潔化？
Business Delegate起到客戶端業務抽象化的做用。它抽象化，進而隱藏業務服務的實現。使用Business Delegate，能夠下降表示層客戶端和系統的業務服務之間的耦合程度。根據實現策略不一樣，Business Delegate能夠在業務服務API的實現中，保護客戶端不受可能的變更性影響。這樣，在業務服務API或其底層實現變化時，能夠潛在地減小必須修改表示層客戶端代碼的次數。
45. 適配器模式與橋樑模式的區別
適配器模式把一個類的接口變換成客戶端所期待的另外一種接口，從而使本來因接口不匹配而沒法在一塊兒工做的兩個類可以在一塊兒工做。又稱爲轉換器模式、變壓器模式、包裝模式（把已有的一些類包裝起來，使之能有知足須要的接口）。適配器模式的用意是將接口不一樣而功能相同或者相近的兩個接口加以轉換，包括適配器角色補充一些源角色沒有但目標接口須要的方法。就像生活中電器插頭是三相的，而電源插座是兩相的，這時須要一個三相變兩相的轉換器來知足。
好比，在Java I/O庫中使用了適配器模式，象FileInputStream是一個適配器類，其繼承了InputStrem類型，同時持有一個對FileDiscriptor的引用。這是將一個FileDiscriptor對象適配成InputStrem類型的對象形式的適配器模式。StringReader是一個適配器類，其繼承了Reader類型，持有一個對String對象的引用。它將String的接口適配成Reader類型的接口。等等。
橋樑模式的用意是要把實現和它的接口分開，以便它們能夠獨立地變化。橋樑模式並非用來把一個已有的對象接到不相匹配的接口上的。當一個客戶端只知道一個特定的接口，可是又必須與具備不一樣接口的類打交道時，就應該使用橋樑模式。
好比，JDBC驅動器就是一個橋樑模式的應用，使用驅動程序的應用系統就是抽象化角色，而驅動器自己扮演實現化角色。應用系統和JDBC驅動器是相對獨立的。應用系統動態地選擇一個合適的驅動器，而後經過驅動器向數據庫引擎發出指令就能夠訪問數據庫中的數據。
工廠模式
工廠模式：工廠模式是一種常常被使用到的模式，根據工廠模式實現的類能夠根據提供的數據生成一組類中某一個類的實例，一般這一組類有一個公共的抽象父類而且實現了相同的方法，可是這些方法針對不一樣的數據進行了不一樣的操做。首先須要定義一個基類，該類的子類經過不一樣的方法實現了基類中的方法。而後須要定義一個工廠類，工廠類能夠根據條件生成不一樣的子類實例。當獲得子類的實例後，開發人員能夠調用基類中的方法而沒必要考慮到底返回的是哪個子類的實例。
46. 開發中都用到了那些設計模式?用在什麼場合?
每一個模式都描述了一個在咱們的環境中不斷出現的問題，而後描述了該問題的解決方案的核心。經過這種方式，你能夠無數次地使用那些已有的解決方案，無需在重複相同的工做。
(1) MVC模式,在J2EE項目開發中主要用在表示層框架中，很好解決視圖和流程控制。在項目中採用的Struts、WebWork等框架。
(2) DAO模式,在項目開發中主要用在數據層，封裝數據的訪問操做，爲業務層提供數據服務。
(3) IoC模式,在項目開發中業務層有大量對象，他們之間存在依賴關係，能夠使用IoC模式減小他們之間的代碼耦合，提升系統的可擴展性。實際項目中使用的Spring框架來實現業務組件的裝配。
(4) Observer模式，在Servlet的監聽器中應用到了觀察者模式。
(5) singleton單例模式和Factory工廠模式結合使用在項目中無需使用者瞭解過多的細節就可獲取有關的對象實例。好比Hibernate項目中經過SessionFactory來獲取Session。
(6) bridge模式，在項目中使用JDBC驅動訪問數據庫。
47. Hibernate中離線查詢與在線查詢的區別
Criteria 和 DetachedCriteria 的主要區別在於建立的形式不同， Criteria 是在線的，因此它是由 Hibernate Session 進行建立的；而 DetachedCriteria 是離線的，建立時無需 Session，DetachedCriteria 提供了 2 個靜態方法 forClass(Class) 或 forEntityName(Name) 進行DetachedCriteria 實例的建立。
48. C#數據類型有哪些 ？
int 整型 double 雙精度型 string 字符串型 char 字符型 bool 布爾型
49. 抽象類可否被實例化 ？抽象類的做用是什麼？
抽象類通常不能被實例化；
抽象類一般不是由程序員定義的，而是由項目經理或模塊設計人 設計抽象類的緣由一般是爲了規範方法名 抽象類必需要繼承，否則無法用，做爲模塊設計者，能夠把讓底層程序員直接用得方法直接調用，而一些須要讓程序員覆蓋後本身作得方法則定義稱抽象方法
50. ASP.NET頁面傳遞值的方式有哪些
1 經過URL連接地址傳遞 2 經過post方式。 3 經過session 4經過Application
5 經過Server.Transfersend.aspx:
51. 如何定義一個MDI(.NET技術)
定義MDI父窗口應該是設置窗體的MdiParent屬性= true
52. WCF是什麼？
Windows Communication Foundation (WCF) 是由微軟發展的一組數據通訊的應用程序開發接口，它是.NET框架的一部分，由 .NET Framework 3.0 開始引入，與 Windows Presentation Foundation 及 Windows Workflow Foundation 並行爲新一代 Windows 操做系統以及 WinFX 的三個重大應用程序開發類庫
53. 經常使用的包，類，接口，各舉5個。
類String Integer Long File Date
包 java.lang.*;java.io.*;java.util.*;java.swt.*;java.math.*;
接口: Comparable ,Connection,Map,List,Runable,
54. 網上購物系統的類圖，用例圖。
用例圖：
類圖:
55. 給你一個整數類型的數組，按從小到大的順序進行排列！
public static void fun(int [] a,int c){
for(int i=0;i<a.length-1;i++){
for(int j=i;j<a.length-1;j++){
if(a[i]<a[j]){
t=a[i];
a[i]=a[j];
a[j]=t;
}
}
System.out.print(a[i]+" ");
}
}
56. 查詢出M 頁的N行數據(分頁的實現，求第M也的記錄數)
Select top N from table where id not in (select top (M-1)*N id from table )
57. Linkedlist arraylist內部是如何實現的（更深刻的問了LinkedList與ArrayList的區別）
ArrayList的內部實現是基於內部數組Object[]，因此從概念上講，它更像數組，但LinkedList的內部實現是基於一組鏈接的記錄，因此，它更像一個鏈表結構，因此，它們在性能上有很大的差異。
在ArrayList的前面或中間插入數據時，必須將其後的全部數據相應的後移，這樣必然要花費較多時間，因此，當你的操做是在一列數據的後面添加數據而不是在前面或中間，而且須要隨機地訪問其中的元素時，使用ArrayList會提供比較好的性能；
而訪問鏈表中的某個元素時，就必須從鏈表的一端開始沿着鏈接方向一個一個元素地去查找，直到找到所需的元素爲止，因此，當你的操做是在一列數據的前面或中間添加或刪除數據，而且按照順序訪問其中的元素時，就應該使用LinkedList了。
若是在編程中，兩種情形交替出現，這時，能夠考慮使用List這樣的通用接口，而不用關心具體的實現，在具體的情形下，它的性能由具體的實現來保證
58. new ArrayList(10)含義
在內存中連續分配了用來存在Object對象的數組；
59. 面向對象主要內容? 有什麼做用？
就分析設計層面來講，面向對象技術提供了更高級的抽象能力以及更多的方法和工具，如設計模式； 就實現維護層面來講，面向對象技術使代碼重用更容易，且使代碼具備可擴展性，便於軟件的維護和升級更新。
60. 如何移動一個數 使62-63=1成立
62-63=1如何移動 2的6次方等於64 2的6次方-63=1 把2移動到6的左下方
61. 遞歸實現1,1,2,3,5,8,….第30個數是多少？
public static int Foo(int i)
{
if (i <= 0)
return 0;
else if(i > 0 && i <= 2)
return 1;
else return Foo(i -1) + Foo(i - 2);
}
int i=Foo(30);
System.out.println(i);
62. JAVA實現向數據庫添加一列
Connection con = null;
ResultSet rs = null;
Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver");
String url="jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=db_name";
Connection con = DriverManager.getConnection(url,"","");
StateManager sm =con.createStateMent();
String sql = " alter table student add age int ";
rs = sm.excute(sql);
63. 寫出刪除表中重複記錄的語句 oracle
delete from people
where peopleId in (select peopleId from people group by peopleId having count(peopleId) > 1) and rowid not in (select min(rowid) from people p group by p.peopleId );
delete from test where rowid not in (select min(rowid) from test t group by t.tid)
64. 用什麼方法使服務器關閉以後，session所保存的信息不會丟失？
使用cookie
65. 若是頁面沒有<html></html>標籤，會出現什麼錯誤代碼？
沒有什麼變化
66. 抽象類是否能夠沒有抽象方法？爲何？
能夠 在java中用abstract關鍵字來修飾一個類時，這個類叫作抽象類。
抽象類中不必定要包含abstract方法，但一個類中包含了abstract方法，則這個類必須聲明爲abstract類。
67. servlet中的init方法何時被調用？
容器首次建立實例的時候
68. 用4 個0，用你所知道的數學方法計算出24
0的階乘等於1 即 0！＝１那麼４個0就是４了
又4的階乘爲２４ ４！＝２４
69. linux中進程的查看和調度分別用什麼命令？
ps -A 查看 renice top
70. 集合類有哪些？有哪些方法？
集合類 ArrayList LinkedList HashSet HashMap
方法：add(),remove(),put(),addAll(),removeAll()
71. OSI七層模型tcp四層模型是什麼樣的
OSI七層參考模型 ：物理層 、數據鏈路層 、網絡層 、傳輸層、應用層、會話層、表示層
TCP/IP:第一層網絡接口層第二層 第二層??網間層 第三層??傳輸層 第四層??應用層
72. JAVA測試模式(ZZ)：
模式（一） Main 模式
模式（二） toString 模式
模式（三） Equal 模式
模式（四） Internal Tester Class 模式
模式（五） Extern Tester Class 模式
73. 一學生表！有班及id，學號！成績！一求平均成績！二求比平均成績高的學生的全部信息
select id,avg(成績) from table group by id
select * from table where 成績 > (select 成績 from （select id,avg(成績) 成績 from table group by id）as a )
74. jdk的新特性
「JDK1.5」的一個重要主題就是經過新增一些特性來簡化開發，這些特性包括泛型，for-each 循環，自動裝包/拆包，枚舉，可變參數, 靜態導入 。使用這些特性有助於咱們編寫更加清晰，精悍，安全的代碼。
75. j2ee的規範？
SUN公司定義的一個開發分佈式企業級應用的規範。它提供了一個多層次的分佈式應用模型和一系列開發技術規範。多層次分佈式應用模型是指根據功能把應用邏輯分紅多個層次，每一個層次支持相應的服務器和組件，組件在分佈式服務器的組件容器中運行（如Servlet組件在Servlet容器上運行，EJB組件在EJB容器上運行），容器間經過相關的協議進行通信，實現組件間的相互調用 J2EE規範定義瞭如下四個層次。 1.客戶端層(Client Tier) 2.Web層 3.業務層(Business Tier) 4.企業信息系統層
76. ajax的工做原理？
Ajax 基本上就是把 JavaScript 技術和 XMLHttpRequest 對象放在 Web 表單和服務器之間。當用戶填寫表單時，數據發送給一些 JavaScript 代碼而不是 直接發送給服務器。相反，JavaScript 代碼捕獲表單數據並向服務器發送請求。同時用戶屏幕上的表單也不會閃爍、消失或延遲。換句話說，JavaScript 代碼在幕後發送請求，用戶甚至不知道請求的發出。更好的是，請求是異步發送的，就是說 JavaScript 代碼（和用戶）不用等待服務器的響應。所以用戶能夠繼續輸入數據、滾動屏幕和使用應用程 序。
而後，服務器將數據返回 JavaScript 代碼（仍然在 Web 表單中），後者決定如何處理這些數據。它能夠迅速更新表單數據，讓人感受應用程序是當即完成的，表單沒有提交或刷新而用戶獲得了新數據。JavaScript 代碼甚至能夠對收到的數據執行某種計算，再發送另外一個請求，徹底不須要用戶干預！這就是 XMLHttpRequest 的強大之處。它能夠根據須要自行與服務器進行交互，用戶甚至能夠徹底不知道幕後發生的一切。結果就是相似於桌面應用程序的動態、快速響應、高交互性的體驗，可是背後又擁有互聯網的所有強大力量。
77. .Xml特色？
XML是一種可擴展標記語言 (XML) 是 Web 上的數據通用語言。它使開發人員可以將結構化數據，從許多不一樣的應用程序傳遞到桌面，進行本地計算和演示。XML 容許爲特定應用程序建立惟一的數據格式。它仍是在服務器之間傳輸結構化數據的理想格式。
XML主要具備如下幾個特色：
① 簡潔有效
XML是一個精簡的SGML，它將SGML的豐富功能與HTML的易用性結合到Web應用種，它保留了SGML的可擴展功能，這使得XML從根本上有區別於HTML。而且XML種還包括可擴展格式語言XSL（Extensible Style Language）和可擴展連接語言XLL（Extensible Linking Language）使得XML的顯示和解析更加方便快捷。
② 易學易用
XML對SGML進行了精簡，它拋棄了SGML中不經常使用的部分，方便用戶編寫Web頁面同時也給設計人員實現XML瀏覽器下降了困難。
③ 開放的國際化標準
XML是W3C正式批准的，它徹底可用於Web和工具的開發。XML具備標準的名域說明方法，支持文檔對象模型標準、可擴展類型語言標準、可擴展連接語言標準和XML指針語言標準。使用XML能夠在不一樣的計算機系統間交換信息，並且還能夠跨越國界和超越不一樣文化疆界交換信息。
④ 高效可擴充
XML支持複用文檔片段，使用者能夠發明和使用本身的標籤，也能夠與他人共享，可延伸性大。在XML中，可定義一組無限量的標準，能夠有效地進行XML文件的擴充。
78. oracle中除了數據庫備份，還有什麼方法備份？
Oracle數據庫有三種標準的備份方法，它們分別是導出/導入(EXP/IMP)、熱備份和冷備份。導出備份是一種邏輯備份，冷備份和熱備份是物理備份。
79. j2ee的經常使用設計模式
Factory（工廠模式）,Builder（建造模式）fFactory Method（工廠方法模式），Prototype（原始模型模式），Singleton（單例模式），（門面模式），Adapter（適配器模式），Bridge（橋樑模式）
80. 由aaa字符串獲得1000個a寫個程序
StringBuilder sBuilder = new StringBuilder();
for(int i=0;i<333;i++){
sBuilder.Append("aaa");
}
sBuilder.Append("aaa".subString(0,1));
81. servlet與cgi的區別
CGI應用開發比較困難，由於它要求程序員有處理參數傳遞的知識，這不是一種通用的技能。CGI不可移植，爲某一特定平臺編寫的CGI應用只能運行於這一環境中。每個CGI應用存在於一個由客戶端請求激活的進程中，而且在請求被服務後被卸載。這種模式將引發很高的內存、CPU開銷，並且在同一進程中不能服務多個客戶。
Servlet提供了Java應用程序的全部優點——可移植、穩健、易開發。使用Servlet Tag技術，Servlet可以生成嵌於靜態HTML頁面中的動態內容
Servlet對CGI的最主要優點在於一個Servlet被客戶端發送的第一個請求激活，而後它將繼續運行於後臺，等待之後的請求。每一個請求將生成一個新的線程，而不是一個完整的進程。多個客戶可以在同一個進程中同時獲得服務。通常來講，Servlet進程只是在Web Server卸載時被卸載
82. SOCKET中有幾中鏈接方式，區別？
Sockets有兩種主要的操做方式:面向鏈接的和無鏈接的。無鏈接的操做使用數據報協議，無鏈接的操做是快速的和高效的,可是數據安全性不佳. 面向鏈接的操做使用TCP協議.面向鏈接的操做比無鏈接的操做效率更低,可是數據的安全性更高
83. Socket如何獲取本地ip地址？
public InetAddress getLocalAddress()
84. truncate與delete的區別？（delete from table和truncate table tablea的區別！）
truncate是DDL語言.delete是DML語言 DDL語言是自動提交的.命令完成就不可回滾.truncate的速度也比delete要快得多.
詳細說明：
相同點:truncate和不帶where子句的delete, 以及drop都會刪除表內的數據
不一樣點:
1. truncate和 delete只刪除數據不刪除表的結構(定義)
drop語句將刪除表的結構被依賴的約束(constrain),觸發器(trigger),索引(index); 依賴於該表的存儲過程/函數將保留,可是變爲invalid狀態.
2.delete語句是dml,這個操做會放到rollback segement中,事務提交以後才生效;若是有相應的trigger,執行的時候將被觸發.
truncate,drop是ddl, 操做當即生效,原數據不放到rollback segment中,不能回滾. 操做不觸發trigger.
3.delete語句不影響表所佔用的extent, 高水線(high watermark)保持原位置不動
顯然drop語句將表所佔用的空間所有釋放
truncate 語句缺省狀況下見空間釋放到 minextents個 extent,除非使用reuse storage; truncate會將高水線復位(回到最開始).
4.速度,通常來講: drop> truncate > delete
5.安全性:當心使用drop 和truncate,尤爲沒有備份的時候.不然哭都來不及
使用上,想刪除部分數據行用delete,注意帶上where子句. 回滾段要足夠大.
想刪除表,固然用drop
想保留表而將全部數據刪除. 若是和事務無關,用truncate便可. 若是和事務有關,或者想觸發trigger,仍是用delete.
************************************************************************************************
85. xml有哪些解析技術，及區別？
有DOM,SAX,STAX等
DOM:處理大型文件時其性能降低的很是厲害。這個問題是由DOM的樹結構所形成的，這種結構佔用的內存較多，並且DOM必須在解析文件以前把整個文檔裝入內存,適合對XML的隨機訪問SAX:不現於DOM,SAX是事件驅動型的XML解析方式。它順序讀取XML文件，不須要一次所有裝載整個文件。當遇到像文件開頭，文檔結束，或者標籤開頭與標籤結束時，它會觸發一個事件，用戶經過在其回調事件中寫入處理代碼來處理XML文件，適合對XML的順序訪問
86. 文件和目錄(i/o)操做，怎麼列出某目錄下全部文件？某目錄下全部子目錄，怎麼判斷文件或目錄是否存在？如何讀寫文件？
列出某目錄下全部文件：調用listFile()，而後判斷每一個File對象是不是文件能夠調用 isFile（），判斷是不是文件夾能夠調用isDirectory（），判斷文件或目錄是否存在：調用exists() 方法，讀寫文件使用FileReader和FileWriter兩個類便可
87. 怎麼用java反射獲得一個類的私有方法？
package test;
public class TestClass {
private String testMethod(String value){
return "test:"+value;
}
}
| try { //獲得test.TestClass類 Class c=Class.forName("test.TestClass"); //獲得testMethod的方法 Method m=c.getDeclaredMethod("testMethod", new Class[]{String.class}); //打印完整的方法表示字符串 System.out.println(m.toGenericString()); //調用這個方法 Object obj=m.invoke(c.newInstance(), new Object[]{"method"}); //打印返回結果 System.out.println(obj); } catch (SecurityException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IllegalArgumentException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (ClassNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (NoSuchMethodException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IllegalAccessException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (InvocationTargetException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (InstantiationException e) { // TODO Auto-generated catch block e.printStackTrace(); } |
88. 寫一個單例模式？描述工廠模式和單例優缺點 舉例在什麼狀況下用
| class Single{} public class SingleFactory { private SingleFactory(){}; private static Single single; public static Single getSingle(){ if(single==null){ single=new Single(); } return single; } } |
· 簡單工廠模式可以根據外界給定的信息，決定究竟應該建立哪一個具體類的對象。經過它，外界能夠從直接建立具體產品對 象的尷尬局面中擺脫出來。
· 外界與具體類隔離開來，偶合性低。
· 明確區分了各自的職責和權力，有利於整個軟件體系結構的優化。
缺點：工廠類集中了全部實例的建立邏輯，容易違反GRASPR的高內聚的責任分配原則 雖然簡單工廠模式可以適應必定的變化，可是它所能解決的問題是遠遠有限的。它所能建立的類只能是事先教考慮到的，若是須要添加新的類，則就須要改變工廠類了。（這個問題在工廠方法模式將獲得很好的解決）
應用情景 工廠類負責建立的對象比較少 客戶只知道傳入了工廠類的參數，對於始何建立對象（邏輯）不關心
89. JVM加載class文件原理？
所謂裝載就是尋找一個類或是一個接口的二進制形式並用該二進制形式來構造表明這個類或是這個接口的class對象的過程.
在Java中，類裝載器把一個類裝入Java虛擬機中，要通過三個步驟來完成：裝載、連接和初始化,其中連接又能夠分紅校驗、準備、解析
裝載：查找和導入類或接口的二進制數據；
連接：執行下面的校驗、準備和解析步驟，其中解析步驟是能夠選擇的；
校驗：檢查導入類或接口的二進制數據的正確性；
準備：給類的靜態變量分配並初始化存儲空間；
解析：將符號引用轉成直接引用；
初始化：激活類的靜態變量的初始化Java代碼和靜態Java代碼塊
JVM中類的裝載是由ClassLoader和它的子類來實現的,Java ClassLoader 是一個重要的Java運行時系統組件。它負責在運行時查找和裝入類文件的類
一個Java應用程序使用兩種類型的類裝載器：根裝載器(bootstrap)和用戶定義的裝載器(user-defined)。
根裝載器以某種默認的方式將類裝入，包括那些Java API的類。在運行期間一個Java程序能安裝用戶本身定義的類裝載器。根裝載器是虛擬機固有的一部分，而用戶定義的類裝載器則不是，它是用Java語言寫的，被編譯成class文件以後而後再被裝入到虛擬機，並像其它的任何對象同樣能夠被實例化。 Java類裝載器的體系結構以下所示：
Bootstrap(根裝載器)
|
Extension (擴展裝載器)
|
System
|
UserDefine1
/ \
UserDefine2 UserDefine3
|
UserDefine4
Java的類裝載模型是一種代理(delegation)模型。當JVM 要求類裝載器CL(ClassLoader)裝載一個類時,CL首先將這個類裝載請求轉發給他的父裝載器。只有當父裝載器沒有裝載並沒有法裝載這個類時,CL纔得到裝載這個類的機會。這樣, 全部類裝載器的代理關係構成了一種樹狀的關係。樹的根是類的根裝載器(bootstrap ClassLoader) , 在JVM 中它以"null"表示。除根裝載器之外的類裝載器有且僅有一個父裝載器。在建立一個裝載器時, 若是沒有顯式地給出父裝載器, 那麼JVM將默認系統裝載器爲其父裝載器
下面針對各類類裝載器分別進行詳細的說明：
根(Bootstrap) 裝載器:該裝載器沒有父裝載器，它是JVM實現的一部分，從sun.boot.class.path裝載運行時庫的核心代碼。
擴展(Extension) 裝載器:繼承的父裝載器爲根裝載器，不像根裝載器可能與運行時的操做系統有關，這個類裝載器是用純Java代碼實現的，它從java.ext.dirs (擴展目錄)中裝載代碼。
系統(System or Application) 裝載器:裝載器爲擴展裝載器，咱們都知道在安裝JDK的時候要設置環境變量(CLASSPATH )，這個類裝載器就是從java.class.path(CLASSPATH 環境變量)中裝載代碼的，它也是用純Java代碼實現的，同時仍是用戶自定義類裝載器的缺省父裝載器。
小應用程序(Applet) 裝載器: 裝載器爲系統裝載器，它從用戶指定的網絡上的特定目錄裝載小應用程序代碼。
90. Tomcat的class加載的優先順序一覽
1.最早是$JAVA_HOME/jre/lib/ext/下的jar文件。
2.環境變量CLASSPATH中的jar和class文
3.$CATALINA_HOME/common/classes下的class
4.$CATALINA_HOME/commons/endorsed下的jar文件。
5.$CATALINA_HOME/commons/i18n下的jar文件。
6.$CATALINA_HOME/common/lib 下的jar文件。
（JDBC驅動之類的jar文件能夠放在這裏，這樣就能夠避免在server.xml配置好數據源卻出現找不到JDBC Driver的狀況。）
7.$CATALINA_HOME/server/classes下的class文件。
8.$CATALINA_HOME/server/lib/下的jar文件。
9.$CATALINA_BASE/shared/classes 下的class文件。
10.$CATALINA_BASE/shared/lib下的jar文件。
11.各自具體的webapp /WEB-INF/classes下的class文件。
12.各自具體的webapp /WEB-INF/lib下的jar文件。
91. CS與BS聯繫區別
1）java適合開發bs結構，cs不是它的強項 C/S 服務器一般採用高性能的PC、工做站或小型機，並採用大型數據庫系統，如Oracle、Sybase、Informix或 SQL Server。客戶端須要安裝專用的客戶端軟件。B/S 客戶機上只要安裝一個瀏覽器（Browser），如Internet Explorer，服務器安裝Oracle、Sybase、Informix或 SQL Server等數據庫。在這種結構下，用戶界面徹底經過WWW瀏覽器實現，一部分事務邏輯在前端實現，可是主要事務邏輯在服務器端實現。瀏覽器經過Web Server 同數據庫進行數據交互 1．硬件環境不一樣: C/S 通常創建在專用的網絡上, 小範圍裏的網絡環境, 局域網之間再經過專門服務器提供鏈接和數據交換服務. B/S 創建在廣域網之上的
2）對安全要求不一樣 C/S 通常面向相對固定的用戶羣, 對信息安全的控制能力很強. 通常高度機密的信息系統採用C/S 結構適宜. 能夠經過B/S發佈部分可公開信息. B/S 創建在廣域網之上, 對安全的控制能力相對弱, 可能面向不可知的用戶
3）對程序架構不一樣 C/S 程序能夠更加註重流程, 能夠對權限多層次校驗 B/S 對安全以及訪問速度的多重的考慮, 創建在須要更加優化的基礎之上
92. Error和 exception的區別與聯繫
error 表示恢復不是不可能,但很困難的狀況下的一種嚴重問題。好比說內存溢,網絡故障等。不可能期望程序能處理的狀況。
exception 表示一種設計或實現問題。也就是說，它表示若是程序運行正常，就不會發生的狀況。程序能夠捕獲到這些異常，並進行處理。
93. 在編寫頁面的會用到哪些技術？
美化頁面須要用到CSS、頁面交互使用JavaScript、動態頁面須要用到JSP、XML等動態網頁技術。
94. 手寫個程序在本頁面中心彈出一個窗體，裏面有學生的成績，能夠修改學生的成績，而且能夠關閉窗口，把每一個要用的jsp頁面顯示出來。（用 JavaScript）
到顯示頁面的ShowStudentServlet
| public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { request.setCharacterEncoding("gbk"); response.setCharacterEncoding("gbk"); response.setContentType("text/html"); StudentDao dao=new StudentDao(); List<Student> sts=dao.stlist(); request.setAttribute("sts", sts); request.getRequestDispatcher("/showStu.jsp").forward(request, response); } |
學生成績的顯示頁面：showStu.jsp
| <table> <tr> <th>學號</th> <th>姓名</th> <th>成績</th> <th>修改</th> </tr> <c:forEach items="${sts}" var="st"> <tr> <td>${st.sid}</td> <td>${st.name}</td> <td>${st.score}</td> <td><button onclick="window.showModalDialog('UpdateStudentServlet?sid=${st.sid }&rand='+Math.random());location.reload();">修改</button></td> </tr> </c:forEach> </table> |
請求修改的UpdateStudentServlet
| public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { request.setCharacterEncoding("gbk"); response.setCharacterEncoding("gbk"); response.setContentType("text/html"); String s=request.getParameter("sid"); if(s!=null&&!s.equals("")){ StudentDao dao=new StudentDao(); Integer sid=Integer.parseInt(s); Student st=dao.findById(sid); request.setAttribute("st", st); request.getRequestDispatcher("/updateStu.jsp").forward(request, response); }else{ throw new ServletException("須要傳遞一個名爲sid的int類型參數"); } } |
能夠修改爲績的頁面:updateStu.jsp
| <base href="<%=basePath%>" target="_self"> <form action="UpdateScoreServlet" method="post"> <table> <tr> <th>編號</th> <td><input type="text" name="sid" value="${st.sid }" readonly="readonly"/></td> </tr> <tr> <th>姓名</th> <td><input type="text" name="name" value="${st.name }" readonly="readonly"/></td> </tr> <tr> <th>分數</th> <td><input type="text" name="score" value="${st.score }"/></td> </tr> <tr> <td colspan="2"><input type="submit" value="修改"/></td> </tr> </table> </form> |
負責修改爲績的UpdateScoreServlet
| public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
request.setCharacterEncoding("gbk"); response.setCharacterEncoding("gbk"); response.setContentType("text/html"); String sid=request.getParameter("sid"); String score=request.getParameter("score"); if(sid!=null&&!sid.equals("")&&score!=null&&!"".equals(score)){ StudentDao dao=new StudentDao(); Student st=new Student(); st.setSid(Integer.parseInt(sid)); st.setScore(Double.parseDouble(score)); dao.update(st); response.getWriter().println("<script type='text/javascript'>alert('修改爲功');window.close();</script>"); } } |
95. 用main涵數輸出一到一百的和。
#include <stdio.h>
int main() {
printf("sum:%d\n", sum());
return 0;
}
int sum() {
int i;
int sum = 0;
for (i = 1; i <= 100; i++)
sum += i;
return sum;
}
96. 查一下每門課程都大於80的學生姓名
學生表student 分數表grade
select s.name from student s where s.id not in(select g.studentid from grade g where g.marks<=80)
或者
select s.name from student s where not exists(select 1 from grade g where g.studentid=s.id and g.marks<=80)
97. LIUNIX如何查看CPU,IP,內存？
cat /proc/cpuinfo 查看CPU
cat /proc/meminfo 查看內存
/sbin/ifcong 查看 IP的
98. j2EE系統訪問速度慢.從哪些方面能夠優化
J2EE性能的優化包括不少方面的，要達到一個性能優良的系統，除了關注代碼以外，還應該根據系統實際的運行狀況，從服務器軟硬件環境、集羣技術、系統構架設計、系統部署環境、數據結構、算法設計等方面綜合考慮
99. J2EE訪問速度慢，怎麼樣優化
1 使用緩衝標記 對於代碼邏輯複雜的頁面，利用緩衝標記提升性能的效果比較明顯；反之，效果可能略遜一籌。
2 始終經過會話Bean訪問實體Bean一些時候，使用實體Bean會致使程序性能不佳。若是實體Bean的唯一用途就是提取和更新數據，改爲在會話Bean以內利用JDBC訪問數據庫能夠獲得更好的性能
3 選擇合適的引用機制
4 在部署描述器中設置只讀屬性 實體Bean的部署描述器容許把全部get方法設置成「只讀」。當某個事務單元的工做只包含執行讀取操做的方法時，設置只讀屬性有利於提升性能，由於容器沒必要再執行存儲操做
5 緩衝對EJB Home的訪問
100. haShtable的原理
原理:經過節點的關鍵碼肯定節點的存儲位置,即給定節點的關鍵碼k,經過必定的函數關係H(散列函數),獲得函數值H(k),將此值解釋爲該節點的存儲地址
101. struts中的prepare怎麼用？
prepare是在validate攔截器以前執行
<s:checkboxlist list="users" listKey="id" listValue="name" name="userid"></s:checkboxlist>
在使用struts2 checkboxlist,select綁定list時，有時候會出現 如下異常
The requested list key 'users' could not be resolved as a collection/array/map/enumeration/iterator type. Example: people or people.{name} - [unknown location]這樣的錯誤。是由於list的值爲空
解決辦法是把初始化list的工做放到prepare攔截器中
public class RoleAction extends ActionSupport implements Preparable{
@Override
public void prepare() throws Exception {
//初始化list
} }
102. C#題目conetextmenu控件如何使用.. listview
ContextMenu 組件提供與選定對象相關的經常使用命令的菜單。能夠經過向 MenuItems 集合中添加 MenuItem 對象來向快捷菜單中添加項。能夠從快捷菜單中永久地移除項；可是在運行時隱藏或禁用項可能更爲穩當。 ListView的ContextMenu屬性設置爲ContextMenu對象
103. 寫一條SQL語句，查詢姓張學生中平均成績大於75的學生信息
select * from student where name in (select name from student
where name like '張%' group by name having avg(score) > 75)
104. 從如下方面比較strut1和strut2:線程模式、依賴、可測性、表達式語言、捕獲輸入、綁釘值到頁面、類型轉換
線程模式: Struts1 Action是單例模式而且必須是線程安全的，由於僅有Action的一個實例來處理全部的請求。單例策略限制了Struts1 Action能做的事，而且要在開發時特別當心。Action資源必須是線程安全的或同步的。
• Struts2 Action對象爲每個請求產生一個實例，所以沒有線程安全問題。（實際上，servlet容器給每一個請求產生許多可丟棄的對象，而且不會致使性能和垃圾回收問題）
Servlet 依賴:
• Struts1 Action 依賴於Servlet API ,由於當一個Action被調用時HttpServletRequest 和 HttpServletResponse 被傳遞給execute方法。
• Struts 2 Action不依賴於容器，容許Action脫離容器單獨被測試。若是須要，Struts2 Action仍然能夠訪問初始的request和response。可是，其餘的元素減小或者消除了直接訪問HttpServetRequest 和 HttpServletResponse的必要性。
可測性:
• 測試Struts1 Action的一個主要問題是execute方法暴露了servlet API（這使得測試要依賴於容器）。一個第三方擴展－－Struts TestCase－－提供了一套Struts1的模擬對象（來進行測試）。
• Struts 2 Action能夠經過初始化、設置屬性、調用方法來測試，「依賴注入」支持也使測試更容易。
捕獲輸入:
• Struts1 使用ActionForm對象捕獲輸入。全部的ActionForm必須繼承一個基類。由於其餘JavaBean不能用做ActionForm，開發者經 常建立多餘的類捕獲輸入。動態Bean（DynaBeans）能夠做爲建立傳統ActionForm的選擇，可是，開發者多是在從新描述(建立)已經存 在的JavaBean（仍然會致使有冗餘的javabean）。
• Struts 2直接使用Action屬性做爲輸入屬性，消除了對第二個輸入對象的需求。輸入屬性多是有本身(子)屬性的rich對象類型。Action屬性可以經過 web頁面上的taglibs訪問。Struts2也支持ActionForm模式。rich對象類型，包括業務對象，可以用做輸入/輸出對象。這種 ModelDriven 特性簡化了taglib對POJO輸入對象的引用。
表達式語言：
• Struts1 整合了JSTL，所以使用JSTL EL。這種EL有基本對象圖遍歷，可是對集合和索引屬性的支持很弱。
• Struts2能夠使用JSTL，可是也支持一個更強大和靈活的表達式語言－－"Object Graph Notation Language" (OGNL).
綁定值到頁面（view）:
• Struts 1使用標準JSP機制把對象綁定到頁面中來訪問。
• Struts 2 使用 "ValueStack"技術，使taglib可以訪問值而不須要把你的頁面（view）和對象綁定起來。ValueStack策略容許經過一系列名稱相同但類型不一樣的屬性重用頁面（view）。
類型轉換：
• Struts 1 ActionForm 屬性一般都是String類型。Struts1使用Commons-Beanutils進行類型轉換。每一個類一個轉換器，對每個實例來講是不可配置的。
• Struts2 使用OGNL進行類型轉換。提供基本和經常使用對象的轉換器。
105. struts的工做原理可分爲以下8步。
1.讀取配置（初始化ModuleConfig對象）
Struts框架總控制器（ActionServlet）是一個Servlet，在web.xml中被配置成一個自動啓動的Servlet。讀取配置文件struts-config.xml的配置信息，爲不一樣的Struts模塊初始化相應的ModuleConfig對象。
2.用戶請求
用戶提交表單或調用URL向WEB應用程序服務器提交一個請求，請求的數據用HTTP協議上傳給WEB服務器。
3.填充FormBean
（*.do請求）從ActionConfig中找出對應該請求的Action子類，若有對應的Action且這個Action又一個相應的ActionForm，ActionForm被實例化並用HTTP請求的數據填充其屬性，並保存在ServletContext中，這樣他們就能夠被其它Action對象或JSP調用。若是沒有對應的Action，控制器則直接轉發給JSP或靜態頁面。
4.派發請求
控制器根據配置信息ActionConfig將請求派發到具體的Action，相應的FormBean一併傳給這個Action的execute()方法。
5.處理業務
Action通常只包含一個execute方法，它負責執行相應的業務邏輯。執行完畢後返回一個ActionFoward對象，控制器經過該ActionFoward對象來進行轉發工做。
6.返回響應
Action根據業務處理的不一樣結果返回一個響應對象給總控制器，該目標響應對相對應一個具體的JSP頁面或另外一個Action。
7.查找響應
總控制器根據業務功能Action返回的目標響應對象找到對應的資源對象，一般是一個具體的JSP頁面。
8.響應用戶
JSP將結果展示給用戶。
106. Spring工做原理
內部最核心的就是IOC了，動態注入，讓一個對象的建立不用new了，能夠自動的生產，這其實就是利用java裏的反射,反射其實就是在運行時動態的去建立、調用對象，Spring就是在運行時，跟xml Spring的配置文件來動態的建立對象，和調用對象裏的方法的 還有一個核心就是AOP這個就是面向切面編程，能夠爲某一類對象 進行監督和控制（也就是在調用這類對象的具體方法的先後去調用你指定的 模塊）從而達到對一個模塊擴充的功能。這些都是經過配置類達到的
Spring目的：就是讓對象與對象（模塊與模塊）之間的關係沒有經過代碼來關聯，都是經過配置類說明 管理的（Spring根據這些配置 內部經過反射去動態的組裝對象）要記住：Spring是一個容器，凡是在容器裏的對象纔會有Spring所提供的這些服務和功能
107. Hibernate 的初始化.
讀取Hibernate 的配置信息-〉建立Session Factory
1)建立Configeration類的實例。
它的構造方法：將配置信息(Hibernate config.xml)讀入到內存。
一個Configeration 實例表明Hibernate 全部Java類到Sql數據庫映射的集合。
2)建立SessionFactory實例
把Configeration 對象中的全部配置信息拷貝到SessionFactory的緩存中。
SessionFactory的實例表明一個數據庫存儲員源，建立後再也不與Configeration 對象關聯。
緩存(cache):指Java對象的屬性(一般是一些集合類型的屬性－－佔用內存空間。
108. 在main方法中將字符串中的。數字排序並輸出 STRING A="56.89.5.3.75.98.98.26.15.44"
String s=」 56.89.5.3.75.98.98.26.15.44」;
String s1[]=s. split (「.」);
Integer ii[]=new Integer[s1.length];
For(int i=0;i<s1.length;i++){
ii[i]=Integer.parseInt(s1[i]);
}
Arrays.sort(ii);
for(Integer o: ii){
System.out.println(o+」 s」);
}
96Oracle冷備份的一般步驟
1 正常關閉數據庫 2 備份全部重要的文件到備份目錄（數據文件、控制文件、重作日誌文件等）
3 完成備份後啓動數據庫用冷備份進行恢復時，只須要將全部文件恢復到原有位置，就能夠啓動數據庫了
4 關閉數據庫 SQL>shutdown 5 備份文件到備份的目錄 6 而後啓動數據庫 ＃sqlplus "/as sysdba"SQL>startup 冷備份完畢！！
109. servlet 建立過程以及ruquest，response，session的生命週期？
Servlet的建立過程：
第一步
public class AAA extends HttpServlet{
實現對應的doxxx方法
}
第二步:
在web.xml中配置
<servlet>
<servlet-name></servlet-name>
<servlet-class></servlet-class>
</servlet>
<servlet-mapping>
<servlet-name></servlet-name>
<url-pattern></url-pattern>
</servlet-mapping>
servlet的生命週期：
servlet容器建立servlet的一個實例
容器調用該實例的init()方法
若是容器對該servlet有請求，則調用此實例的service()方法
容器在銷燬本實例前調用它的destroy()方法
銷燬並標記該實例以供做爲垃圾收集
一旦請求了一個servlet，就沒有辦法阻止容器執行一個完整的生命週期。
容器在servlet首次被調用時建立它的一個實例，並保持該實例在內存中，讓它對全部的請求進行處理。容器能夠決定在任什麼時候候把這個實例從內存中移走。在典型的模型中，容器爲每一個servlet建立一個單獨的實例，容器並不會每接到一個請求就建立一個新線程，而是使用一個線程池來動態的將線程分配給到來的請求，可是這從servlet的觀點來看，效果和爲每一個請求建立一個新線程的效果相同。
一旦請求提交給容器，容器會自動建立相應的request、response，一旦迴應完畢則request、response自動銷燬。客戶端第一次請求時，容器會創建相應的會話，直到會話超時，會話隨即銷燬。
110. 手寫個單例模式？每一個公司基本都考
public class danli {
private static danli dl;
private danli(){
System.out.println("單例模式");
}
public static danli getconnection()
{
if(dl==null)
{
dl=new danli();
}
return dl;
}
}
111. 解釋一下mvc以及熟悉的mvc框架
答:m表明模型層，v 表明視圖層，c表明控制層，也就是把一個總體分割成不一樣的模塊，各負責本身的功能，分工明確，提升代碼的重用性和方便維護。
在jsp設計模式二中，jsp用來作視圖層，servlet是控制器，dao則處理相關業務成爲模型層。
在struts2.0,其中m是action,c是攔截器，v是jsp.
112. 解釋一下IOC,以及spring的舉例
IOC稱爲控制反轉，也叫依賴注入，ioc是Spring的核心組件，它經過配置文件，將須要建立的對象以池的方式管理，將實例注入到須要的對象中區，是對象依賴於注入而不依賴於實現，解決了各個組件的耦合度，使得項目在後期的維護和擴展上很是方便。 如在ssh框架整合中，咱們將datasource對象注入給sessionFactory，再將sessionFactory注入給dao組件，再將dao組件注入給struts的Action組件，在將action對象注入給struts的攔截器。
113. Oracle和Sqlserver的區別？數據庫裏面的語言符號表示？
a)體系結構：
ORACLE的文件體系結構爲：
數據文件 .DBF (真實數據) / 日誌文件 .RDO / 控制文件 .CTL / 參數文件 .ORA
SQL SERVER的文件體系結構爲：
.MDF (數據字典) / .NDF (數據文件) /.LDF (日誌文件)
b)存儲結構：
ORACLE存儲結構：在ORACLE將存儲單位分爲塊、區、段、表等；塊的大小可設置(OLTP塊和DSS塊)；將連續的塊組成區，可動態分配區(區的分配能夠是等額的也能夠是自增加的)可減小空間分配次數；ORACLEl裏表能夠分爲多個段，段由多個區組成，每一個段可指定分配在哪一個表空間裏(段的類型分爲：數據段、索引段、回滾段、臨時段、CASH段。ORACLE裏還可對錶進行分區，可按照用戶定義的業務規則、條件或規範，物理的分開磁盤上的數據。這樣大大下降了磁盤爭用的可能性。
SQL SERVER 存儲結構：以頁爲最小分配單位，每一個頁爲8K(不可控制，缺少對頁的存儲狀況的分析機制),可將8個連續的頁的組成一個‘擴展’，以進一步減小分配時所耗用的資源。(分配缺少靈活性)，在SQL SERVER裏數據以表的方式存放，而表是存放在數據庫裏。真實數據與數據字典存放在一塊兒。對系統參數信息無安全機制。
c)操做系統：
Oracle可在全部主流平臺上運行；但SQL Sever只在Window平臺上的表現很好；
d)運行速度與安全性：Oracle高於SQLServer;
e)價格：Oracle高於SQLServer;
114. 瀏覽器頁面與T0MCat的交互過程？
當一個JSP頁面第一次被訪問的時候，JSP引擎將執行如下步驟：
（1）將JSP頁面翻譯成一個Servlet，這個Servlet是一個java文件，同時也是一個完整的java程序
（2）JSP引擎調用java編譯器對這個Servlet進行編譯，獲得可執行文件class
（3）JSP引擎調用java虛擬機來解釋執行class文件，生成向客戶端發送的應答，而後發送給客戶端
以上三個步驟僅僅在JSP頁面第一次被訪問時纔會執行，之後的訪問速度會由於class文件已經生成而大大提升。當JSP引擎街道一個客戶端的訪問請求時，首先判斷請求的JSP頁面是否比對應的Servlet新，若是新，對應的JSP須要從新編譯。
115. 用C編寫將一個100之內的天然數分解質因數
/* 100之內素數 */
#include<stdio.h>
main()
{
int i,j;
for(i=2;i<100;i++)
{
for(j=2;j<i;j++)
{
if(i%j==0)
break;
}
if(i==j)
{
printf("%d ",i);
}
}
}
/* 分解質因數*/
main()
{
int n,i;
printf( "please input a number:\n ");
scanf( "%d ",&n);
printf( "%d= ",n);
for(i=2;i <=n;i++)
while(n!=i)
{
if(n%i==0)
{
printf( "%d* ",i);
n=n/i;
} else{ break; }
}
printf( "%d ",n);
getch();
}
116. 用一個方法查出宜個數值類型數組的最大值，用遞歸方式實現
方法1
public class Test1 {
public static int a(int[] i,int j){
if(i.length-1>j){
if(i[j]>i[j+1]){
i[j+1]=i[j];
}
return a(i,j+1);
}else{
return i[i.length-1];
}
}
}
方法2 -- 非遞歸
public static int test(int []num) { int x=0; int log = num.Length;for(intt=0;t<log;t++){ if(num[t]>x){ x=num[t]; } }return x;}
方法3 --- 遞歸 不改變原數組中的元素
public static int getMax(int[]a, int index,int max){
int len = a.length;
if(len==1){
return a[len-1];
}
if(index==0){
max = a[index];
}
if(index==len){
return max;
}
if(max<a[index]){
max = a[index];
}
index++;
return getMax(a,index,max);
}
// 測試
int max = getMax(new int[]{2,5,18,3,38,10,2},0,0);
System.out.println(max);
117. JSP與SERVLET區別
JSP在本質上就是SERVLET,可是二者的建立方式不同.Servlet徹底是JAVA程序代碼構成，擅長於流程控制和事務處理，經過Servlet來生成動態網頁很不直觀.JSP由HTML代碼和JSP標籤構成，能夠方便地編寫動態網頁.所以在實際應用中採用Servlet來控制業務流程，而採用JSP來生成動態網頁.在struts框架中，JSP位於MVC設計模式的視圖層，而Servlet位於控制層.JSP是Servlet技術的擴展，本質上就是Servlet的簡易方式。JSP編譯後是「類servlet」。Servlet和JSP最主要的不一樣點在於，Servlet的應用邏輯是在Java文件中，而且徹底從表示層中的HTML裏分離開來。而JSP是Java和HTML組合成一個擴展名爲.jsp的文件。JSP側重於視圖，Servlet主要用於控制邏輯。
118. xmlhttprequest.open()裏面有幾個方法?
XMLHttpRequest.open()
初始化 HTTP 請求參數
語法
open (method, url, async, username, password)
method 參數是用於請求的 HTTP 方法。值包括 GET、POST 和 HEAD。
( 大小寫不敏感 。
POST：用"POST"方式發送數據,能夠大到4MB
GET：用"GET"方式發送數據,只能256KB
若是請求帶有參數的化實用POST方式，POST方式將參數放置在頁面的隱藏控件內
沒有參數使用GET方式
對於請求的頁面在中途可能發生更改的，也最好用POST方式
)
url 參數是請求的主體。大多數瀏覽器實施了一個同源安全策略，而且要求這個 URL 與包含腳本的文本具備相同的主機名和端口。
async 參數指示請求使用應該異步地執行。若是這個參數是 false，請求是同步的，後續對 send() 的調用將阻塞，直到響應徹底接收。
若是這個參數是 true 或省略，請求是異步的，且一般須要一個 onreadystatechange 事件句柄。
username 和 password 參數是可選的，爲 url 所需的受權提供認證資格。若是指定了，它們會覆蓋 url 本身指定的任何資格。
119. java優缺點
先說優勢吧,比較顯見一點
1.指針.
任何一個學過C或者C++的人都知道指針的操做對於他們是很重要的,爲何,指針可以支持內存的直接操做,這樣的直接操做可以帶來的是效率上的提升.可是任何一個東西都是有反作用的,指針給程序員帶了的混亂也是無可比擬的.對於一個不是很強勁的C程序員而言,指針是要命的(對我而言也是,我幾乎不會寫C代碼).而JAVA就爲咱們省去了這樣的麻煩,或者說JAVA完整的限制了對內存的直接操做,讓程序員可以安心去搞業務邏輯,而不用管本身後院的那堆內存有沒有人來收拾.
2.垃圾回收
其實垃圾回收也是JAVA對於內存操做的限制之一,也大大解放了程序員的手腳.可是也正是這樣的一個內存保姆的存在致使JAVA程序員在內存上幾乎沒有概念...一個純粹的JAVA程序員對於內存泄露這樣的問題是歷來沒有概念的,由於他歷來不用擔憂,由於大多數狀況下即使他大手大腳也不會有什麼問題
3.平臺無關性
平臺無關性的真正意義在於程序的可移植性高，可以在多個平臺平滑遷移。這點就特別適合網絡應用。
好吧,而後咱們再來看看缺點吧:
1效率
1.1固然首先就是內存操做限制帶來安全的同時帶來的副面效果了.....
1.2 其次呢,就是面對對象的一個很重要的特色所帶來的——多態致使的。
1.3平臺無關性帶來的。因爲須要平臺無關，因此JAVA是不能直接調用OS的API的，JAVA須要調用本身的API來隱式地調用OS的API，你們可想而知這樣的效果。多一層調用，必然多一層代碼須要加載到棧內了。
2逆向編譯問題
因爲JAVA程序是動態鏈接的，從一個類到另一個類的引用是符號化的。在靜態鏈接的可執行程序中，類之間的只是直接的指針或者偏移量，。相反地，在JAVA class文件中，指向另外一個類的引用經過字符串清楚地標明瞭所指向的類的名字。若是引用指向一個字段的話，這個字段的名字和描述符會被詳細說明。若是引用指向一個成員變量，這個成員變量的名字和描述符（方法的返回類型，方法參數的數量和類型）也會被詳細說明。
3 線程調度問題
Java雖然是一個總進程下的多線程，可是線程間的調度沒有很是的清晰，因爲爲了可以支持多種系統的不一樣的線程支持策略，JAVA只能採起這樣籠統而又鬆散的線程規範。
120. 寫一個單例Signleton代碼
public class Singleton {
private Singleton(){};
private static Singleton singleton;
@SuppressWarnings("unused")
private static Singleton getSingleton(){
if(singleton==null){
singleton=new Singleton();
}
return singleton;
}
}
121. Mvc各部分用什麼實現？
視圖層用jsp，javascript
做用--顯示數據，接受用戶輸入數據
控制層用servlet
做用--接收視圖層數據，傳輸 給業務邏輯層（即模型層）
模型層用普通javaBean
做用--業務類的實現，如：數據庫操做
122. ejb是基於哪些技術實現的，和javabean的區別？
EJB包括Session Bean、Entity Bean、Message Driven Bean，基於JNDI、RMI、JAT等技術實現 EJB是一個關於用JAVA語言開發的可部署的服務器端組件的組件體系結構。它是一個技術協議，能使組件運行於任何應用服務器,專門用來解決商務問題JAVABEANS是JAVA類，是由屬性、事件和方法組成的JAVA組件，它們能夠用來組成JAVA應用程序
123. 適配器模式解釋：
把一個類的接口變換成客戶端所期待的另外一種接口，從而使本來因接口緣由不匹配而沒法一塊兒工做的兩個類 可以一塊兒工做。適配類能夠根據參數返還一個合適的實例給客戶端
124. 進程和線程的區別：
線程是一種操做系統對象，表明着一個進程中要被執行的代碼的路徑。每個WIN32應用程序至少有一個線程--一般稱爲住線程或默認線程--但應用程序能夠自由地建立其餘線程來執行其餘任務！
進程是程序的一次動態執行過程，它對應了從代碼加載、執行到執行完畢的一個完整過程，這個過程也是進程自己從產生、發展到消亡的過程 線程是比進程更小的執行單位。一個進程在其執行過程可以中，能夠產生 多個線程，造成多條執行線索。每條線索，即每一個線程也有它自身的產生、存在和消亡過程，也是一個動態的概念
125.
short s1 = 1; s1 = s1 + 1;有什麼錯? short s1 = 1; s1 += 1;有什麼錯?
short s1 = 1; s1 = s1 + 1; （s1+1運算結果是int型，須要強制轉換類型）
short s1 = 1; s1 += 1;（能夠正確編譯）
126. 寫一個程序,把一個文件的數組按對角線作對稱變換,並輸出!
一個正方形裏面全數字,寫一個程序,成對角線轉變! 我作的這個是3行3列的對角互換，也許轉換規則不同
public class testMain {
public static void main(String[] args) {
int a[][]=new int[3][3];
int c=1;
//初始化數據
for(int i=0;i<3;i++){
for(int j=0;j<3;j++){
a[i][j]=c++;
}
}
System.out.println("轉換以前：");
for(int i=0;i<3;i++){
for(int j=0;j<3;j++){
System.out.print("a["+i+"]["+j+"]="+a[i][j]+" ");
}
System.out.println("\n");
}
for(int i=0;i<3;i++){
for(int j=0;j<3;j++){
if((i+1<3&&j+1<3)&&i==j&&i!=0&&i!=3-i){
int temp=a[i-1][j-1];
a[i-1][j-1]=a[i+1][j+1];
a[i+1][j+1]=temp;
temp=a[i-1][j+1];
a[i-1][j+1]=a[i+1][j-1];
a[i+1][j-1]=temp;
}
}
}
System.out.println("轉換以後：");
for(int i=0;i<3;i++){
for(int j=0;j<3;j++){
System.out
print("a["+i+"]["+j+"]="+a[i][j]+" ");
}
System.out.println("\n");
}
}
}
127. 再SSH框架中，用流程表示處理過程。從Request, Response
128. 人民幣小寫轉成大寫，寫個java程序和思路（寫10100.00轉成漢字壹萬零壹百整）
public class Money {
public static void main(String[] args) {
// 金額大小寫轉換
float money = 2038.0f;
int m1, m2, m3, m4, m5, m6, temp;
temp = (int) (money * 100);
System.out.println(money);
m1 = temp % 1000000 / 100000;
m2 = temp % 100000 / 10000;
m3 = temp % 10000 / 1000;
m4 = temp % 1000 / 100;
m5 = temp % 100 / 10;
m6 = temp % 10;
char c1, c2, c3, c4, c5, c6;
c1 = transe(m1);
c2 = transe(m2);
c3 = transe(m3);
c4 = transe(m4);
c5 = transe(m5);
c6 = transe(m6);
String str = "";
if (m1 != 0) {
str += c1 + "千";
}
if (m2 != 0) {
str += c2 + "百";
}
if (m1 != 0 && m2 == 0 && (m3 != 0 || m4 != 0)) {
str += "零";
}
if (m3 != 0) {
str += c3 + "十";
}
if (m2 != 0 && m3 == 0 && m4 != 0) {
str += "零";
}
if (m4 != 0) {
str += c4;
}
str += "元";
if (m5 == 0 && m6 == 0) {
str += "整";
}
if (m5 != 0) {
str += c5 + "角";
}
if (m5 == 0 && m6 != 0) {
str += "零";
}
if (m6 != 0) {
str += c6 + "分";
}
System.out.print(str + "\n");
System.out.println("..........................");
}
public static char transe(int m) {
char r = ' ';
switch (m) {
case 0:
r = '零';
break;
case 1:
r = '壹';
break;
case 2:
r = '貳';
break;
case 3:
r = '叄';
break;
case 4:
r = '肆';
break;
case 5:
r = '伍';
break;
case 6:
r = '陸';
break;
case 7:
r = '柒';
break;
case 8:
r = '捌';
break;
case 9:
r = '玖';
break;
}
return r;
}
}
129. 針對一個分期付款，總期爲1年，給定分期金額，期數和開始還款時間，計算出各期還款日期。
package demo;
import java.util.Calendar;
import java.util.Date;
public class TestDemo {
// 分期付款，總期爲1年，給定分期金額，期數和開始還款時間
// 計算出各期還款日期
public void huankuan(double amount,int num,Date start){
int period = 365/num; // 一年中分期間隔天數
Calendar cal = Calendar.getInstance();
cal.set(Calendar.YEAR, start.getYear()+1900);
cal.set(Calendar.MONTH, start.getMonth());
cal.set(Calendar.DATE, start.getDate());
for(int i=1;i<=num;i++){
System.out.println(" 第" + i + "期還款日期: " + cal.getTime().toLocaleString());
cal.add(Calendar.DATE, period);
}
}
public static void main(String[] args) {
TestDemo demo = new TestDemo();
demo.huankuan(20000.00, 1, new Date());
}
}
130. 用java寫從1加到100
sum=(1+i)*i/2
i=100
最簡單的方法
public class Hello5050{
public static void main(String[] args){
for (int i=1;i<=100;i=i++)
}
131. SSH的優勢和缺點
優勢： ssh把數據庫，實體，配置都整合，封裝
層次的結構（偏於mvc模式）
並且框架的融合，代碼的耦合都很不錯
對於編程的持續化，擴展化，維護化都很棒 ，SSH已經把底層實現封裝好了，開發人員能夠更專一於業務處理，
缺點： 出現錯誤容易搞的複雜
若是某個框架不是很熟悉的話（特別是spring）那就很麻煩
運行速度比較慢
132. 用JDBC來實現訪問數據庫記錄能夠採用下面的幾個步驟：
一、 經過驅動器管理器獲取鏈接接口。
二、 得到Statement或它的子類。
三、 限制Statement中的參數。
四、 執行Statement。
五、 查看返回的行數是否超出範圍。
六、 關閉Statement。
七、 處理其它的Statement
八、 關閉鏈接接
133. overload和override的區別
override是方法重載，用在同一個類中，是幾個方法的名字相同，返回值相同，可是參數列表不一樣，舉例來講就像構造函數，能夠後多個構造函數，而且每一個的參數列表都不一樣，這樣能夠用多種方式構造對象。
overload是方法覆蓋，用在父子類中，是方法名字相同，參數列表也相同，聲明形式都相同，可是子類方法的權限不容許小於父類，不容許拋出比父類更多的異常
134. 最多見的runtime exception運行時異常？
數字轉換異常，類異常ClassCastException NumberFormatException ArrayIndexOutOfBoundsException:數組越界 ClassCastException:類型轉換錯誤
ArithmeticException：算術錯誤，典型的就是0做爲除數的時候。IllegalArgumentException：非法參數 IndexOutOfBoundsException NullPointerException
SystemException ArrayStoreException
135. 描述工廠模式和單例優缺點 舉例在什麼狀況下用。
單例 保證一個類只有單一的實例，也就是說你沒法經過New或CreateInstance來建立這個類的一個新實例 好處：當一個對象在程序內部只能有一個實例的時候，它能夠保證咱們不會重複建立，而是始終指向同一個對象。 缺點就是 它就是在內存上共享，均可以去訪問它，並且多個用戶訪問的都是同一個實例，會形成線程不安全。
/** *//**
* IOC模式簡單實例
*/
/** *//**
* 運行類
*/
public class MainClass {
/** *//**
* 主函數
*/
public static void main(String[] args) {
try {
PrinterFactory.createPrinter().printByString("Hello World~!");
} catch (Exception ex) {
System.out.println(ex.toString());
}
}
}
/** *//**
* Printer接口
*/
interface IF_Printer {
/** *//**
* 接口printByString方法聲明
*/
public void printByString(String str);
}
/** *//**
* MyPrinter實現Printer接口
*/
class MyPrinter implements IF_Printer {
public void printByString(String str) {
System.out.println(str);
}
}
/** *//**
* IF_Printer對象工廠,用於建立實現接口的類對象
*/
class PrinterFactory {
/** *//**
* 工廠方法,返回IF_Printer接口實例
*/
public static IF_Printer createPrinter() throws InstantiationException,
ClassNotFoundException, IllegalAccessException {
String str = "MyPrinter";//經過字符串尋找實現接口的類,字符串可從文件中讀取得到,從而實現IOC模式
return (IF_Printer) Class.forName(str).newInstance();//返回IF_Printer接口實例
}
}
136. 建立一個序列號,從1000開始,每次增長1,最大到999999
create sequence newstudno increment by 1
start with 10001 maxvalue 99999
137. 設計4個線程，其中兩個線程每次對j增長1，另外兩個線程對j每次減小1。寫出程序。
public class ThreadTest1{
private int j;
public static void main(String args[]){
ThreadTest1 tt=new ThreadTest1();
Inc inc=tt.new Inc(); Dec dec=tt.new Dec();
for(int i=0;i <2;i++){
Thread t=new Thread(inc);
t.start();
t=new Thread(dec); //???這個前面不要加Thread嗎
t.start();
}
}
private synchronized void inc(){ //???爲何要加鎖呢 不加能夠嗎
j++;
System.out.println(Thread.currentThread().getName()+"-inc:"+j);
} //???currentThread()有什麼做用呢是什麼方法
//???getname呢
private synchronized void dec(){
j--;
System.out.println(Thread.currentThread().getName()+"-dec:"+j);
}
class Inc implements Runnable{
public void run(){
for(int i=0;i <100;i++){
inc();
}
}
}
class Dec implements Runnable{
public void run(){
for(int i=0;i <100;i++){
dec(); } } } }
138. 十六進制的216轉換十進制是多少：
216是16進制，轉10進制:
＝2*16^2+1*16^1+6*16^0
=512+16+6
=536
139. Java中的XML解析方式： dom和jdom解析
Java中處理XML文檔的標準API有兩種，即XML的簡單API（SAX，Simple API for XML）和文檔對象模型（DOM， Document Object Model），其餘的API，如JDOM，dom4j等。
基於DOM的XML分析器將一個XML文檔轉換成一個對象模型的集合（一般稱DOM樹），應用程序正是經過對這個對象模型的操做，來實現對XML文檔數據的操做。經過DOM接口，應用程序能夠在任什麼時候候訪問XML文檔中的任何一部分數據。
n 基於樹的處理的優勢和缺點
l 優勢
Ø 樹在內存中是持久的，所以能夠修改它以便應用程序能對數據和結構做出更改
Ø 能夠在任什麼時候候在樹中上下導航，而不是像 SAX 那樣是一次性的處理
Ø DOM API是讀寫的，而不象SAX那樣是隻讀的。
l 缺點
Ø 在內存中構建一個DOM樹開銷比較大
Ø 建立一棵 DOM 樹多是一個緩慢的過程
Ø DOM不象SAX那樣能夠提供不少XML文檔中的信息。好比非分析實體、標記、屬性類型和DTD中的聲明。
SAX是一個基於事件的 API。解析器向一個事件處理程序發送事件，好比元素開始和元素結束，而事件處理器則處理該信息。應用程序自己就可以處理該數據。原始的文檔仍然保留無缺無損
n 優勢：
l 能夠解析任意大小的文件；
l 適合建立本身的數據結構；
l 適合小信息子集；
l 簡單；
l 快速
n 缺點：
l 不能對文檔作隨機存取；
l 難以實現複雜的查詢；
l 不能使用文檔類型定義（DTD）；
l 不可獲取詞法信息；
l SAX是隻讀的；
l 當前的瀏覽器不支持SAX；
JDOM是java document object model的簡稱，JDOM兼顧了DOM和SAX的優勢，它會提供適配器用來選擇具體的XML解析器。JDOM是一個源代碼開發的項目，它基於樹型結構，利用純Java的技術對XML文件實現解析、生成、序列化以及多種操做。在 JDOM 中，XML 元素就是 Element 的實例，XML 屬性就是 Attribute 的實例，XML 文檔自己就是 Document 的實例。所以建立一個新 JDOM 對象就如在 Java 語言中使用 new 操做符同樣容易。JDOM 使用標準的 Java 編碼模式。只要有可能，它使用 Java new 操做符而不故弄玄虛使用複雜的工廠化模式，使對象操做即使對於初學用戶也很方便。
140. UML幾種圖及用途？
單一的圖形不可能包含系統所學的全部信息，更不可能描述系統的總體結構，因此係統一般是從多個不一樣的方面來描述的，分別對應UML的幾種視圖：
§ 用例視圖--從使用者角度描述系統功能
§ 邏輯視圖—描述系統內部如何實現
§ 組件視圖—描述系統有哪些組件/模塊構成
§ 併發視圖—描述系統內部的通訊與併發問題
配置視圖—描述系統軟硬件的配置與位置關係
n 用例圖—描述系統的參與者與用例之間的關係
n 類圖—描述系統中的概念及它們之間的關係
n 對象圖—描述系統中實例及它們之間關係
n 狀態圖—描述系統中對象所具有的狀態，及觸發狀態改變的事件
n 時序圖—描述對象之間發送消息的時間順序
n 協做圖—描述對象之間協做關係
n 活動圖—描述執行過程當中涉及的活動及狀態變化
n 組件圖—描述系統組件之間的關係
配置圖—描述系統的硬件及軟件的物理結構
141. 列舉你接觸過的框架，說明特色和原理
struts框架具備組件的模塊化，靈活性和重用性的優勢，同時簡化了基於MVC的web應用程序的開發，缺點：Taglib是Struts的一大優點，但對於初學者而言，卻須要一個持續學習的過程，甚至還會打亂你網頁編寫的習慣 Struts將MVC的Controller一分爲三，在得到結構更加清晰的同時，也增長了系統的複雜度，工做原理 ：用一個servlet攔截用戶的請求，並分發到具體的action中去處理，再將返回的response進行封裝，這是處理頁面流程的機制，另外還有一些標籤，很是容易在頁面進行顯示。
Hibernate是一個開放源代碼的對象關係映射框架，它對JDBC進行了很是輕量級的對象封裝，使得Java程序員能夠爲所欲爲的使用對象編程思惟來操縱數據庫。 Hibernate能夠應用在任何使用JDBC的場合，既能夠在Java的客戶端程序使用，也能夠在Servlet/JSP的Web應用中使用，最具革命意義的是，Hibernate能夠在應用EJB的J2EE架構中取代CMP，完成數據持久化的重任。
Spring 也表示是一個開源框架，是爲了解決企業應用程序開發複雜性由Rod Johnson建立的。框架的主要優點之一就是其分層架構，分層架構容許您選擇使用哪個組件，同時爲 J2EE 應用程序開發提供集成的框架。Spring使用基本的JavaBean來完成之前只可能由EJB完成的事情。然而，Spring的用途不只限於服務器端的開發。從簡單性、可測試性和鬆耦合的角度而言，任何Java應用均可以從Spring中受益。
142. Struts Hibernate Spring 在程序中用到哪些
典型的J2EE三層結構，分爲表現層、中間層（業務邏輯層）和數據服務層。三層體系將業務規則、數據訪問及合法性校驗等工做放在中間層處理。客戶端不直接與數據庫交互，而是經過組件與中間層創建鏈接，再由中間層與數據庫交互。
表現層是傳統的JSP技術，自1999年問世以來，通過多年的發展，其普遍的應用和穩定的表現，爲其做爲表現層技術打下了堅實的基礎。
中間層採用的是流行的Spring+Hibernate，爲了將控制層與業務邏輯層分離，又細分爲如下幾種。
Web層，就是MVC模式裏面的「C」（controller），負責控制業務邏輯層與表現層的交互，調用業務邏輯層，並將業務數據返回給表現層做組織表現，該系統的MVC框架採用Struts。
Service層（就是業務邏輯層），負責實現業務邏輯。業務邏輯層以DAO層爲基礎，經過對DAO組件的正面模式包裝，完成系統所要求的業務邏輯。
DAO層，負責與持久化對象交互。該層封裝了數據的增、刪、查、改的操做。
PO，持久化對象。經過實體關係映射工具將關係型數據庫的數據映射成對象，很方便地實現以面向對象方式操做數據庫，該系統採用Hibernate做爲ORM框架。
Spring的做用貫穿了整個中間層，將Web層、Service層、DAO層及PO無縫整合，其數據服務層用來存放數據。
一個良好的框架可讓開發人員減輕從新創建解決複雜問題方案的負擔和精力；它能夠被擴展以進行內部的定製化；而且有強大的用戶社區來支持它。框架一般能很好的解決一個問題。然而，你的應用是分層的，可能每個層都須要各自的框架。僅僅解決UI問題並不意味着你可以很好的將業務邏輯和持久性邏輯和UI 組件很好的耦合。
143. 你對面向對象思想的理解？
面向對象(Object Oriented,OO)是當前計算機界關心的重點，它是90年代軟件開發方法的主流。面向對象的概念和應用已超越了程序設計和軟件開發，擴展到很寬的範圍。如數據庫系統、交互式界面、應用結構、應用平臺、分佈式系統、網絡管理結構、CAD技術、人工智能等領域。
面向對象的特徵
(1)對象惟一性。
每一個對象都有自身惟一的標識，經過這種標識，可找到相應的對象。在對象的整個生命期中，它的標識都不改變，不一樣的對象不能有相同的標識。
(2)分類性。
分類性是指將具備一致的數據結構(屬性)和行爲(操做)的對象抽象成類。一個類就是這樣一種抽象，它反映了與應用有關的重要性質，而忽略其餘一些無關內容。任何類的劃分都是主觀的，但必須與具體的應用有關。
(3)繼承性。
繼承性是子類自動共享父類數據結構和方法的機制，這是類之間的一種關係。在定義和實現一個類的時候，能夠在一個已經存在的類的基礎之上來進行，把這個已經存在的類所定義的內容做爲本身的內容，並加入若干新的內容。
繼承性是面向對象程序設計語言不一樣於其它語言的最重要的特色，是其餘語言所沒有的。
在類層次中，子類只繼承一個父類的數據結構和方法，則稱爲單重繼承。
在類層次中，子類繼承了多個父類的數據結構和方法，則稱爲多重繼承。
在軟件開發中，類的繼承性使所創建的軟件具備開放性、可擴充性，這是信息組織與分類的行之有效的方法，它簡化了對象、類的建立工做量，增長了代碼的可重性。
採用繼承性，提供了類的規範的等級結構。經過類的繼承關係，使公共的特性可以共享，提升了軟件的重用性。
(4)多態性(多形性)
多態性使指相同的操做或函數、過程可做用於多種類型的對象上並得到不一樣的結果。不一樣的對象，收到同一消息能夠產生不一樣的結果，這種現象稱爲多態性。
多態性容許每一個對象以適合自身的方式去響應共同的消息。
多態性加強了軟件的靈活性和重用性。
數組和鏈表的理解，及優缺點？
144. 鏈表是一種常見的數據組織形式，它採用動態分配內存的形式實現。須要時能夠用new分配內存空間，不須要時用delete將已分配的空間釋放，不會形成內存空間的浪費。
A 從邏輯結構來看
A-1. 數組必須事先定義固定的長度（元素個數），不能適應數據動態地增減的狀況。當數據增長時，可能超出原先定義的元素個數；當數據減小時，形成內存浪費。
A-2. 鏈表動態地進行存儲分配，能夠適應數據動態地增減的狀況，且能夠方便地插入、刪除數據項。（數組中插入、刪除數據項時，須要移動其它數據項）
B 從內存存儲來看
B-1. (靜態)數組從棧中分配空間, 對於程序員方便快速,可是自由度小
B-2. 鏈表從堆中分配空間, 自由度大可是申請管理比較麻煩.
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
數組中的數據在內存中的按順序存儲的，而鏈表是隨機存儲的！
要訪問數組中的元素能夠按下標索引來訪問，速度比較快，若是對他進行插入操做的話，就得移動不少元素，因此對數組進行插入操做效率很低！
因爲連表是隨機存儲的，鏈表在插入，刪除操做上有很高的效率（相對數組），若是要訪問鏈表中的某個元素的話，那就得從鏈表的頭逐個遍歷，直到找到所須要的元素爲止，因此鏈表的隨機訪問的效率就比數組要低
數組在內存中開闢連續的一塊區域，若是一個數據要兩個內存單元，一組5個數據10個單元就夠了，無需標記其地址，由於數組定義時候標頂了第一個原許的地址，其餘四個都知道了。
鏈表可能夠是連續的，也能夠是不連續的，但通常都是不連續的，儘管在內存中是連續的，咱們也不把他看成是連續的，而是把他看成是不連續的，由於若是把他看成是連續的，不如看成是數組了，在某些狀況下。一鏈5個數據，若是每一個數據自己用2個內存單元，那麼10個單元是不夠的，由於每一個數據都要表示出下個數據在哪裏，因此一個數據自己用2個單元，再用1個單元表示此鏈下一個數據在什麼地址。
145. 寫幾個java.lang.Object類中的方法名稱
equals(); toString(); getClass(); hashCode(); clone() finalize() notify() wait() notify()
146. js中加VAR與不加VAR的區別？
在全局做用域中能夠不使用var聲明變量，但在聲明局部變量時，必定要使用var語句.
加了var:在局部函數中加了var說明是局部變量,只對該函數起做用.
不加var:在局部函數中不加的話,說明是給這個全局變量從新賦值.其結果爲從新賦值後的.
147. Struts 1的Action類與Struts 2的Action類區別？
Struts 1要求Action類要擴展自一個抽象基類。Struts 1的一個共有的問題是面向抽象類編程而不是面向接口編程。
Struts 2的Action類實現了一個Action接口，連同其餘接口一塊兒實現可選擇和自定義的服務。
Struts 1 Action類是單例類，因只有一個示例控制全部的請求。
Struts 2 Action對象每個請求都實例化對象，因此沒有程安全的問題。
148. jsp有哪些的動做？分別有什麼做用？
答： jsp:include：在頁面被請求的時候引入一個文件。
jsp:useBean：尋找或者實例化一個JavaBean。
jsp:setProperty：設置JavaBean的屬性。
jsp:getProperty：輸出某個JavaBean的屬性。
jsp:forward：把請求轉到一個新的頁面。
jsp:plugin：根據瀏覽器類型爲Java插件生成OBJECT或EMBED標記。
149. 用oracle寫向mine表中差入miname字段？
ALTER TABLE MINE ADD MINNAME VARCHAR2(10);
150. oracle有哪幾個對象？
Oracle數據庫對象有表、索引、視圖、同義詞、序列、存儲過程、觸發器、PL/SQL塊等
151. 在oracle中，有4個大對象（lobs）類型可用
分別是blob,clob,bfile,nclob。
152. 定義兩個變量a和b，不使用第三個變量，使兩個值交換
public class testMain {
public void test(int a,int b){
System.out.println("交換前a = "+a);
System.out.println("交換前b = "+b);
a=a+b;
b=a-b;
a=a-b;
System.out.println("交換後a = " +a);
System.out.print("交換後b = "+b);
}
public static void main(String args[]){
new testMain().test(10,13);
}
}
153. 題目：JS樹形菜單
<%@ page language="java" import="java.util.*" pageEncoding="gbk"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<base href="<%=basePath%>">
<title>My JSP 'scriptTree.jsp' starting page</title>
<script type="text/javascript">
function fun1(){
window.showModalDialog("${pageContext.request.contextPath}/user.do?method=login","700");
window.dialogHeight=800;
}
function fun(isd){
var tabIds=document.getElementById(isd);
if(tabIds.style.display=='none'){
tabIds.style.display='inline';
}else{
tabIds.style.display='none';
}
}
</script>
</head>
<body>
<table border="2" borderColor="green" width="75%">
<tr>
<td onclick="fun('tableId1');">樹型菜單</td>
<td>菜單名稱</td>
</tr>
<tr>
<td colspan="2">
<table id="tableId1" border="2" borderColor="red">
<tr style="display:inline">
<td> kongjian </td>
</tr>
<tr style="display:inline">
<td><a href=""> xiaoxin </a> </td>
</tr>
</table>
</td>
</tr>
</table>
</body>
</html>
154. 辦公自動化系統用到的技術，分哪些層，有哪些包
使用技術:DWR + Struts + Hibernate + Spring+Ajax+JavaScript
系統架構分爲: View層、WEB層、Serivce層、DAO層、持久層(po層)
155. 解釋下mvc，客戶端的請求被髮送到哪?
.jsp是v層(視圖層view) Servlet是c層(控制層,Control) Bean Bin都是M層(後臺類,Model)
m層(模型層)
156. 使用了哪些數據庫事務?
BeginTransaction、Commit 和 Rollback
.
157. 對數據庫的訪問是怎麼實現的
將對持久層數據庫的基本添加，修改，查找等操做提取到BaseDAO中,採用JavaBean對數據進行封裝，以便對持久層的數據可以很好的處理，實現BaseDAO設計對數據庫訪問的便捷。業務組件經過DAO 的委託接口調用DAO對象，使得上層組件不 直接依賴於DAO的實現類.
140．接口與抽象類的區別
聲明方法的存在而不去實現它的類被叫作抽象類（abstract class），它用於要建立一個體現某些基本行爲的類，併爲該類聲明方法，但不能在該類中實現該類的狀況。不能建立abstract 類的實例。然而能夠建立一個變量，其類型是一個抽象類，並讓它指向具體子類的一個實例。不能有抽象構造函數或抽象靜態方法。Abstract 類的子類爲它們父類中的全部抽象方法提供實現，不然它們也是抽象類爲。取而代之，在子類中實現該方法。知道其行爲的其它類能夠在類中實現這些方法。
接 口（interface）是抽象類的變體。在接口中，全部方法都是抽象的。多繼承性可經過實現這樣的接口而得到。接口中的全部方法都是抽象的，沒有一個有 程序體。接口只能夠定義static final成員變量。接口的實現與子類類似，除了該實現類不能從接口定義中繼承行爲。當類實現特殊接口時，它定義（即將程序體給予）全部這種接口的方法。 而後，它能夠在實現了該接口的類的任何對象上調用接口的方法。因爲有抽象類，它容許使用接口名做爲引用變量的類型。一般的動態聯編將生效。引用能夠轉換到 接口類型或從接口類型轉換，instanceof 運算符能夠用來決定某對象的類是否實現了接口。
158. 數據庫優化的方案
創建主鍵，爲數據庫建立索引，創建存儲過程，觸發器，可提升查詢速度。
159. 冒泡
public static void Bubble(int a[]){
for(int i=0;i<a.length-1;i++){
for(int j=a.length-1;j>i;j--){
if(a[j]<a[j-1]){
a[j]=a[j]+a[j-1];
a[j-1]=a[j]-a[j-1];
a[j]=a[j]-a[j-1];
}
}
}
}
160. 經常使用的設計模式有哪些？並寫出一段程序代碼
Factory(工廠模式)，Adapter(適配器模式)，Singleton(單例模式)，State(狀態模式)，Observer(觀察者模式) 等。
單例模式
public class Singleton{
private static Singleton instance=null;
private Singleton(){}
public static Singleton getInstance(){
if(instance==null){
instance=new Singleton();
}
return instance;
}
}
161. 數據庫有哪幾種結構？
從數據管理的角度看，數據庫一般採用三級模式結構，這是數據庫管理系統的內部結構；從數據庫最終用戶的角度看，數據庫的結構可分爲集中式結構、分佈式結構、客戶/服務器結構、並型結構，這是數據庫的外部的體系
162. css是什麼？ABSTRACT是什麼意思？（層疊樣式表，抽象）
Css:（層疊樣式表，抽象）
abstract 修飾符能夠用於類、方法、屬性、事件和索引指示器（indexer），表示其爲抽象成員，abstract 不能夠和 static 、virtual 一塊兒使用 聲明爲 abstract 成員能夠不包括實現代碼，但只要類中還有未實現的抽象成員（即抽象類），那麼它的對象就不能被實例化，一般用於強制繼承類必須實現某一成員
163. 你對Oracle有哪些瞭解？ （大型數據庫，安全性高，穩定性高，功能強大，效率低，價格貴，操做麻煩）
164. 你大學所學習的哪些課程？（會哪些JAVA技術？學過 C語言，c++,c#,java）
165. BBS論壇運用了那些技術，若是你單獨開發須要多久，你可以獨立完成整個代碼的編寫嗎？（jsp技術，ajax技術，通訊技術，）
166. 你對博客網有什麼認識（典型的網絡新事物，指網上寫做的一種特定形式和格式。由按時間倒序排列的文檔組成的欄目，兩側一般還能夠有補充材料，頻繁更新，通常大量使用連接）
167. 測試覆蓋最強的是__d______,最弱的是____c___
A.條件覆蓋 B.條件及斷定覆蓋 C.語句覆蓋 D.條件組合覆蓋
168. DFD是面向__c____分析方法的描述工具（DFD數據流程圖）
A.數據結構 B.數據流 C.對象 D.構件
169. 從終端用戶的角度來看,事務是一個__B_____
A.對象 B.原子 C.操做 D.子程序
170. 構造器是否能夠被重寫？ 不能
171. char是否能夠裝一個漢字？ 能夠
172. public class Test {
public static void add(Integer i){
int val=i.intValue();
val+=3;
i=new Integer(val);
}
public static void main(String[] args) {
Integer i=new Integer(0);
add(i);
System.out.println(i.intValue());
}
}
打印的結果是0
173. outmermory是個什麼問題？你是怎麼解決的？
內存溢出 解決方法：手動設置Heap size修改TOMCAT_HOME/bin/catalina.bat
在「echo "Using CATALINA_BASE: $CATALINA_BASE"」上面加入如下行：
JAVA_OPTS="-server -Xms800m -Xmx800m -XX:MaxNewSize=256m"
174. &和&&的區別
&,按位與,是位運算符
&&,與，是邏輯運算符
175. 數組有沒有length()這個方法，String有沒有length()這個方
數組沒有length()方法，但有length屬性
String有length()方法。
176. String s=new String(「xyz」)建立了幾個對象
2個string對象,一個是=null的s，一個是=「xyz」的string
177. 談談struts的整個體系？
Struts的目的是爲了減小在運用MVC設計模型來開發Web應用的時間。你仍然須要學習和應用該架構，不過它將能夠完成其中一些繁重的工做Struts跟Tomcat、Turbine等諸多Apache項目同樣，是開源軟件，這是它的一大優勢，使開發者能更深刻的瞭解其內部實現機制。
除此以外，Struts的優勢主要集中體如今兩個方面：Taglib和頁面導航。Taglib是Struts的標記庫，靈活動用，能大大提升開發效率。另外，就目前國內的JSP開發者而言，除了使用JSP自帶的經常使用標記外，不多開發本身的標記，或許Struts是一個很好的起點。
關於頁面導航，我認爲那將是從此的一個發展方向，事實上，這樣作，使系統的脈絡更加清晰。經過一個配置文件，便可把握整個系統各部分之間的聯繫，這對於後期的維護有着莫大的好處。尤爲是當另外一批開發者接手這個項目時，這種優點體現得更加明顯。
MVC即Model-View-Controller的縮寫，是一種經常使用的設計模式。MVC 減弱了業務邏輯接口和數據接口之間的耦合，以及讓視圖層更富於變化。Struts 是MVC的一種實現，它將 Servlet和 JSP 標記（屬於 J2EE 規範）用做實現的一部分。Struts繼承了MVC的各項特性，並根據J2EE的特色，作了相應的變化與擴展
178. 域名格式要求
英文26個字母和10個阿拉伯數字以及橫槓"－"能夠用做域名。字母的大小寫沒有區別；每一個層次最長不能超過26個字母；首字或結尾字不能是"."和"-"；域名不能包括有空格；中文暫時不能用做域名。
179. AjAX有什麼好處？
用於須要查詢數據庫才能作的頁面校驗,再好比實時刷新,再好比良好的用戶界面以及快速的響應等等 無刷新、減小網絡流量
180. Webservice 有什麼好處?
跨平臺的可互操做性 跨防火牆的通訊 應用程序集成 軟件和數據重用
181. JAVA 的緩衝機制？ BufferdStream
182. 如何在javascript中實現繼續？首先js是單線程的，如今基本除了XHR的callback能夠另開一個線程之外，還沒法實現多線程，其次timeout是在本次js代碼運行完開始計時timeout的，因此在一個耗時的函數以外timeout或者interval一個函數運行自己就是荒謬的，ie下面alert，js函數執行也會阻塞interval執行
183. XMLHTTP的hibernate的save與saveOrUpdate的區別？get與load的區別？
答案: Transient狀態--離線狀態，Persient狀態--持久狀態，Detached狀態--脫管狀態
1.save（）方法，調用save方法時，首先會在session緩存中查找保存對象若是實體對象已經處於Persient狀態，直接返回，否在實行sql操做，並將保存的實體對象加入session緩存（save方法不會把實體加入二級緩存的），最後對存在的級聯關係進行遞歸處理。
2.saveOrUpdate（）方法：和save方法同樣首先在session緩存中查找，判斷對象是否爲爲保存狀態，若是對象處於Persient，不執行操做，處於Transient執行save操做，處於Detached調用save將對象與session從新關聯（簡單的說就是該方法會先看該對象是否已經存在，若是已經存在就更新，不然新增保存）。
3.get與load的區別？load會先從緩存中查詢，若是不存在再到數據庫查詢；而get是直接從數據庫中查詢；load的效率會快點（由於他從緩存中查詢）
184. 鏈接池的原理
j2ee 服務器啓動時會創建必定數量的池鏈接，並一直維持很多於此數量的池鏈接。當客戶端程序須要鏈接時，吃驅動程序會返回一個未使用的池鏈接並將其標記爲忙。若是當前 沒有空閒鏈接，池驅動就創建必定新的 鏈接
185. 用javascript編寫腳本小程序，實現點擊全選（）
function selectAll(){
var item = document.getElementsByName("ids");
for( var j=0;j<item.length;j++){
if(!item[j].disabled){
item[j].checked = true
}
}
}
<input type="checkbox" name="ids" value="${N.oid}">
<input type=button value="全選" onclick="selectAll()">
186. 說一下垃圾回收的原理，能夠直接從內存中回收嗎?
垃圾回收器一般是做爲一個單獨的低級別的線程運行，不可預知的狀況下對內存堆中已經死亡的或者長時間沒有使用的對象進行清楚和回收，程序員不能實時的調用垃圾回收器對某個對象或全部對象進行垃圾回收。回收機制有分代複製垃圾回收和標記垃圾回收，增量垃圾回收
187. java的異常有哪幾種，有什麼區別。
第一種方式：直接在函數頭中throws SomeException，函數體中不須要try/catch
第二種方式：使用try/catch，在catch中進行必定的處理以後（若是有必要的話）拋出某種異常
第三種方法：使用try/catch/finally，在catch中進行必定的處理以後（若是有必要的話）拋出某種異常
188. 經過部署描述文件（web.xml）能夠配置哪些功能？
監聽器。。過濾器。。也能夠用來驗證XML文件的正確性
189. 說一下mvc原理，（關於mvc）
一、模型（Model）
模型是應用程序的主體部分。模型表示業務數據，或者業務邏輯.
二、視圖（View）
視圖是應用程序中用戶界面相關的部分，是用戶看到並與之交互的界面。
三、控制器（controller)
控制器工做就是根據用戶的輸入，控制用戶界面數據顯示和更新model對象狀態。
MVC 式的出現不只實現了功能模塊和顯示模塊的分離，同時它還提升了應用系統的可維護性、可擴展性、可移植性和組件的可複用性
190. servlet 在MVC中充當的角色: 中心控制器
191. 什麼是BS和CS
B/S結構是Browser/Server的簡稱
即瀏覽器/服務器結構，程序和數據庫放在SERVER端，客戶端經過
瀏覽器來訪問數據，進行數據交換。
B其實就是BROWSE即瀏覽器，S就是SERVER,即服務器
也就是說,用戶能夠用瀏覽器就能夠享受SERVER提供的服務,也就是咱們上網的啦
而CS呢,C就是CLIENT即客戶端,S就是SERVER,服務端,
也就是說,用戶要使用SERVER的服務,須要裝上相應的客戶端軟件,像QQ就是這樣的.
C/S又稱Client/Server或客戶/服務器模式。服務器一般採用高性能的PC、工做站或小型機，並採用大型數據庫系統，如Oracle、Sybase、Informix或 SQL Server。客戶端須要安裝專用的客戶端軟件。
B/S是Brower/Server的縮寫，客戶機上只要安裝一個瀏覽器（Browser），如Netscape Navigator或Internet Explorer，服務器安裝。Oracle、Sybase、Informix或 SQL Server等數據庫。瀏覽器經過Ｗeb Server 同數據庫進行數據交互。
C/S的優勢是能充分發揮客戶端ＰＣ的處理能力，不少工做能夠在客戶端處理後再提交給服務器。對應的優勢就是客戶端響應速度快。缺點主要有如下幾個：
只適用於局域網。而隨着互聯網的飛速發展，移動辦公和分佈式辦公愈來愈普及，這須要咱們的系統具備擴展性。這種方式遠程訪問須要專門的技術，同時要對系統進行專門的設計來處理分佈式的數據。客戶端須要安裝專用的客戶端軟件。首先涉及到安裝的工做量，其次任何一臺電腦出問題，如病毒、硬件損壞，都須要進行安裝或維護。特別是有不少分部或專賣店的狀況，不是工做量的問題，而是路程的問題。還有，系統軟件升級時，每一臺客戶機須要從新安裝，其維護和升級成本很是高。
對客戶端的操做系統通常也會有限制。可能適應於Win98, 但不能用於win2000或Windows XP。或者不適用於微軟新的操做系統等等，更不用說Linux、Ｕnix等。
B/S最大的優勢就是能夠在任何地方進行操做而不用安裝任何專門的軟件。只要有一臺能上網的電腦就能使用，客戶端零維護。系統的擴展很是容易，只要能上網，再由系統管理員分配一個用戶名和密碼，就能夠使用了。甚至能夠在線申請，經過公司內部的安全認證（如ＣＡ證書）後，不須要人的參與，系統能夠自動分配給用戶一個帳號進入系統。
192. 頁面中使用javascript的利與弊？（益端：能減小一些簡單的邏輯業務，提升頁面的效率，弊端：對於有些不能識別Javascript的瀏覽器存在必定的安全隱患）
193. 在Liniux/Uinix下建立一個角色賬號，本身擁有一切權限，系統用戶擁有訪問權限，其餘用戶沒有任何權限.
194. SQL中有個PrepardStatement對象，用Java實現鏈接Oracle數據庫，運用PrepardStatement對象。ConnDB.java
package demo.bean;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
public class ConnDB {
public static void main(String[] args) {
try{
String driver = "oracle.jdbc.driver.OracleDriver";
String url="jdbc:oracle:thin:@localhost:1521:yf";
String username = "scott";
String password = "tiger";
DriverManager.registerDriver( new oracle.jdbc.OracleDriver());
Connection con = DriverManager.getConnection(url, username, password);
PreparedStatement stm = con.prepareStatement("select sysdate from dual");
ResultSet rs = stm.executeQuery();
while(rs.next()){
System.out.print(rs.getString(1));
}
}catch(Exception e){
e.printStackTrace();
}
}
}
195. 數據庫索引的優勢和缺點
1、爲何要建立索引呢（優勢）？
這是由於，建立索引能夠大大提升系統的性能。
第一， 經過建立惟一性索引，能夠保證數據庫表中每一行數據的惟一性。
第二， 能夠大大加快數據的檢索速度，這也是建立索引的最主要的緣由。
第三， 能夠加速表和表之間的鏈接，特別是在實現數據的參考完整性方面特別有意義。
第四， 在使用分組和排序子句進行數據檢索時，一樣能夠顯著減小查詢中分組和排序的時間。
第五， 經過使用索引，能夠在查詢的過程當中，使用優化隱藏器，提升系統的性能。
2、創建方向索引的不利因素（缺點）可是，爲表中的每個列都增長索引，是很是不明智的缺點：
1 建立索引和維護索引要耗費時間，這種時間隨着數據量的增長而增長。
2 索引須要佔物理空間，除了數據表佔數據空間以外，每個索引還要佔必定的物理空間，若是要創建聚 簇索引，那麼須要的空間就會更大。
3 當對錶中的數據進行增長、刪除和修改的時候，索引也要動態的維護，這樣就下降了數據的維護速度。
196. struts2.0中幾種經常使用的標籤
<s:if test=""></s:if> <s:form action=""></s:form>
<s:checkbox></s:checkbox>-----複選框 <s:url></s:url>-----建立url <s:textarea></s:textarea>-----文本域輸入框
<s:autocompleter></s:autocompleter> <s:a href=""></s:a>-----超連接，相似於html裏的<a></a>
197. 介紹下spring
Spring提供了管理業務對象的一致方法而且鼓勵了注入對接口編程而不是對類編程的良好習慣.Spring的架構基礎是基於使用JavaBean屬性的Inversion of Control容器是一個解決了許多在J2EE開發中常見的問題的強大框架，還提供了能夠和整體的IoC容器集成的強大而靈活的MVC web框.
198. 介紹下ajax
AJAX全稱爲「Asynchronous JavaScript and XML」（異步JavaScript和XML），是指一種建立交互式網頁應用的網頁開發技術
199. 介紹下hibernate
Hibernate是鏈接 Java 應用程序和關係數據庫的中間件。它對 JDBC API 進行了封裝，負責Java對象的持久化。在分層的軟件架構中它位於持久化層，封裝了全部數據訪問細節，使業務羅基層能夠專一於實現業務邏輯
200. servlet和jsp頁面過濾器Filter的做用及配置
過濾器可附加到一個或多個servlet或JSP頁面上，而且能夠檢查進入這些資源的請求信息 過濾器要好處。1它以一種模塊化的或可重用的方式封裝公共的行爲 2 利用它可以將高級訪問決策與表現代碼相分離
201. 學JAVA的都看了什麼書？
基礎不好的人我建議用那本JavaSE 6.0編程指南 《最新Java2 核心技術 卷1、卷2》了，不要怕代碼難懂，這個必定要克服，固然某些代碼(好比常常說起的畫小球、你又不是搞圖象的:))就能夠跳過去。這當中能夠穿插閱讀《Java實效編程百例》，最後建議你們閱讀《Java編程思想》 thinking in JAVA第三版中文版 Core Java（java核心技術）
202. 函數和過程的區別？
過程和函數區別以下：
一、標識符不一樣:函數的標識符爲FUNCTION，過程爲：PROCEDURE。
二、話法不一樣：函數中通常不用變量形參，用函數名直接返回函數值；而過程若有返回值，則必須用變量形參返回。
三、函數在定義時必定要進行函數的類型說明，過程則不進行過程的類型說明。
四、調用方式不一樣:函數的調用出如今表達式中，過程調用，由獨立的過程調用語句來完成。
五、過程通常會被設計成求若干個運算結果，完成一系列的數據處理，或與計算無關的各類
操做；而函數每每只爲了求得一個函數值。
203. Javascript如何實現繼承？
1.採用對象冒充方式:
原理: 構造函數使用this關鍵字給全部屬性和方法賦值, 由於構造函數只是一個函數,因此能夠使ClassA的構造函數成爲classB的方法,而後調用它.這樣classB就會收到classA的構造函數中定義的屬性和方法.例子:
2.例:
function classA(name)
{
this.name=name;
this.showName=function(){alert(this.name);}
}
function classB(name)
{
this.newMethod = classA;
this.newMethod(name);
}
obj = new classA("hero");
objB = new classB("dby");
obj.showName(); // print hero
objB.showName(); // print dby 說明classB 繼承了classA的方法.
204. 將字符串str（例：」abcrepefd」）中的」rep」部分替換成」with」字符串(不能用jdk自帶的replace方法)
答案以下:
public void replace(String str,String rep,String with){
try{
int i = str.indexOf(rep);
String s1 = str.substring(0, i);
String s2 = str.substring(i, rep.length()+i);
String s3 = str.substring(rep.length()+i, str.length());
s2 = with;
String mes = s1+s2+s3;
System.out.println("替換前："+str);
System.out.println("替換後："+mes);
}catch(Exception e){
System.out.println("字符串"+str+"中不含有"+rep+"字符串！");
}
}
205. Java Reflection是什麼？
答：
1.JAVA反射，Reflection是Java 程序開發語言的特徵之一，它容許運行中的 Java 程序對自身進行檢查，或者說"自審"，並能直接操做程序的內部屬性。例如，使用它能得到 Java 類中各成員的名稱並顯示出來;
2.一個簡單的例子
import java.lang.reflect.*;
public class DumpMethods {
public static void main(String args[]) {
try {
Class c = Class.forName(args[0]);
Method m[] = c.getDeclaredMethods();
for (int i = 0; i < m.length; i++)
System.out.println(m.toString());
}
catch (Throwable e) {
System.err.println(e);
}
}}
206. 1到11相加是奇數仍是偶數?
偶數
207. 一個圓上有6個點，能夠連多少條直線？
15條線段
208. Stack堆棧，實現進棧，出棧
package t1;
public class mystack {
private Object[] data;
private int top=-1;
private int size;
public mystack()
{
data=new Object[5];
size=5;
}
public mystack(int size)
{
data=new Object[size];
this.size=size;
}
public void push(Object obj)
{
if(this.isfull())
{
return ;
}
top++;
data[top]=obj;
}
public Object pop() {
if(this.isempty())
{
return null;
}
Object obj=data[top];
top--;
return obj ;
}
public boolean isfull()
{
if(top==data.length)
{
return true;
}
else
{
return false;
}
}
public boolean isempty()
{
if(top==-1)
{
return true;
}
else
{
return false;
}
}
}
209. 每週的工做效率要提升24％，每週工做6天，那麼天天工做效率要提升多少？（6％，4%,24%）
答：24%
210. .前一天是星期一，又是第二個工做日，那麼今天是星期幾？
答：星期三
211. Hibernate 中的HQL和 criteria的區別？
答：
1.QBC(Query by Criteria)查詢對查詢條件進行了面向對象封裝，符合編程人員的思惟方式;
2．HQL(Hibernate Query Language)查詢提供了更加豐富的和靈活的查詢特性，在涵蓋Criteria查詢的全部功能的前提下，提供了相似標準SQL語句的查詢方式，同時也提供了更加面向對象的封裝;
212. Web service 是什麼？它是採用什麼通訊機制，它的通訊協議是什麼？
答： Webservice是跨平臺，跨語言的遠程調用技術;
1. 它的通訊機制實質就是xml數據交換;
2. 它採用了soap協議（簡單對象協議）進行通訊
213. Struts 是怎麼實現MVC的？
Struts提供MVC三層模式:
MVC就是 model view controller.
一、view視圖層通常運用jsp或者html進行實現，展示給用戶看；
二、controller控制層struts有個文件叫struts-config.xml，該文件裏面定義個處理後的跳轉頁面；
三、model模型層理解不深，多是邏輯模型
214. j a v a 對象初始化順序
1.類的初始化（initialization class & interface）
2.對象的建立（creation of new class instances）
順序：應爲類的加載確定是第一步的，因此類的初始化在前。大致的初始化順序是：
類初始化 -> 子類構造函數 -> 父類構造函數 -> 實例化成員變量 -> 繼續執行子類構造函數的語句
215. 一個字符串中可能存在A-Z的全角字符，寫一個方法把裏面的全角字符轉變成半角字符？
答：採用創建字典表進行查找轉換
public static String translate(String s){
String qj = "ＡＢＣＤＥＦＧＨＩＪＫＬＭＮＯＰＱＲＳＴＵＶＷＸＹＺ";
String bj = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
StringBuffer sb = new StringBuffer();
for(int i=0;i<s.length();i++){
char c = s.charAt(i);
int pos = qj.indexOf(c);
if(pos>=0){
System.out.println(c + "," + pos);
sb.append(bj.charAt(pos));
}else{
sb.append(c);
}
}
return sb.toString();
}
216. 寫一個方法，傳入一個int 型的數字，把它的四個字節碼取出來，而且把它按大小順序經過控制檯輸出？
public static void main(String[] args) {
int num = -800000000;
String str = Integer.toBinaryString(num); //得到num 的二進制
if(num>=0) { //若是輸入的數爲正數,位數可能不足32位，要補0；負數確定是32位
if(str.length()<32) { //二進制不足32位，就在前面補0
int n0 = 32-str.length(); //看差幾個0
String temp = "";
for(int i=0;i<n0;i++) {
temp = temp + "0"; //拼0
}
str = temp + str;
}
}
String s1 = str.substring(0, 8);
String s2 = str.substring(8, 16);
String s3 = str.substring(16, 24);
String s4 = str.substring(24, 32);
System.out.println(str);
System.out.println(s1);
System.out.println(s2);
System.out.println(s3);
System.out.println(s4);
int n1=Integer.parseInt(s1,2);//以二進制把字符串解析爲 10進制的數
int n2=Integer.parseInt(s2,2);
int n3=Integer.parseInt(s3,2);
int n4=Integer.parseInt(s4,2);
System.out.println(n1);
System.out.println(n2);
System.out.println(n3);
System.out.println(n4); //整數大小本身比較吧
}
217. ．類的工廠模式怎麼實現？
首先肯定這些類的父類或共同的接口，擔任抽象產品的角色，好比
public interface IServer{
public void calc(int a,int b);
}
而後，這些類的具體實現繼承某個父類或實現共同的接口,擔任具體產品角色，好比
AddServer類和SubServer類
public class AddServer implements IServer{
public void calc(int a,int b){
System.out.println(a+b);
}
}
public class SubServer implements IServer{
public void calc(int a,int b){
System.out.println(a-b);
}
}
最後，涉及一個類充當工廠的角色，根據客戶端的要求，提供具體的產品，好比
public class ServerFactory {
private static ServerFactory factory;
private ServerFactory(){}
public static ServerFactory getInstance(){
if(factory == null)
factory = new ServerFactory();
return factory;
}
//根據客戶給出的名字返回對應的產品
public IServer getServer(String name){
if("Add".equals(name)){
return new AddServer();
}else if("Sub".equals(name)){
return new SubServer();
}else{
return null;
}
}
public static void main(String args[]){
IServer addserver = ServerFactory.getInstance().getServer("Add");
addserver.calc(5,3);
}
}
218. Web容器裏面的對象存活週期？
Web容器裏面的對象的存活週期由JVM控制。某個對象有容器負責實例化或應用負責實例化，若是某個對象得不到任何引用，
則由JVM的垃圾收集器負責銷燬。
219. struts2中action的對象的生命週期？
用spring來控制action的生命週期Struts2支持經過攔截器堆棧（Interceptor Stacks）爲每個Action建立不一樣的生命週期。堆棧可以根據須要和不一樣的Action一塊兒使用。
220. annotation的使用方法和用途主要分爲幾類？
答 一、內建Annotation——Java5.0版在java語法中常常用到的內建Annotation：
二、開發者自定義Annotation：由開發者自定義Annotation類型；
三、使用第三方開發的Annotation類型
221. 說說你對IOC的理解
答：1.控制反轉（Inversion of Control，英文縮寫爲IoC）是一種設計模式；
2.控制反轉還有一個名字叫作依賴注入（Dependency Injection）。簡稱DI；
應用控制反轉，對象在被建立的時候，由一個調控系統內全部對象的外界實體，將其所依賴的對象的引用，傳遞給它。也能夠說，依賴被注入到對象中。
222. 從action類，servlet依賴，action執行的控制、線程模式幾個方面談struts1和struts2的區別。
答：從action類上分析:
1.Struts1要求Action類繼承一個抽象基類。Struts1的一個廣泛問題是使用抽象類編程而不是接口。
2. Struts 2 Action類能夠實現一個Action接口，也可實現其餘接口，使可選和定製的服務成爲可能。Struts2提供一個ActionSupport基類去實現經常使用的接口。Action接口不是必須的，任何有execute標識的POJO對象均可以用做Struts2的Action對象。
從Servlet 依賴分析:
3. Struts1 Action 依賴於Servlet API ,由於當一個Action被調用時HttpServletRequest 和 HttpServletResponse 被傳遞給execute方法。
4. Struts 2 Action不依賴於容器，容許Action脫離容器單獨被測試。若是須要，Struts2 Action仍然能夠訪問初始的request和response。可是，其餘的元素減小或者消除了直接訪問HttpServetRequest 和 HttpServletResponse的必要性。
從action線程模式分析:
5. Struts1 Action是單例模式而且必須是線程安全的，由於僅有Action的一個實例來處理全部的請求。單例策略限制了Struts1 Action能做的事，而且要在開發時特別當心。Action資源必須是線程安全的或同步的。
6. Struts2 Action對象爲每個請求產生一個實例，所以沒有線程安全問題。（實際上，servlet容器給每一個請求產生許多可丟棄的對象，而且不會致使性能和垃圾回收問題）
223. 如何理解struts,jsf,struts2的工做原理
答：1.JSF和STRUTS工做原理大體相同,有一箇中心控制器即一個servlet,
2.JSF:用一個JAVABENA裏的屬性綁定頁面表單值,而struts用ActionFrom對應表單值;
3.JSF在一個JAVABEAN裏處理從頁面送來的個值,而struts則是把actionFrom的值送給對象的ACTION來處理,二者都是MVC模式的.
224. 整合spring 與struts的方法，那種最好，爲何？
答：1.第一種方法:
Struts的Action繼承Spring的ActionSupport類，並在Action中獲取Spring的ApplicationContext。這是最簡單的一種整合方式，但有三個缺點：第一，Struts與Spring緊密耦合，不能改換到其餘IoC容器；第二，難以使用Spring AOP特性；第三，對於須要使用DispatchAction的Struts應用無能爲力。
2.第二種方法:
在Struts的配置文件中，以Spring的DelegatingRequestProcessor類代替Struts的RequestProcessor類，並在Spring的配置文件中定義與Struts配置文件中<action-mappings>對應的bean，從而將Struts的Action與Spring分開，並把Struts的動做置於Spring的控制之下。這種整合方式的優勢是將再也不依賴Spring這個特定的IoC容器，但必須依賴Struts的RequestProcessor類。
3.第三種方法:
經過Spring的DelegatingActionProxy類代理Struts的動做，即在Struts配置文件中，定義<action-mappings>的type屬性所有改成DelegatingActionProxy，而不是具體的類名，並在Spring配置文件中定義與Struts動做映射對應的bean，從而將Struts的Action與Spring分開，並把Struts的動做置於Spring的控制之下。無疑，這是最靈活的一種整合方式。
225. springframework與struts的不一樣之處
答：1. SpringFramework是一個採用了反轉控制（InversionofControl,Ioc）策略的基於J2EE 的輕量級應用框架。核心是IoC容器，對於其它應用，如數據庫訪問，日誌等，SpringFramework多使用現有的、成熟的框架。它採用了模塊化的方式，各模塊能夠共同使用，也能夠單獨使用其中的一個模塊。
2． struts2利用成熟的struts1和webwork整合使之操做更加方便;
226. spring使用了哪些設計模式，這樣用有什麼好處？
Dao模式 經過實現DAO,咱們達到了解耦合的目的,使的程序更加的健壯,但複雜性增長了；
227. spring對多種ORM 框架提供了很好的支持，結合事務管理描述spring中使用Hibernate的方法。
答：spring中採用aop模式注入hibernate的sessionfactory和事務管理,在dao中調用.Spring集成hibernate有兩種方式,一是dao層只與hibernate有關, 不使用任何spring 的api, 而後把dao注入到ioc容器.二是使用spring的hibernateDaoSupport.事務管理也能夠只使用hibernate的事務管理.
228. struts中action是全局的仍是局部的，爲何？
是全局
229. Hibernate有哪幾種查詢數據的方法？
答:hibernate在查詢方式上有三種方式:HQL SQL QBC
230. http和ftp的默許使用端口是什麼？
答：http：80 ftp：21
231. Ping命令的做用？
答：Ping命令的主要做用是經過發送數據包並接收應答信息來檢測兩臺計算機之間的網絡是否連通。當網絡出現故障的時候，能夠用這個命令來預測故障和肯定故障地點
232. 構造器的名能不能和類的名字相同？
答：能夠！而且必定要相同
233. 在一個主方法類可不能夠調用一個非靜態的方法？
答：能夠
234. 一個類中可不能夠有2個公共的方法？
答：能夠
235. Internet的最頂級的商業域名叫什麼？
答： .com
236. GC是什麼，爲何要使用它？
垃圾回收 (garbage collection, GC) 一個跟蹤過程，它傳遞性地跟蹤指向當前使用的對象的全部指針，以便找到能夠引用的全部對象，而後從新使用在此跟蹤過程當中未找到的任何堆內存。公共語言運行庫垃圾回收器還壓縮使用中的內存，以縮小堆所須要的工做空間 由於你沒有足夠多內存,而且,你挺懶,不去本身清理內存,因此就有了 GC
237. 編程題:有一個數據文件:123 34 17 651234 345....這些數據都是隨機產生的,編寫程序讀出該文件.並將其以從大到小的順序輸出到另外一個文件中.
public void readtext(){
File file = new File("D:\test.txt");
List list= new ArrayList();
try {
BufferedReader br=new BufferedReader(new FileReader(file));
String data = "";
String line = null;
while ( (line = br.readLine()) != null) {
data = data.concat(line);
}
StringTokenizer stoken = new StringTokenizer(data, " ");
while (stoken.hasMoreTokens()) {
int i = Integer.parseInt(stoken.nextToken());
list.add(i);
}
} catch(Exception ex) {}
String[] str = new String[list.size()];
for(int i=0;i<list.size();i++){
str[i]=list.get(i);
}
Object iTemp= null;
for(int i=1;i<list.size();i++) {
for(int j=list.size()-1;j>=i;j--) {
if(str[j]>str[j-1]) {
iTemp = str[j-1];
str[j-1] = str[j];
str[j] = iTemp;
}
}
String result = "";
for(int i=0;i<str.length;i++){
result +=str[i]+" ";
}
//將result寫入另一個文件便可。
}
238. 從一到十九共十九個數,打印出利用這十九個整數任意多個相加等於20因此可能性,每一個數字在同一個算式中只出現一次.
public void test(){
Integer[] a = new Integer[19];
for(int i=1;i<20;i++){
a[i-1]=i;
}
for(int i=0;i<18;i++){
for(int j=18-i;j<18;j++)
if(a[i]+a[j]==20)
System.out.println(a[i]+"+"+a[i+1]+"="+20);
}
}
239. JSP內置對象做用，如何取Cookie的方法
使用request對象的getCookies()方法取cookies
(1) HttpServletRequest類的Request對象
做用：表明請求對象，主要用於接受客戶端經過HTTP協議鏈接傳輸到服務器端的數據。
(2) HttpServletResponse類的Respone對象
做用：表明響應對象，主要用於向客戶端發送數據
(3) JspWriter類的out對象
做用：主要用於向客戶端輸出數據;
Out的基類是JspWriter
(4) HttpSession類的session對象
做用：主要用於來分別保存每一個用戶信息，與請求關聯的會話；
會話狀態維持是Web應用開發者必須面對的問題。
(5) ServletContext類的application對象
做用：主要用於保存用戶信息，代碼片斷的運行環境；
它是一個共享的內置對象，即一個容器中的多個用戶共享一個application對象，故其保存的信息被全部用戶所共享.
(6) PageContext類的PageContext對象
做用：管理網頁屬性,爲JSP頁面包裝頁面的上下文，管理對屬於JSP中特殊可見部分中已命名對象的訪問，它的建立和初始化都是由容器來完成的。
(7) ServletConfig類的Config對象
做用：代碼片斷配置對象，表示Servlet的配置。
(8) Object類的Page（至關於this）對象
做用：處理JSP網頁，是Object類的一個實例，指的是JSP實現類的實例，即它也是JSP自己，只有在JSP頁面範圍以內纔是合法的。
(9)Exception
做用：處理JSP文件執行時發生的錯誤和異常
240. 寫幾個線程安全類，不安全的，支持排序的類名？
線程安全類：Vector 、Hashtable、
不安全的類：ArrayList、HashMap、Linkedlist
支持排序的類：TreeSet
JDK也提供一個對集合類進行線程安全處理的類Collections類，能夠對一些非結程安全的類進行同步處理。
241. 將ISO8859-1字符串轉成GB2312編碼，語句爲？
String s=new String(text.getBytes(「iso8859-1」),」gb2312」).
242. 說出你用過的J2EE標準的WEB框架和他們之間的比較？
答：用過的J2EE標準主要有：JSP&Servlet、JDBC、JNDI、JavaMail、JTA、XML、RMI、WebServices等。這些標準主要提供了對於WEB框架的全方位的支持與整合，經過Web容器來管理這些中間件，使得Web框架開發實現者，只需注重應用系統的實現，而沒必要關注與業務不相關的邏輯，大大下降了開發成本和開發週期。同時這些中間年良好的擴展性、平臺不相關性，也使得這個標準成爲大多數Web框架所採用。
243. 類庫有哪些？
Xerces ，JDOM dom4j XOM jConfig XStream
244. <jsp:include>與<%@include>的區別
動態INCLUDE用jsp:include動做實現 它老是會檢查所含文件中的變化，適合用於包含動態頁面，而且能夠帶參數。
靜態INCLUDE用include僞碼實現,定不會檢查所含文件的變化，適用於包含靜態頁面，不能實現參數共享。
245. 怎麼樣手動啓動Oracle數據庫？
答：第一步：啓動Oracle在OS下的監聽程序。第二步：啓用OS下的實例服務。第三步打開數據庫。
246. WEB SERVICE 的理解
Web Service主要是爲了使原來各孤立的站點之間的信息可以相互通訊、共享而提出的一種接口。 Web Service所使用的是Internet上統1、開放的標準，如HTTP、XML、SOAP（簡單對象訪問協議）、WSDL等，因此Web Service能夠在任何支持這些標準的環境（Windows,Linux）中使用。注：SOAP協議（Simple Object Access Protocal,簡單對象訪問協議）,它是一個用於分散和分佈式環境下網絡信息交換的基於XML的通信協議。在此協議下，軟件組件或應用程序可以經過標準的HTTP協議進行通信。它的設計目標就是簡單性和擴展性，這有助於大量異構程序和平臺之間的互操做性，從而使存在的應用程序可以被普遍的用戶訪問。
247. 寫一個遞歸編程
public class Test {
static int multiply(int n){
if(n==1||n==0)
return n;
else
return n*multiply(n-1);
}
public static void main(String[] args){
System.out.println(multiply(10));
}
248. AWT和Swing的區別？
通常swing組件是從awt組件擴展的,swing是輕量組件 而awt是重量組件， AWT是比較依賴操做系統組件，功能少，Swing不依賴，組件多，功能多 窗口風格更多樣化 Swing是由純JAVA CODE所寫的，解決了JAVA因窗口類而沒法跨平臺的問題，使窗口功能也具備跨平臺與延展性的特性，並且SWING不需佔有太多系統資源，而且一些組件也採用一些更開放式的開發方式，支持更多的擴展。
249. 哪幾個方法能夠實現一個線程？
一種是聲明 Thread 的子類,重載 Thread 類的方法 run。 另外一種途徑是聲明一個類，該類實現 Runnable 接口。而後再實現方法 run。
250. STOP()和SUSPEND()不推薦使用的緣由？
由於stop本質上就是不安全的。中止線程會致使解鎖它已鎖定的全部監視程序。suspend 從本質上就是易於死鎖的一種操做。
251. JAVA事件有哪些模式？
1. 事件直接驅動模式。它的第一個要求就是性能的要求，須要直接並且快，是必須常用的，主要適合於迅速處理 前臺的命令，每每是系統架構的重要部分，也是流程控制的主要模式。2.監控式事件模式是藉助第三者來監控和觸發事件，特色是： 有一個觀察者置身事外在按期獨立運行着。
252. 用javascript實現用戶登陸驗證的代碼.
<script language=javascript>
function checkSubmit()
{if ((document.form1.name.value)=='')
{
window.alert ('姓名必須填寫');
document.form1.name.select();
document.form1.name.focus();
return false;
}
else
return true;
}
</script>
<form name="form1" onsubmit="javascript:return checkSubmit()">
<input type="text" name="name">
</form>
<%
253. uml三要素.
事物、關係、圖
254. EJB規範規定的EJB禁止的操做有哪些？
1.不能操做線程和線程API(線程API指非線程對象的方法如notify,wait等)，
2.不能操做awt，
3.不能實現服務器功能，
4.不能對靜態屬生存取，
5.不能使用IO操做直接存取文件系統，
6.不能加載本地庫.，
7.不能將this做爲變量和返回，
8.不能循環調用。
255. TRUNCATE和DELETE有如下幾點區別？
一、TRUNCATE在各類表上不管是大的仍是小的都很是快。若是有ROLLBACK命令DELETE將被撤銷，而TRUNCATE則不會被撤銷。
二、TRUNCATE是一個DDL語言，向其餘全部的DDL語言同樣，他將被隱式提交，不能對TRUNCATE使用ROLLBACK命令。
三、TRUNCATE將從新設置高水平
256. http協議，tcpip協議解釋
答：HTTP：超文本傳輸協議（Hypertext Transfer Protocol）
TCP/IP（Transmission Control Protocol/Internet Protocol)的簡寫，中文譯名爲傳輸控制協
257. //編寫一個截取字符串的函數，輸入爲一個字符串和字節數，輸出爲按字節截取的字符串。
//可是要保證漢字不被截半個，如「我ABC」4，應該截爲「我AB」，輸入「我ABC漢DEF」，6應該輸出爲「我ABC」而不是「我ABC+漢的半個」。
public static void main(String[] args) throws Exception{
String str = "我a愛中華abc def';
String str = "我ABC漢";
int num = trimGBK(str.getBytes("GBK"),5);
System.out.println(str.substring(0,num) );
}
public static int trimGBK(byte[] buf,int n){
int num = 0;
boolean bChineseFirstHalf = false;
for(int i=0;i<n;i++)
{
if(buf[i]<0 && !bChineseFirstHalf){
bChineseFirstHalf = true;
}else{
num++;
bChineseFirstHalf = false;
}
}
return num;
}
258. java程序天天12點打印」hello」
public static void main(String[] args) {
Date date = new Date();
System.out.println(date.getHours());
while (true) {
while (date.getHours() == 12) {
if (date.getMinutes() == 0) {
if (date.getSeconds() == 0) {
System.out.println("hello world!");
}
}
}
}
}
259. 編程題：讀取一個文件在控制檯打印出來
File file = new File("E:\\課件\\二期課件\\Java\\T09 src\\JRadioButtonDemo.java");
long file_length= file.length();
try {
//輸入流
FileInputStream input = new FileInputStream(file);
byte b_data [] = new byte[(int)file_length];
input.read(b_data);
System.out.println(new String(b_data));
input.close();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
260. 解析XML的方法及對它的瞭解？
答：:有DOM,SAX,STAX等
DOM:處理大型文件時其性能降低的很是厲害。這個問題是由DOM的樹結構所形成的，這種結構佔用的內存較多，並且DOM必須在解析文件以前把整個文檔裝入內存,適合對XML的隨機訪問SAX:不現於DOM,SAX是事件驅動型的XML解析方式。它順序讀取XML文件，不須要一次所有裝載整個文件。當遇到像文件開頭，文檔結束，或者標籤開頭與標籤結束時，它會觸發一個事件，用戶經過在其回調事件中寫入處理代碼來處理XML文件，適合對XML的順序訪問
261. 你所熟悉的開源組件和框架，簡單介紹下
答：FileUpload、 POI、WebWork、Struts1/二、hibernate、spring、Ajax、Ibatis
262. 要求WEB2。0是什麼東西 ？
Web1.0 的主要特色在於用戶經過瀏覽器獲取信息。Web2.0 則更注重用戶的交互做用，用戶既是網站內容的瀏覽者，也是網站內容的製造者。所謂網站內容的製造者是說互聯網上的每個用戶再也不僅僅是互聯網的讀者，同時也成爲互聯網的做者；再也不僅僅是在互聯網上衝浪，同時也成爲波浪製造者;在模式上由單純的「讀」向「寫」以及「共同建設」發展；由被動地接收互聯網信息向主動創造互聯網信息發展，從而更加人性化
webservice和soap的區別？
Web ServiceWeb Service是基於網絡的、分佈式的模塊化組件，它執行特定的任務，遵照具體的技術規範，這些規範使得Web Service能與其餘兼容的組件進行互操做。
SOAP即簡單對象訪問協議(Simple Object Access Protocol)，它是用於交換XML編碼信息的輕量級協議。 它是Webservice所採用的主要協議之一
。
263. 介紹幾種WEB服務器，問Tomcat裏面的文件組成？
IIS、apache、Tomcat
bin:啓動,關閉Tomcat的命令.
common/lib:網絡編程的jar文件.
conf:配置文件.
logs:日誌文件.
server:自帶的web應用(三個).
shared:全部web應用均可以訪問的內容.
temp:臨時.
webapps:默認站點文件夾.
work:jsp生成的類.
Tomcat是一個開放源代碼、運行servlet和JSP Web應用軟件的基於Java的Web應用軟件容器。Tomcat Server是根據servlet和JSP規範進行執行的，所以咱們就能夠說Tomcat Server也實行了Apache-Jakarta規範且比絕大多數商業應用軟件服務器要好。
264. ThreadLocal在項目中的實際意義？
ThreadLocal和其它同步機制相比從另外一個角度來解決多線程的併發訪問，它爲每個線程維護一個和該線程綁定的變量的副本，從而隔離了多個線程的數據，每個線程都擁有本身的變量副本，從而也就沒有必要對該變量進行同步了。還提供了線程安全的共享對象，在編寫多線程代碼時，能夠把不安全的整個變量封裝進ThreadLocal
ThreadLocal能夠大量減小參數的傳遞，能夠使代碼簡潔，但一個線程會綁定多個本身定義的局部對象，ThreadLocal是抽象在線程上的對象建立工廠，目前的Tomcat5使用了線程池，一個線程處理一個request，這樣ThreadLocal對象能夠抽象的綁定在request生命週期，不會存在線程危機，並且線程池也平衡了這些ThreadLo
265. 不一樣的數據庫裏面有相同的表實現同步更新（從多方面考慮）
--用觸發器能夠實現兩個數據表之間的數據同步更新
For Example:
Create Trigger room_texes_change_id
on room
for update
as if update(room.cstname)
set texes.cstname=room.cstname
where texes.id=room.id 。
266. ejb是基於哪些技術實現的，和javabean的區別？
EJB包括Session Bean、Entity Bean、Message Driven Bean，基於JNDI、RMI、JAT等技術實現 EJB是一個關於用JAVA語言開發的可部署的服務器端組件的組件體系結構。它是一個技術協議，能使組件運行於任何應用服務器,專門用來解決商務問題JAVABEANS是JAVA類，是由屬性、事件和方法組成的JAVA組件，它們能夠用來組成JAVA應用程序
267. 適配器模式解釋：
把一個類的接口變換成客戶端所期待的另外一種接口，從而使本來因接口緣由不匹配而沒法一塊兒工做的兩個類 可以一塊兒工做。適配類能夠根據參數返還一個合適的實例給客戶端
268. Gc是什麼，爲何要有GC
GC是垃圾收集的意思（Gabage Collection）,內存處理是編程人員容易出現問題的地方，忘記或者錯誤的內存回收會致使程序或系統的不穩定甚至崩潰，Java提供的GC功能能夠自動監測對象是否超過做用域從而達到自動回收內存的目的，Java語言沒有提供釋放已分配內存的顯示操做方法。
垃圾回收能夠有效的防止內存泄露，有效的使用能夠使用的內存。垃圾回收器一般是做爲一個單獨的低級別的線程運行，不可預知的狀況下對內存堆中已經死亡的或者長時間沒有使用的對象進行清楚和回收，程序員不能實時的調用垃圾回收器對某個對象或全部對象進行垃圾回收。回收機制有分代複製垃圾回收和標記垃圾回收，增量垃圾回收。
269. switch能夠做用於byte嗎？能夠做用於long，能夠做用於string 嗎？
switch（expr1）中，expr1是一個整數表達式。所以傳遞給 switch 和 case 語句的參數應該是 int、 short、 char 或者 byte。long,string 都不能做用於swtich。
270. try {}裏有一個return語句，那麼緊跟在這個try後的finally {}裏的code會不會被執行，何時被執行，在return前仍是後?
也許你的答案是在return以前，但往更細地說，個人答案是在return中間執行，請看下面程序代碼的運行結果：
public class Test {
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println(new Test().test());;
}
static int test()
{
int x = 1;
try
{
return x;
}
finally
{
++x;
}
}
}
---------執行結果 ---------
1
運行結果是1，爲何呢？主函數調用子函數並獲得結果的過程，比如主函數準備一個空罐子，當子函數要返回結果時，先把結果放在罐子裏，而後再將程序邏輯返回到主函數。所謂返回，就是子函數說，我不運行了，你主函數繼續運行吧，這沒什麼結果可言，結果是在說這話以前放進罐子裏的。
271. 兩個對象值相同(x.equals(y) == true)，但卻可有不一樣的hash code，這句話對不對?
對。
若是對象要保存在HashSet或HashMap中，它們的equals相等，那麼，它們的hashcode值就必須相等。
若是不是要保存在HashSet或HashMap，則與hashcode沒有什麼關係了，這時候hashcode不等是能夠的，例如arrayList存儲的對象就不用實現hashcode，固然，咱們沒有理由不實現，一般都會去實現的。
272. 當一個對象被看成參數傳遞到一個方法後，此方法可改變這個對象的屬性，並可返回變化後的結果，那麼這裏究竟是值傳遞仍是引用傳遞?
引用傳遞。當一個對象實例做爲一個參數被傳遞到方法中時，參數的值就是對該對象的引用。
273. 在Oracle中數據庫中的一個表中，這個表沒有主鍵id也沒有特定標示來查數據，怎麼查？
[題意不明：考慮從面試者的角度能是考僞列和rownum的內容]
考慮使用Oracle的僞列rowid來查詢
274. 概述反射和序列化
反射Reflection 是Java 程序開發語言的特徵之一，它容許運行中的Java 程序對自身進行檢查;能直接操做程序的內部屬性和方法。
簡單來講序列化就是一種用來處理對象流的機制，所謂對象流也就是將對象的內容進行流化，咱們能夠對流化後的對象進行讀寫操做，也可將流化後的對象傳輸於網絡之間。而把Java對象轉換爲字節序列的過程稱爲對象的序列化。
275. 簡述WebService和Remoting的特色和運用場景
Web Service主要是爲了使原來各孤立的站點之間的信息可以相互通訊、共享而提出的一種接口。 Web Service所使用的是Internet上統1、開放的標準，如HTTP、XML、SOAP（簡單對象訪問協議）、WSDL等，因此Web Service能夠在任何支持這些標準的環境（Windows,Linux）中使用。Remoting 依賴於特定語言的遠程調用機制，好比Java的RMI/IIOP它的設計目標就是簡單性和擴展性，這有助於大量異構程序和平臺之間的互操做性，從而使存在的應用程序可以被普遍的用戶訪問。
276. dao 是什麼及做用
DAO組件主要提供數據庫訪問操做，主要是對各自數據表的CRUD方法，在通常設計過程當中爲了考慮鬆耦合的問題，業務邏輯層中不該當牽涉到任何持久層實際操做，因此能夠將各數據源表的操做特性封裝到DAO組件中去，這樣加強了系統的可讀性、可維護性。
277. Inserted和deleted的含義？
SQLServer的DML觸發器中兩個臨時表
inserted表反映插入或更新操做時插入的記錄
deleted表反映刪除或更新操做時刪除的記錄
278. 3個框架在項目在項目當中的用，basedao是用來作什麼的。
DAO組件主要提供數據庫訪問操做，針對不一樣數據源表進行了封裝，這樣能夠提供其它層的訪問接口，使得組件之間解耦，而BaseDAO是這些全部不一樣DAO的公共特性的封裝，針對一些能夠進一步進行細化的DAO組行的進一步抽象，使組件的移值性更爲靈活。
279. Orace中除了數據庫[XX]備份，還有什麼方法備份？
1.導出／導入（EXP/IMP）。
2.熱備份。 熱備份是在數據庫運行的狀況下，採用archivelog mode方式備份數據庫的方法。因此，若是你有昨天夜裏的一個冷備份並且又有今天的熱備份文件，在發生問題時，就能夠利用這些資料恢復更多的信息。熱備份要求數據庫在Archivelog方式下操做，並須要大量的檔案空間。一旦數據庫運行在archivelog狀態下，就能夠作備份了。
3.冷備份。冷備份發生在數據庫已經正常關閉的狀況下，當正常關閉時會提供給咱們一個完整的數據庫。冷備份時將關鍵性文件拷貝到另外的位置的一種說法。
280. jsp與servlet中請求轉發的區別
forward是服務器請求資源，服務器直接訪問目標地址的URL，把那個URL的響應內容讀取過來，而後把這些內容再發給瀏覽器，瀏覽器根本不知道服務器發送的內容是從哪兒來的，因此它的地址欄中仍是原來的地址，但此轉發是連續的轉發，在轉發過程當中請求參數也連續轉發到目標地址中。
redirect就是服務端根據邏輯,發送一個狀態碼,告訴瀏覽器從新去請求那個地址，通常來講瀏覽器會用剛纔請求的全部參數從新請求。前者對請求是連續的，後者是從新發送一個新的請求，因此只能從新發送新的請求參數，原有的請求參數將再也不連續到目標頁面。
281. 分頁的優化需考慮哪些
sql語句的優化：ID排除法、三層嵌套等
表的優化：適當使用索引
282. web運用程序的穩定、安全須要考慮哪些
Web服務器的性能考慮主要有：併發用戶數、事務安全、負載均衡、時段流量、網絡帶寬
安全性：
· 關鍵數據的保護，例如用戶數據等
· 功能服務的正常提供。
· 網站的防攻擊能力
· 對異常災害的恢復能力
程序性能：
· 響應請求並運行得出結果的平均時間
· 錯誤的檢測和攔截
· 擴展性
283. 問spring的AOP，mvc究竟是怎麼優化程序的結構？
SpringAOP主要提供了Pointcut、Aspects等以及它們如何被織入應用程序、代理的方式等等進行優化的控制。而Spring MVC裏面前端控制器叫作DispatcherServlet。裏面充當Action的組件叫作Controller，返回的視圖層對象叫作ModelAndView，提交和返回均可能要通過過濾。從而提升程序可讀性和穩定性。
284. 筆試：1.LinkedList和ArrayList內部是如何實現的？new ArrayList（10）意思
ArrayList的內部實現是基於內部數組Object[]，因此從概念上講，它更像數組，但LinkedList的內部實現是基於一組鏈接的記錄，因此，它更像一個鏈表結構，因此，它們在性能上有很大的差異。
new ArrayList（10）構造一個初始容量爲 10 的空列表
285. 定義一個變量，Var v =new Object (),用js編寫的簡便寫法是什麼？
var v = {};
286. 網上購物系統的類圖，用例圖。
主要的類有：商品分類 商品 訂單 訂單項 商品評論
主要用例有：查看商品詳情 發表評論 登陸 註冊 購物車管理 訂單生成 查詢訂單等
287. 給你一個整數類型的數組，按從小到大的順序進行排列！
Array.sort(int a[]);//默認爲升序排列
288. 查詢出M 頁的N行數據 。
答：
SQL實現：select top N from a where id not in
(select top 每頁顯示 * (M-1) id from students order by id) order by id
MYSQL:select * from a limit m,n
289. 把二叉樹從小到大遍歷出來怎麼實現？
public class Node {
public int value;
public Node left;
public Node right;
public void store(int value)
{
if(value<this.value)
{
if(left == null)
{
left = new Node();
left.value=value;
}
else
{
left.store(value);
}
}
else if(value>this.value)
{
if(right == null)
{
right = new Node();
right.value=value;
}
else
{
right.store(value);
}
}
}
public boolean find(int value)
{
System.out.println("happen " + this.value);
if(value == this.value)
{
return true;
}
else if(value>this.value)
{
if(right == null) return false;
return right.find(value);
}else
{
if(left == null) return false;
return left.find(value);
}
}
public void preList()
{
System.out.print(this.value + ",");
if(left!=null) left.preList();
if(right!=null) right.preList();
}
public void middleList()
{
if(left!=null) left.preList();
System.out.print(this.value + ",");
if(right!=null) right.preList();
}
public void afterList()
{
if(left!=null) left.preList();
if(right!=null) right.preList();
System.out.print(this.value + ",");
}
public static void main(String [] args)
{
int [] data = new int[20];
for(int i=0;i<data.length;i++)
{
data[i] = (int)(Math.random()*100) + 1;
System.out.print(data[i] + ",");
}
System.out.println();
Node root = new Node();
root.value = data[0];
for(int i=1;i<data.length;i++)
{
root.store(data[i]);
}
root.find(data[19]);
root.preList();
System.out.println();
root.middleList();
System.out.println();
root.afterList();
}
}
290. mysql分頁怎麼實現，oracle分頁怎麼實現，他們之間的區別？
Ajax是一個RIA應用技術，解決富Web客戶端問題，提升用戶體驗的
jms是Java的消息服務系統，解決Java分佈式應用消息異步通訊
mysql中的limit關鍵字查詢出指定區間的記錄進行分頁。
oracle中經過rownum來記錄結果集記錄編號實現分頁
291. 描述struts體系結構？對應各個部分的開發工做主要包含哪些？
按MVC設計的Web架構，
其中Model爲ActionForm組件的設計
View爲Struts標籤的使用
Controller爲Action組件的設計和ActionServlet的配置
292. 組合優於繼承。你是否贊成這句話，並說明
繼承和組合均可以實現代碼的重用（Reuse），爲何組合要優於繼承呢？
經過繼承，子類可以得到與父類相同的功能和屬性，父類擁有了某種功能，子類就有了；可是若是子類需 要新的功能，直接在父類裏面增長新的功能，那麼會致使全部的子類同時擁有這種功能，這其實是將類的功能與類牢牢的耦合在一塊兒，是一種緊密耦合系統，因爲 關係至關密切，致使改動一處而動全身，實際上不利於代碼的重用。而組合剛好相反，她把類的各項功能分割開，互不干涉。一個類的功能，其實是各類子功能的 組合，好比鴨子的功能就是飛行功能和發出叫聲功能的組合，不管是何種鴨子，都是這樣。同時究竟是怎樣飛行，怎樣叫，又能夠經過面向接口的編程實現多態。
51．javascript取瀏覽器的版本 裏面還有哪些對象？
<script type="text/javascript">
function getBrowser(){
var bro = navigator.userAgent.toLowerCase();
if(/msie/.test(bro)) return 'IE' + bro.match(/msie ([\d.]*);/)[1]
else if(/navigator/.test(bro)) return 'NS' + bro.match(/navigator\/([\d.]*)/)[1]
else if(/chrome/.test(bro)) return 'CR' + bro.match(/chrome\/([\d]*)/)[1]
else if(/safari/.test(bro)) return 'SF' + bro.match(/version\/([\d]*)/)[1]
else if(/opera/.test(bro)) return 'OP' + bro.match(/version\/([\d]*)/)[1]
else if(/firefox/.test(bro)) return 'FF' + bro.match(/firefox\/([\d]*)/)[1]
}
</script>
293. 如何運行本地的EXE文件？
雙擊運行,或者在DOS窗口中經過命令運行
294. struts中的prepare怎麼用？
首先Action組件實現Preparable接口的prepare()方法，在配置 Action組件時應用PrepareInterceptor攔截器。
295. Hrbernate的二級緩存講述。
hibernate的session提供了一級緩存，每一個session，對同一個id進行兩次load，不會發送兩條sql給數據庫，可是session關閉的時候，一級緩存就失效了。
二級緩存是SessionFactory級別的全局緩存，它底下能夠使用不一樣的緩存類庫，好比ehcache、oscache等。hibernate在執行任何一次查詢的以後，都會把獲得的結果集放到緩存中，緩存結構能夠看做是一個hash table，key是數據庫記錄的id，value是id對應的pojo對象。當用戶根據id查詢對象的時候（load、iterator方法），會首先在緩存中查找，若是沒有找到再發起數據庫查詢。
296. 若是作個招聘網站性別只招男的，年齡20-30，若是不匹配就不能讓他投簡歷，怎麼實現？ 填身份證時如何讓該人信息所有顯示出來？
使用JavaScript作客戶端檢驗，填身份證時使用Ajax獲取人員信息；
297. 軟件的開發過程、以及角色？
軟件立項 à 需求分析 à 概要設計 à 詳細設計 à 編碼測試 à 驗收運行
| | | |
|------------ 分析員 ---------|--------------程序員---------------|------------測試員-------|
298. Io流 InputStream與Reader的區別 ,怎樣將字符流轉換成字節流
InputStream 字節輸入流、Reader字符輸入流
OutputStreamWriter 是字符流通向字節流的橋樑
InputStreamReader 是字節流通向字符流的橋樑
299. 啓動線程調用那個方法 ？爲何要調用start（）方法？若調用run（）方法會出現什麼狀況？
面試題上有
300. Struts2.0 若在一個方法中返回的是null，代表什麼?struts.xml還須要配置嗎？爲何？struts有那些標籤？struts.xml中有那些標籤？
方法返回null，表示沒有視圖結果迴應，固然本身經過流直接輸出響應結果，則struts.xml只需對Action進行映射配置，而無須進行結果配置。
301. Hibernate 運行的流程？優缺點？爲何insert比select快？能夠批量insert一些數據嗎？
Hibernate應該是創建在JDBC基礎上的一個開源的ORM映射框架，很好的封裝了實體映射實現，提供友好的實體操做接口，以及基於HQL的查詢接口，在開發中能夠減小編寫SQL相關代碼，提升效率和減小出錯。
以面向對象的方式操做數據庫，進行增刪改很方便，但執行復雜的查詢時則很費事麻煩。
select查詢可能須要執行多條SQL語句，牽涉到加載策略因此執行須要消耗不少時間，相比insert操做要慢些。
hibernate可批量insert一些數據，配置文件中設置hibernate.jdbc.batch_size參數，來指定每次提交SQL的數量。
302. sqlserver查詢 怎樣取得JAVA虛擬機默認的編碼方式？
可經過Charset.defaultCharset()來獲取
303. 智力題：
一、有一輛火車以15千米/小時從洛杉磯開往紐約，一輛火車以20千米/小時從紐約開往洛杉磯，一隻鴿子以30千米/小時從洛杉磯開往紐約，鴿子和兩輛火車同時出發，鴿子遇到火車轉頭，向另外一輛火車飛，直到兩輛火車相遇，問鴿子飛了多少千米？
假設洛杉磯到紐約的距離爲s
那小鳥飛行的距離就是(s/(15+20))*30。
二、有兩根不勻稱的香，燒完1小時，問如何知道1 5分鐘
把香稱重，取出總重量的1/4
3一羣人在一黑屋子，有黑白2種帽子，每人能夠看其餘人的帽子，至少1頂黑帽子。若是知道本身是黑帽子，打本身一巴掌。第一次開燈，無人，關燈。第二開燈，無人，關燈。第3次，聽到劈劈啪啪的聲音。問有幾頂黑帽子。
304. 什麼是 聯通圖的生成樹？
什麼是哈夫曼樹？什麼是平衡二叉樹？寫一個深度優先排序，寫一個廣度優先排序？寫出 C語言對鏈表HEAD的排序？
連通圖的生成樹——是連通圖的一個極小連通子圖，它含有圖中所有頂點，但只有足以構成一棵樹的n-1條邊。
哈夫曼樹又稱最優樹（二叉樹），是一類帶權路徑最短的樹。構造這種樹的算法最先是由哈夫曼(Huffman)1952年提出，這種樹在信息檢索中頗有用。
若是任意節點的左右子樹的深度相差不超過1，那這棵樹就是平衡二叉樹。
305. 哪些不是JAVA關鍵字：TRUE sizeof native是關鍵字
sizeof不是 大寫的TRUE不是
306. 怎樣知道給出的兩條線段是否相交，用僞碼實現。
假設線段AB,A(X1,Y1),B(X2,Y2);線段CD,C(X3,Y3),D(X4,Y4);
1。判斷兩斜率 相等則不相交
2。若斜率不等
307. ORACLE數據庫用到了哪些方面，怎樣優化數據庫。SQL語句過長時，怎樣優化？
(1) 使用分區這種手段。所謂分區就是動態地將表中的記錄分離到若干不一樣的表空間上，使數據在物理上被分割開來，便於維護、備份、恢復、事務及查詢性能。
(2) 重建索引，及時回收那些未使用空間，提升空間利用率。
(3) 調整SGA參數
sql語句長：用存儲過程！
308. JAVASCRIPT的一些經常使用東西：如提示框如何實現的 ：MVC
使用jQuery等第三方的插件Dialog便可，無需重複造輪子。
309. 兩個SQL語句 一個ArrayList裏面存了一些Student對象，Student對象有Name和Age兩人屬性，此類裏面有set和get方法，要求以Age來降序排序。
要求Student實現Comparable接口的compareTo()方法來按照age判斷對象的大小，而且大於時返回-1，小於時返回1，相等則返回0。
310. 有一些奇數和偶數，無序的，要求寫一個方法，實現將全部的奇數放在所有的偶數前面
主要代碼以下：主要採用快速排序的算法。
int[] n = {1,2,5,6,4,7,10,9,3,8};
int m = n[0];
int j = n.length -1;
int i= 0;
while(i<j){
while(i<j && n[j]%2==0){j--;}
if(j>=i){
n[i++] = n[j];
}
while(i<j && n[i]%2!=0){i++;}
if(i<=j){
n[j--] = n[i];
}
}
n[i] = m;
for(int k=0;k<n.length;k++){
System.out.print(n[k] + " ");
}
311. 你對工做流和表單的理解
一個工做流包括一組活動及它們的相互順序關係，還包括過程及活動的啓動和終止條件，以及對每一個活動的描述。一個完整的工做流管理系統一般由工做流引擎、可視工做流設計、流程操做、工做流客戶端程序、流程監控、表單設計工具、與表單的集成以及與應用程序的集成八個部分組成。工做流引擎做爲工做流管理系統的核心部分，主要提供了對於工做流定義的解析以及流程流轉的支持。
表單用來顯示查詢或輸入的業務數據。
312. Classpath怎麼設置和它的意義是什麼？
好比，set CLASSPATH=C:\Java\jdk1.6.0_10\lib\dt.jar;.
設置class文件的搜索路徑
313. 用java寫一個讀取盤符的名字
new File("").getAbsolutePath().substring(0, 1);
314. Deprecated API 是什麼意思？
deprecated是指已通過時，可是爲了向前兼容起見仍然保留的方法，這些方法可能會在之後取消支持。你應當改用較新的方法。通常在API裏面會說明你應當用什麼方法來代替之。
315. 如何去掉JAVA的 內存機制？
是否是垃圾回收機制，使用System.gc()強制回收。
316. 缺乏IDE如何編譯JAVA代碼？
使用JDK的javac.exe 直接手工編譯
或使用Apache的ANT腳本構建
317. THHP與HTTPS有什麼區別？
HTTP爲普通WEB協議、HTTPS爲加密WEB協議。默認http爲tcp80端口。https爲tcp443端口
318. Session的具體用法？
Session用來保存每個用戶的專有信息，好比像用戶登陸驗證、購物車。
1.ibatis 中的#與$的區別
1.#是把傳入的數據看成字符串，如#field#傳入的是id,則sql語句生成是這樣，order by "id",這固然會報錯．．
2.$傳入的數據直接生成在sql裏，如#field#傳入的是id,則sql語句生成是這樣，order by id, 這就對了．
3.#方式可以很大程度防止sql注入．
4.$方式沒法方式sql注入．
5.$方式通常用於傳入數據庫對象．例如傳入表名.
6.通常能用#的就別用$.
319. 請裂舉session、cookie、viewstated的應用範圍
Session 服務器端維護， 某個用戶活動時間 + 延遲時間（默認20分鐘），
Cookie 客戶端維護， 程序可指定生命週期，
ViewState 小量數據，一個web頁面的生命期
320. 用什麼方法使服務器關閉以後，session所保存的信息不會丟失？
將session信息保存到數據庫中或文件中
321. B2C和C2C大家是怎麼區別的？
Business（企業）、Customer（消費者）
B2C的B是Business企業，2則是to的諧音，C是Customer消費者，因此B2C是企業對消費者的電子商務模式。這種形式的電子商務通常以網絡零售業爲主，主要藉助於Internet開展在線銷售活動。B2C簡而言之是就是商家與顧客之間的商務活動，也就是一般所說的「網上購物網站」，企業、商家可充分利用電子商城提供的網絡基礎設施、支付平臺、安全平臺、管理平臺等共享資源有效地、低成本地開展本身的商業活動。
C2C就是消費者（consumer）與消費者（consumer）之間的電子商務。打個比方，好比一個消費者的有一臺舊電腦，經過網上拍賣，把它賣給另一個消費者，這種交易類型就稱爲c2c電子商務。主要是指網上拍賣。c2c模式的特色就是大衆化交易，由於是我的與我的之間的交易！
322. 用最好效率寫一個2*17等於多少？
（2<<4）+ 2
323. 用4 個0，用你所知道的數學方法計算出24
0的階乘等於1 即 0！＝１那麼４個0就是４了
又4的階乘爲２４ ４！＝２４
324. 10怎樣計算等於24？ (10×10-4)÷4=24
325. 有一個長方形蛋糕,切掉長方形一塊,怎樣一刀切下去成大小相等兩塊
將完整的蛋糕的中心與被切掉的那塊蛋糕的中心連成一條線。這個方法也適用於立方體
326. 九個球不知道哪一個輕重，讓你稱？
4個和4個稱，若相等則剩下一個是比較重要(2)若不相等，則往那邊不相等的那4個球中取兩個分爲一組，則左2個，右2個，則有左邊或右邊右一個是比較重的，從任意一邊取一個投入另外一方，並記住這個球，從其它4個取兩個放入另一邊，並記住這兩個球，若從一邊取走的放到另外一邊後，那邊重，則這球比較重要，若從一邊取走的放到另外一邊後，那邊輕，則爲另一邊所剩的一個球發
Java基礎部分：
1. 怎樣獲得一個文件的後綴名，io的設計思路：
ü 調用File.getName()獲得文件完整名fname
ü 獲得文件名中的.號位置 int poc = fname.indexOf(".");
ü 獲得後綴 ftype = fname.substring(poc+1);
2. int x=1 int y='a'<'A' ? x--:x++; , 求x 的最終值 ：2；
3. Integer a和int b運行以後a和b有什麼不一樣？都沒有賦值的狀況下他們的初始值各是什麼?
答：Integer a 定義爲整型變量對象，默認值爲null；int b 定義爲整數變量，默認值爲0；
4. 什麼緣由，怎麼解決NullPointerException異常？
答：對沒有賦值或爲null的對象進行處理會致使NullPointerException異常，最好在使用對象變量以前對該變量進行非null判斷
5. PHP中：echo和print的區別？
答：echo能夠同時輸出多個字符串，並不須要圓括號；print只能夠同時輸出一個字符串，須要圓括號。
6. （編程題）求一百之內質數
public class ZhiShu {
public static void main(String[] args) {
System.out.println("1~100的質數有：");
for (int n = 1; n <= 100; n++) {
boolean b = true;
if (n != 1) {
for (int i = 2; i < n; i++) {
if (n % i == 0) {
b = false;
break;
}
}
}
if (b) {
System.out.println(n );
}
}
}
}
7. 六行五列字符串數組（分別用C和java實現）
Java: int a[][]= new int[6][5]; //java申明不須要初始化，此時有默認值
C: int b[6][5]; //C申明必需要初始化值
8. （編程題）把int值保存在byte數組中〈高位在前〉
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
public class IntToByte {
public static void main(String[] args) throws Exception {
System.out.println(byteArrayToInt(intToByteArray1(456548)));
System.out.println(byteArrayToInt(intToByteArray2(456548)));
}
/**
* 將int值轉換稱byte數組 方法1
*/
public static byte[] intToByteArray1(int i) {
byte[] result = new byte[4];
result[0] = (byte) ((i >> 24) & 0xFF);
result[1] = (byte) ((i >> 16) & 0xFF);
result[2] = (byte) ((i >> 8) & 0xFF);
result[3] = (byte) (i & 0xFF);
return result;
}
/**
* 將int值轉換稱byte數組 方法2
*/
public static byte[] intToByteArray2(int i) throws Exception {
ByteArrayOutputStream buf = new ByteArrayOutputStream();
DataOutputStream out = new DataOutputStream(buf);
out.writeInt(i);
byte[] b = buf.toByteArray();
out.close();
buf.close();
return b;
}
｝
9. （編程題）寫一個方法：輸入的是文件名，輸出的是文件內容字符串(FileToString.java 考察IO與String與StringBuffer的區別)
File f = new File("hello.txt");
StringBuffer sb = new StringBuffer();
try{
FileReader in = new FileReader(f);
char[] buf = new char[1024];
while(in.read(buf)!=-1){
//將每次讀取的內容放到StringBuffer中
sb.append(new String(buf).trim());
}
System.out.println(sb.toString());
}
catch(Exception e){
System.out.println(e.getMessage());
e.printStackTrace();
}
10. （編程題）建立個靜態方法，傳個對象，循環打印對象的類名跟方法名，用代碼（反射機制）
public static void display(Object clazz) throws ClassNotFoundException {
System.out.println("對象的類名....." + clazz.getClass().getName());
System.out.println();
// 獲得構造方法
Constructor cons[] = clazz.getClass().getConstructors();
for (int i = 0; i < cons.length; i++) {
Constructor c = cons[i];
String name = c.getName();
Class cs[] = c.getParameterTypes();
System.out.print("對象的構造方法....." + c.getModifiers() + " " + name
+ "(");
for (int j = 0; j < cs.length; j++) {
System.out.print(" " + cs[j].getName() + " ");
}
System.out.println(" )");
}
System.out.println();
// 獲得其餘方法
Method method[] = clazz.getClass().getMethods();
for (int i = 0; i < method.length; i++) {
Method m = method[i];
String name = m.getName();
Class ms[] = m.getParameterTypes();
System.out.print("對象的其餘方法....." + m.getModifiers() + " " + name
+ "(");
for (int j = 0; j < ms.length; j++) {
System.out.print(" " + ms[j].getName() + " ");
}
System.out.println(" )");
}
}
11. （編程題）寫一個判斷對稱數的方法
/**
* 對稱數就是順讀和反讀都同樣嗎，你能夠用一個String接受用戶輸入，
* 而後把它反轉，判斷先後是否是equals就能夠了。
* 例如 123321就是對稱數
*/
public static void RegularNumberTest() {
String num1 = new Scanner(System.in).nextLine();
String num2 = "";
for (int j = num1.length() - 1; j >= 0; j--) {
char a = num1.charAt(j);
num2 += a;
}
if (num2.equals(num1)) {
System.out.println(num1 + "是對稱數.");
}else{
System.out.println(num1 + "不是對稱數.");
}
}
12. String和StringBuilder的區
答：StringBuilder是一個可變的字符序列，該類提供一個與 StringBuffer 兼容的 API，但不保證同步，存儲效率比StringBuffer高；而String 是不可變的對象；
13. String str=new String(「abc」)內存中怎麼分配的？
答：先在棧中分配一塊空間，存放str,而後會在堆中分配一塊空間，存放abc，且棧中的str指向堆中的abc地址
14. （編程題）1.1.2.3.5.8.13.21.求N位是多少，用遞歸實現
// 1.1.2.3.5.8.13.21.求N位是多少
public static int amwih(int i) {
if (i <= 0)
return 0;
else if (i > 0 && i <= 2)
return 1;
else
return amwih(i - 1) + amwih(i - 2);
}
15. 128>>1和128<<1結果分別是多少？
答：128>>1 = 64;
128<<1 = 256;
16. （編程題）用程序打印出下面的金字塔:（楊輝三角）
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
1 n-1 ......n-1 1
import java.util.Scanner;
public class YangHuiSanJiao {
int array[][];
public void creat() {
for (int i = 0; i < array.length; i++)
for (int j = 0; j < array[i].length; j++) {
if (j == 0)
array[i][j] = 1;
else if (i == j)
array[i][j] = 1;
else if (j > i)
array[i][j] = 0;
else
array[i][j] = array[i - 1][j - 1] + array[i - 1][j];
}
}
public static void main(String args[]) {
int n, m;
System.out.println("請輸入行數n:");
Scanner sc = new Scanner(System.in);
n = m= sc.nextInt();
YangHuiSanJiao aa = new YangHuiSanJiao();
aa.array = new int[n][m];
aa.creat();
for (int i = 0; i < aa.array.length; i++) {
for (int j = 0; j < aa.array[i].length; j++)
if (aa.array[i][j] == 0)
System.out.print(" ");
else
System.out.print(aa.array[i][j] + " ");
System.out.println();
}
}
}
17. （編程題）給出一個數字，如123456，輸出123.456,輸入1234567，輸出123.456.7，可是輸入如12，輸出是12。(可是不能用format)即針對整數使用財會方式進行輸出提示，考察對字符的使用技巧
public static String numberFormat(int num) {
StringBuffer sb = new StringBuffer(String.valueOf(num));
int sblen = sb.length();
int index = 0;
while (index + 3 < sblen) {
index = index + 3;
sb = sb.insert(index, ".");
index++;
sblen++;
}
return sb.toString();
}
18. 簡要介紹java如何實現安全性
Java經過提供一個」安全沙箱「來保證從網絡或者其餘不信任的地方下載並運行的程序不會破壞本地數據，其中包括：
ü 類裝載器結構
ü class文件檢驗器
ü 內置於Java虛擬機（及語言）的安全特性
ü 安全管理器及Java API
19. 爲何說java是解釋性的？
答：java是由java源代碼編譯成字節碼存放在 .class文件中的. 而執行時,是由java虛擬機(jvm)讀取字節碼文件翻譯並執行的. 因此java是解釋性的
20. （編程題） 1）實現從字符串"<text>你好，歡迎來到咱們公司面試</text>",提取中文字符串 2）把上題中的"咱們公司"改寫成"玄武科技"
String str = "<text>你好，歡迎來到咱們公司面試</text>";
int indexS = str.indexOf("<text>") + 6;
int indexE = str.lastIndexOf("</text>");
str = str.substring(indexS, indexE);
System.out.println(str);
str = str.replaceAll("咱們公司", "玄武科技");
System.out.println(str);
21. （編程題）寫一個流的讀入程序，每次只能讀一行
try {
BufferedReader br = new BufferedReader(new FileReader(new File("hello.txt")));
String s = null;
// readLine()包含該行內容的字符串，不包含任何行終止符，若是已到達流末尾，則返回 null
while ((s=br.readLine())!=null) {
System.out.println(s); // 轉換成字符
}
} catch (Exception e) {
e.printStackTrace();
}
22. CURD是什麼，怎麼實現
CURD: Cread、Update、Read、Delete，就是對數據庫記錄的建立（添加insert）、修改、讀取（select）、刪除；
在java編程中主要是經過jdbc來實現的，但能夠使用其餘的中間件來簡化jdbc的複雜操做，例如hibernate、ibatis等；
23. （編程題）求一個二叉樹中值的和（考察遍歷二叉樹）
// 前序遍歷,同時記錄出全部節點值的和
private int firstRootSum(TreeNode root, int sum) {
if (root!= null){
sum = sum+root.getNum();
sum = firstRootSum(root.getLeft(),sum);// 左
sum = firstRootSum(root.getRight(),sum);// 右
}
return sum;
}
24. Java代碼以下person p=new person（）；中p放在什麼位置？
答：其中對象句柄p放在棧中
25. （編程題）字符串的分割如「abc|ddd||0dc」寫一個相似split的方法分割輸出出來
//Object[] obj = SplitString2.splitString("|abc|de||e|||", "|");
public static Object[] splitString(String str, String regex) {
ArrayList alist = new ArrayList();
StringBuffer sb = new StringBuffer(str);
int index = -1;
while ((index = sb.indexOf(regex)) != -1) {
if (index != 0) {
alist.add(sb.substring(0, index));
}
sb = sb.replace(0, index + 1, "");
}
alist.add(sb.toString());
alist.remove("");
return alist.toArray();
}
26. N個Integer的向量（Vector），能夠爲1到N+1之間任何一個，其中裏面的值互不相同，即Vector中不包含重複值。由於有N個對象，可能的值有n+1個，有一個值沒有包含在內，問是哪一個值沒有包含在內？（用Vector.get()或 Vector.size()實現）
Vector<Integer> data = new Vector();
// 初始化data的N個元素爲1~ N+1之間的值，且不從重複
boolean isIn = false;
for (int i = 1; i <= N + 1; i++) {
isIn = false;
for (int j = 0; j < data.size(); j++) {
if (data.get(j).intValue() == i) {
isIn = true;
break;
}
}
if (!isIn) {
// 當前的i爲要找的
}
}
27. （編程題）給你一組數據，如（1，3，5，5，2，6，1）寫一個程序要求輸出其中出現次數最多數值最大的數，並輸出出現幾回
int a[] = new int[] { 1, 3, 5, 5, 5, 6, 1,1 };
HashMap hmap = new HashMap();
// 統計每一個數字出現的次數
for (int i = 0; i < a.length; i++) {
if (hmap.get(a[i]) == null) {
hmap.put(a[i], 1);
} else {
int num = (Integer) hmap.get(a[i]);
hmap.put(a[i], ++num);
}
}
// 分別存放出現次數最多的次數，及其對應的值
int maxNum = Integer.MIN_VALUE, maxCount = Integer.MIN_VALUE;
int num; // 存放從集合中獲得的key值
Set kset = hmap.keySet();
Iterator ites = kset.iterator();
while (ites.hasNext()) {
num = (Integer) ites.next();
if ((Integer) hmap.get(num) > maxCount) {
maxNum = num;
maxCount = (Integer) hmap.get(num);
} else if ((Integer) hmap.get(num) == maxCount) {
if(num >maxNum){
maxNum = num;
}
}
}
System.out.println("出現次數最多數值最大的數"+maxNum+" 出現 "+maxCount+"次");
28. （編程題）如圖：（其實就是個二叉樹的存儲方式；給個節點，輸出該節點下的全部孩子節點）
A
B C
D E F G
（1）數據結構描述上面的圖形結構: 二叉樹
（2）按層次打印出上面圖形的結構如輸入B打出 B，D，H，I，E
public class BinaryTreeChar {
private CharTreeNode root;
public BinaryTreeChar(char num) {
this.root = new CharTreeNode(num);
}
/**
* 添加節點，默認是給樹根添加節點
*
* @param num
*/
public void add(char num) {
this.addTreeNode(root, num);
}
private void addTreeNode(CharTreeNode node, char num) {
if (num >= node.getNum()) {
if (node.getRight() != null) {
addTreeNode(node.getRight(), num);
} else {
node.setRight(new CharTreeNode(num));
}
} else {
if (node.getLeft() != null) {
addTreeNode(node.getLeft(), num);
} else {
node.setLeft(new CharTreeNode(num));
}
}
}
// 遍歷
private void printInfo(CharTreeNode node, boolean bool, char c) {
if (node == null)
return;
if (bool || node.getNum() == c) {
bool = true;
System.out.print(node.getNum() + " "); // 根
}
printInfo(node.getLeft(), bool,c);// 左
printInfo(node.getRight(), bool,c);// 右
}
public static void main(String[] args) {
BinaryTreeChar btree = new BinaryTreeChar('E');
btree.add('D');
btree.add('G');
btree.add('H');
btree.add('I');
btree.add('B');
btree.add('A');
btree.add('C');
btree.printInfo(btree.root,false,'D');
}
}
/**
* 樹節點
*
* @author admin
*/
class CharTreeNode {
private char num; // 節點值
private CharTreeNode left; // 左孩子節點
private CharTreeNode right; // 右孩子節點
public CharTreeNode(char num) {
this.num = num;
this.left = null;
this.right = null;
}
public CharTreeNode getLeft() {
return left;
}
public void setLeft(CharTreeNode left) {
this.left = left;
}
public char getNum() {
return num;
}
public void setNum(char num) {
this.num = num;
}
public CharTreeNode getRight() {
return right;
}
public void setRight(CharTreeNode right) {
this.right = right;
}
}
29. 字符集與字符編碼有什麼區別？
字符集（Charset）：是一個系統支持的全部抽象字符的集合。字符是各類文字和符號的總稱，包括各國家文字、標點符號、圖形符號、數字等。
字符編碼（Character Encoding）：是一套法則，使用該法則可以對天然語言的字符的一個集合（如字母表或音節表），與其餘東西的一個集合（如號碼或電脈衝）進行配對。即在符號集合與數字系統之間創建對應關係，它是信息處理的一項基本技術。
30. （編程題）寫一個遞歸函數，輸入一個整數，反序輸出這個整數
// 寫一個遞歸函數，輸入一個整數，反序輸出這個整數
public static void printOut(int n) {
System.out.print(n % 10);
if (n >= 10){
printOut(n / 10);
}
}
31. （編程題）小明一家五口信息都放在list中，每一個對象包含姓名，出生，根據爸爸姓名查爸爸生日，程序題
public class PersonClass {
private String name;
private Date birthday;
public PersonClass(String name,Date birthday){
this.name = name;
this.birthday = birthday;
}
public static void main(String[] args) {
ArrayList<PersonClass> list = new ArrayList();
list.add(new PersonClass("小明",new Date()));
list.add(new PersonClass("小明姐",new Date()));
list.add(new PersonClass("小明弟",new Date()));
list.add(new PersonClass("小明媽",new Date()));
list.add(new PersonClass("小明爸",new Date()));
for(PersonClass pc:list){
if(pc.name.equals("小明爸")){
System.out.println(pc.birthday);
}
}
}
}
32. 有什麼方法能將ArrayList list轉爲數組 ？
答： list.toArray()
33. Tread和threadlocal的做用及區別？
答：threadlocal是 線程局部變量（thread local variable），爲每個使用該線程的線程都提供一個變量值的副本，使每個線程均可以獨立地改變本身的副本，而不會和其餘線程的副本產生衝突；
34. 寫一個普通優盤的測試用例，須要考慮那些方面
功能測試：
1 在windows xp比較流行的操做系統上是否能夠識別（裝了驅動後是否能夠）
2 在電腦上顯示的盤符是否正確
3 總空間，可用空間，已用空間是否顯示正確
4 u盤中是否能夠拷入各類格式的各種文件（圖片，視頻，文檔，網頁...）
5 是否能夠拷入拷出大文件
6 正常操做拷入的文檔等是否顯示亂碼
7 拷文件的過程當中是否能夠取消
8 拷文件的過程當中拔掉u盤後，u盤是否損壞
9 拷文件的過程當中電腦關機後，u盤是否損壞
10 u盤的開關是否起做用
12 正常操做，拷入的文件是否會丟失
13 空間已盡是否有提示信息
14 是否支持格式化
15 u盤在各個狀態時是否有相應的led燈提醒
兼容性測試：
1 在windows 98,windows 2000,windows me,windows 2000 server,windows 2003 server,windows xp,windows vista...是否能夠識別
2 在usb1.0,usb2.0上是否可以識別
3 在筆記本上，臺式電腦，服務器上是否能夠識別
性能測試：
1 一次性拷貝刪除多個文件，u盤是否正常
2 u盤連續使用比較長的時間，u盤是否正常
3 u盤摔地上屢次後，是否正常
界面測試：
1 設計是否美觀大方
2 圖案，log是否正確顯示
35. （編程題）求一個字符串中第一個無重複的字符
public static void getUniqueString(String str){
boolean bool = true;
for(int i=0;i<str.length()&&bool;i++){
String s1 = str.substring(i, i+1);
if(str.indexOf(s1, i+1)==-1){
System.out.println(s1);
bool = false;
}
}
}
36. 實現對象比較的接口有哪些
答：java.lang.Comparable；
37. （編程題）給你一個文本，裏面給的是url，讓找出url的文件名及其相同的文件名出現的次數(程序題)
try {
Hashtable<String, Integer> ht = new Hashtable<String, Integer>();
File f = new File("e:/url.txt");
FileReader fr = new FileReader(f);
BufferedReader br = new BufferedReader(fr);
String url = "", urls = "";
while ((url = br.readLine()) != null)
urls += url;// 把全部字符串讀進來
String[] us = urls.split("http://");// 按照http://進行分割
for (int i = 1; i < us.length; i++) {
int ind = us[i].lastIndexOf("/");// 若是文件分隔符爲\，則該方法參數爲\\
String filename = us[i].substring(ind + 1);
int count = 1;
if (ht.containsKey(filename))
count = ht.get(filename) + 1;
ht.put(filename, count);
}
Iterator<String> it = ht.keySet().iterator();
System.out.println("文件名\t出現次數");
while (it.hasNext()) {
String key = it.next();
int value = ht.get(key);
System.out.println(key + "\t\t" + value);
}
br.close();
fr.close();
} catch (Exception e) {
}
38. Hashcode和Equals的聯繫
答：首先equals()和hashcode()這兩個方法都是從object類中繼承過來的 其次是hashcode() 方法，在object類中定義以下：a)若是兩個對象相同，那麼它們的hashCode值必定要相同；b)若是兩個對象的hashCode相同，它們並不必定相同 上面說的對象相同指的是用eqauls方法比較
39. （編程題）提供一個方法判斷任意一個沒有數字的整數數組 是否爲連續數字的數組？
public boolean test(int[] is){
boolean bool=true;
for(int i=0;i<is.length-1&&bool;i++){
if(Math.abs(is[i]-is[i+1])!=1){
bool=false;
}
}
return bool;
}
Web基礎部分（JSP等）（第七次考試）
1. HTTP協議中Header有那些？
答：請求頭包含請求的方法、URI、協議版本、以及包含請求修飾符、客戶信息和內容的相似於MIME的消息結構。例如：Cache-Control指定請求和響應遵循的緩存機制；Date頭域表示消息發送的時間；Pragma頭域用來包含實現特定的指令，最經常使用的是Pragma:no-cache。在HTTP/1.1協議中，它的含義和Cache-Control:no-cache相同。Host頭域指定請求資源的Intenet主機和端口號，必須表示請求url的原始服務器或網關的位置。Referer頭域容許客戶端指定請求uri的源資源地址，這能夠容許服務器生成回退鏈表，可用來登錄、優化cache等。等等；
2. Web中過濾器的原理，可否過濾圖片?
答：過濾器至關於在客戶端與服務器間創建多業務程序，可對request、response進行各類處理操做；只有經過的請求才會順利進入下一個過濾器的處理，最終到達服務器； 能夠對圖片進行過濾；
3. Javascript出現問題是怎麼調試的？（該題主要考察你的js功底，並不強調準確惟一答案）
答：我經常使用的方法：根據提示異常提示信息，在IE窗口，右鍵單擊 彈出的工具欄中 選擇「查看源文件」，這樣基本就能知道什麼地方錯了，若是麻煩點的問題，就經過alert()輸出階段性的結果，比較；
另外，經過專門的調試工具也行，例如frebug,javascript debug toolkit,aptana，我嘗試過aptana;
4. 寫一個郵箱校驗的函數，返回布爾值
function fnCheckEmail() {
var re = /^(\w ((-\w )|(\.\w ))*)\ \w ((-\w )|(\.\w ))*\@[A-Za-z0-9] ((\.|-)[A-Za-z0-9] )*\.[A-Za-z0-9] $/;
var email = document.getElementById("emailid").value;
if (email != null && email.length > 0) {
if (re.test(email)) {
return true;
}
else {
alert("Sorry，你輸入的Email不合法!");
return false;
}
}
else {
alert("請輸入Email!");
return false;
}
}
5. 在JavaScript中寫一個方法 如：function text(a,b,c){} 而後提供給你兩個參數，如（2，3），請問這樣調用會不會出錯？
答：能夠；
6. 在JavaScript中寫兩個方法 如：
function text(a,b){
alert(1);
}
function text(c,d,e){
alert(2);
}
而後提供給你兩個參數，如text(2,3），請問這樣調用會不會出錯？調用以後會出現什麼狀況？
答： 不會出錯，調用輸出的是 2；
7. Http中Staus的code，200，301，400的意思
ü 1XX這一類型的狀態碼，表明請求已被接受，須要繼續處.
ü 2xx表明請求已成功被服務器接收、理解、並接受;
200 請求已成功，請求所但願的響應頭或數據體將隨此響應返回。
ü 3xx 重定向,這類狀態碼錶明須要客戶端採起進一步的操做才能完成請求。
301 被請求的資源已永久移動到新位置，而且未來任何對此資源的引用都應該使用本響應返回的若干個 URI 之一。
ü 4xx 請求錯誤 ,表明了客戶端看起來可能發生了錯誤，妨礙了服務器的處理
400 語義有誤，當前請求沒法被服務器理解 或者 請求參數有誤
404請求失敗，請求所但願獲得的資源未被在服務器上發現。
ü 5xx 服務器錯誤
500服務器遇到了一個不曾預料的情況，致使了它沒法完成對請求的處理。通常來講，這個問題都會在服務器的程序碼出錯時出現。
8. Web系統安全因素有哪些？
答：1)操做系統、後臺數據庫的安全問題：這裏指操做系統和後臺數據庫的漏洞，配置不當，如弱口令等等，致使黑客、病毒能夠利用這些缺陷對網站進行攻擊。
2)Web發佈系統的漏洞 ：Web業務經常使用的發佈系統(即Web服務器)，如IIS、Apache等，這些系統存在的安全漏洞，會給入侵者可乘之機。
3)Web應用程序的漏洞：主要指Web應用程序的編寫人員，在編程的過程當中沒有考慮到安全的因素，使得黑客可以利用這些漏洞發起對網站的攻擊，好比SQL注入、跨站腳本攻擊等等。
4)自身網絡的安全情況：網站服務器所處的網絡安全情況也影響着網站的安全，好比網絡中存在的DoS攻擊等，也會影響到網站的正常運營。
9. 在js編碼中innerHTML,outhtml,innertext區別
ü innerHTML 設置或獲取位於對象起始和結束標籤內的 HTML
ü outerHTML 設置或獲取對象及其內容的 HTML 形式
ü innerText 設置或獲取位於對象起始和結束標籤內的文本
ü outerText 設置(包括標籤)或獲取(不包括標籤)對象的文本
10. 正則表達式＼d，＼s的含義。反斜槓喔
| 代碼 |
說明 |
| . |
匹配除換行符之外的任意字符 |
| \w |
匹配字母或數字或下劃線或漢字 |
| \s |
匹配任意的空白符 |
| \d |
匹配數字 |
| \b |
匹配單詞的開始或結束 |
| ^ |
匹配字符串的開始 |
| $ |
匹配字符串的結束 |
| 代碼/語法 |
說明 |
| * |
重複零次或更屢次 |
| + |
重複一次或更屢次 |
| ? |
重複零次或一次 |
| {n} |
重複n次 |
| {n,} |
重複n次或更屢次 |
| {n,m} |
重複n到m次 |
| 代碼/語法 |
說明 |
| \W |
匹配任意不是字母，數字，下劃線，漢字的字符 |
| \S |
匹配任意不是空白符的字符 |
| \D |
匹配任意非數字的字符 |
| \B |
匹配不是單詞開頭或結束的位置 |
| [^x] |
匹配除了x之外的任意字符 |
| [^aeiou] |
匹配除了aeiou這幾個字母之外的任意字符 |
11. jsp頁面可直接用的變量和類型有哪些？
request : HttpServletRequest
response : HttpServletResponse
session : HttpSession
application : ServletContext
out : JspWriter
pageContext : PageContext
page : Object
config : ServletConfig
exception : ServletException
12. 實現點擊頁面上的一個連接，而後隱藏這個連接的javascript代碼
<a href="#" onclick="hiddenHref()" id="ab">隱藏鏈接</a>
<script language="javascript">
function hiddenHref(){
document.getElementById("ab").style.display="none";
}
</script>
13. 使用js實現輸入框如下功能 1)限制輸入框最多隻能輸入15個字符；2）將輸入的‘a’都換成‘b’；
<script type="text/javascript">
function rep(){
var s=document.getElementById("test").innerText;
if(s.length>15){
alert("長度超出");
document.getElementById("test").innerText=s.substring(0,15);
}else{
document.getElementById("test").innerText=s.replace("a","b");
}
}
</script>
</head>
<body>
<textarea id="test" onkeyup="rep()"></textarea>
</body>
</html>
14. 頁面間對象傳遞有哪些方法？
答：1）Session （2）Cookie （3）Application （4）URL地址中的參數（5）經過隱藏字段來傳遞數據
（6）Server.Transfer （7）經過序列化對象
15. js中找出一個字符串中出現次數最多的一個字符？
<script type="text/javascript">
var str ="dddadadfdfseffserfefsefseeffffftsdg";
var maxLength = 0;
var result = '';
while( str != '' ){
oldStr = str;
getStr = str.substr(0,1);
eval("str = str.replace(/"+getStr+"/g,'')");
if( oldStr.length-str.length > maxLength ) {
maxLength = oldStr.length-str.length;
result = getStr + "=" + maxLength
}
}
alert(result)
</script>
框架部分：
1. ApplicationContext和BeanFactory有什麼區別？
BeanFactory其實是實例化，配置和管理衆多bean的容器。 這些bean一般會彼此合做，於是它們之間會產生依賴。 BeanFactory使用的配置數據能夠反映這些依賴關係中 （一些依賴可能不像配置數據同樣可見，而是在運行期做爲bean之間程序交互的函數）。
一個BeanFactory能夠用接口org.springframework.beans.factory.BeanFactory表示， 這個接口有多個實現。 最常使用的的簡單的eanFactory實現是org.springframework.beans.factory.xml.XmlBeanFactory。 （這裏提醒一下：ApplicationContext是BeanFactory的子類， 因此大多數的用戶更喜歡使用ApplicationContext的XML形式）。
ApplicationContext
beans包提供了以編程的方式管理和操控bean的基本功能，而context包增長了ApplicationContext，它以一種更加面向框架的方式加強了BeanFactory的功能。多數用戶能夠以一種徹底的聲明式方式來使用ApplicationContext，甚至不用去手工建立它，可是卻去依賴像ContextLoader的支持類，在J2EE的Web應用的啓動進程中用它啓動ApplicationContext。固然，這種狀況下還能夠以編程的方式建立一個ApplicationContext。
Context包的基礎是位於org.springframework.context包中的ApplicationContext接口。它是由BeanFactory接口集成而來，提供BeanFactory全部的功能。爲了以一種更像面向框架的方式工做，context包使用分層和有繼承關係的上下文類，包括：
1．MessageSource，提供對i18n消息的訪問；
2．資源訪問，好比URL和文件；
3．事件傳遞給實現了ApplicationListener接口的bean；
4．載入多個（有繼承關係）上下文類，使得每個上下文類都專一於一個特定的層次，好比應用的Web層
在ApplicationContext的諸多實現中，有三個常常用到：
1。ClassPathXmlApplicationContext:從類路徑中的XML文件載入上下文定義信息，把上下文定義文件看成類路徑資源。
2。FileSystemXmlApplicationContext:從文件系統中的XML文件載入上下文定義信息。
3。XmlWebApplicationContext：從Web系統中的XMl文件載入上下文信息。
2. struts2.0的session 和 servlet的session 有什麼區別
servlet中的session:由於在doget或dopost方法會傳遞HttpServletRequest,能夠直接經過request.getSession()獲得sesion
Strutx 2.0你能夠有兩種方式得到這些對象：非IoC（控制反轉Inversion of Control）方式和IoC方式。
非IoC方式
要得到上述對象，關鍵Struts 2.0中com.opensymphony.xwork2.ActionContext類。咱們能夠經過它的靜態方法getContext()獲取當前Action的上下文對象。 另外，org.apache.struts2.ServletActionContext做爲輔助類（Helper Class），能夠幫助您快捷地得到這幾個對象。
HttpServletRequest request = ServletActionContext.getRequest();
HttpServletResponse response = ServletActionContext.getResponse();
HttpSession session = request.getSession();
若是你只是想訪問session的屬性（Attribute），你也能夠經過ActionContext.getContext().getSession()獲取或添加session範圍（Scoped）的對象。
IoC方式
要使用IoC方式，咱們首先要告訴IoC容器（Container）想取得某個對象的意願，經過實現相應的接口作到這點
如implements SessionAware接口
3. Struts中的action是安全線程麼？爲何
Servlet是在多線程環境下的。便可能有多個請求發給一個servelt實例，每一個請求是一個線程。
struts下的action也相似，一樣在多線程環境下。
爲多線程環境編寫代碼。咱們的controller servlet指揮建立你的Action 類的一個實例，用此實例來服務全部的請求。所以，你必須編寫線程安全的Action類。遵循與寫線程安全的servlet一樣的方針。
4. EJB 是否繼承home接口，怎麼實現
Home對象是該類EJB對象的」工廠」或」代理」，管理EJB實例的生命週期，封裝關於EJB的元信息，是全部EJB的客戶間共享的，在部署或容器啓動時，將其stub綁在JNDI中，必須繼承EJBHome，方法必須符合RMI規則，必須提供沒有參數的create()方法,返回Remote接口類型，必須拋出CreateException和RemoteException。
5. 應用服務器與Web server的區別
Web服務器(Web Server)
Web服務器能夠解析(handles)HTTP協議。當Web服務器接收到一個HTTP請求，會返回一個HTTP響應，例如送回一個HTML頁面。爲了處理一個請求，Web服務器能夠響應一個靜態頁面或圖片， 進行頁面跳轉，或者把動態響應的產生委託給一些其它的程序例如CGI腳本，JSP腳本，servlets，ASP腳本，服務器端JavaScript，或者一些其它的服務器端技術。不管它們(譯者 注:腳本)的目的如何，這些服務器端的程序一般產生一個HTML的響應來讓瀏覽器能夠瀏覽。
應用程序服務器
經過各類協議，能夠包括HTTP，把商業邏輯暴露給客戶端應用程序。Web服務器主要 是處理向瀏覽器發送HTML以供瀏覽，而應用程序服務器提供訪問商業邏輯的途徑以供客戶端應用程序使用。應用程序使用此商業邏輯就象你調用對象的一個方法 (或過程語言中的一個函數)同樣。
應用程序服務器的客戶端(包含有圖形用戶界面(GUI)的)可能會運行在一臺PC、一個Web服務器或者甚至是其它的應用程序服務器上。在應用 程序服務器與其客戶端之間來回穿梭的信息不只僅侷限於簡單的顯示標記。相反，這種信息就是程序邏輯。 正是因爲這種邏輯取得了數據和方法調用的形式而不是靜態HTML，因此客戶端才能夠爲所欲爲的使用這種被暴露的商業邏輯。
在大多數情形下，應用程序服務器是經過組件的應用程序接口把商業邏輯暴露 (給客戶端應用程序)的，例如基於J2EE應用程序服務器的EJB組件模型。此外，應用程序服務器能夠管理本身的資源，例如看大門的工做包括安全，事務處理，資源池， 和消息。就象Web服務器同樣，應用程序服務器配置了多種可擴展和容錯技術。
6. 如何設置Hibernate二級緩存
一、首先要打開二級緩存，在hibernate.cfg.xml中添加以下配置：
<property name="hibernate.cache.use_second_level_cache">true</property>
二、Hibernate的二級緩存使用第三方的緩存工具來實現，因此咱們須要指定Hibernate使用哪一個
緩存工具。以下配置指定Hibernate使用EhCache緩存工具。
<property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property>
三、Hibernate在默認狀況下並不會對全部實體對象進行緩存，因此，咱們須要指定緩存哪些對象，
在實體對象的映射文件中（相應的<class>標籤內部），添加以下配置：
<cache usage="read-only"/>
usage="read-only"是「只讀」緩存策略。
注意，這個<cache>標籤只能放在<class>標籤的內部，並且必須處在<id>標籤的前面！！！
這個<cache>標籤放在哪些<class>標籤下面，就說明會多這些類的對象進行緩存
四、對於第3步，有一個可選的方案是在hibernate.cfg.xml文件中指定哪些類的對象須要緩存，
而不須要使用<cache>標籤來指定。如：
在hibernate.cfg.xml中添加以下配置：
<class-cache class="com.bjsxt.hibernate.Classes" usage="read-only" />
注意，這個<class-cache>標籤必須放在<mapping>標籤的後面！！
7. 什麼是事物處理，J2EE提供哪兩種事物處理方式
事務（Transaction）是數據庫管理系統提供的基本功能之一，能夠把完成用戶一個特定工做的一組操做看做是一個不可拆分的工做單元，因此事務也就是做業或任務。
JDBC支持單一數據庫鏈接.
JTA支持分佈式事務.
8. J2EE是技術、平臺、框架？包括哪些技術
J2EE自己是一個標準,一個爲企業分佈式應用的開發提供的標準平臺.
J2EE也是一個框架,包括JDBC、JNDI、RMI、JMS、EJB、JTA等技術.
9. EJB規範中規定EJB中禁止的操做有那些
1.不能操做線程和線程 API(線程 API指非線程對象的方法如 notify,wait等)
2.不能操做awt
3.不能實現服務器功能
4.不能對靜態屬生存取
5.不能使用IO 操做直接存取文件系統
6.不能加載本地庫
7.不能將this 做爲變量和返回
8.不能循環調用
10. webservice和remoting區別
一、Remoting能夠靈活的定義其所基於的協議，若是定義爲HTTP，則與Web Service就沒有什麼區別了，通常都喜歡定義爲TCP，這樣比Web Service稍爲高效一些
二、Remoting不是標準，而Web Service是標準；
三、Remoting通常須要經過一個WinForm或是Windows服務進行啓動，而Web Service則須要IIS進行啓動。
四、在VS.net開發環境中，專門對Web Service的調用進行了封裝，用起來比Remoting方便
建議仍是採用Web Service好些，對於開發來講更容易控制
Remoting通常用在C/S的系統中，Web Service是用在B/S系統中
11. Hiberbate優化方法有那些？
1) 儘可能使用many-to-one，避免使用單項one-to-many
2) 靈活使用單向one-to-many
3) 不用一對一，使用多對一代替一對一
4) 配置對象緩存，不使用集合緩存
5) .一對多使用Bag 多對一使用Set
6) 繼承使用顯示多態 HQL:from object polymorphism="exlicit" 避免查處全部對象
7) 消除大表，使用二級緩存
12. Struts1.X 中ActionServlet、 ActionForm 、Action、 ActionMapping各起什麼做用？
1) Actionservlet爲控制器，接受用戶請求並派發給相應的Action組件處理；
2) ActionForm主要用於封裝請求中的數據和簡單驗證
3) Action組件具體對用戶的請求進行處理
4) ActionMapping封裝當前用戶請求Action相關的配置信息
數據庫部分：
1. 數據庫系統是由哪幾個部分組成的
數據庫系統由數據庫(DB),數據管理系統(DBMS),應用程序,用戶和硬件組成,其中最關鍵的部分是數據庫.
2. 什麼是操做系統
操做系統（Operating System，簡稱OS）是一管理電腦硬件與軟件資源的程序，同時也是計算機系統的內核與基石。操做系統是一個龐大的管理控制程序，大體包括5個方面的管理功能:進程與處理機管理、做業管理、存儲管理、設備管理、文件管理。目前微機上常見的操做系統有DOS、OS/二、UNIX、XENIX、LINUX、Windows、Netware等
3. 解釋樂觀鎖悲觀鎖及實現
樂觀鎖與悲觀鎖是對於併發性的限制。鎖是具備排他性的。悲觀鎖，是悲觀的認爲本身在讀取數據的時候別人也在對數據進行讀寫，因此在本身讀寫數據的時候對數據進行鎖定，直到本身操做完畢。樂觀鎖正好是相反的，是樂觀的認爲在本身對數據進行讀寫的時候不會有其餘人對數據進行讀寫，因此不進行數據庫機制的限制，而是進行，版本的限制，並且樂觀鎖不光光只有版本限制，還有更新時間限制，與字段對比限制。用悲觀鎖機制製做的軟件表明做品是VSS，用樂觀鎖機制製做的軟件表明做品是CVS。
下面咱們看看怎麼調用悲觀鎖，我只寫一個代碼片斷，其餘地方沒有大的改變，若是你們想嘗試下結果的話，能夠本身寫下看看， session.load(User.class,1,LockMode.UPGRADE);經過這句話調用鎖機制，若是其餘人想要用的話呢，就要一直等到 Transaction commit之後才能夠。
樂觀鎖，樂觀鎖其實並非一種鎖，而是一種衝突檢測機制，他能夠隨時改變數據，可是在save和update的時候會進行檢測，檢測版本是否符合標準，若是版本小於等於新版本就不會對數據進行改動，相反還會報錯，說是一個髒數據，說明數據有問題，這樣也會形成更新丟失。
咱們要怎麼調用樂觀鎖呢，相對於悲觀鎖，樂觀鎖的調用仍是比較麻煩的，咱們須要在數據庫中加入version，也須要在持久類中加入verison，這個version不用咱們進行管理是由hibernate進行管理的。還要在*.hbm.xml中的class標籤中配置上
optimistic-lock="verson"這裏說明的是這個version不是字段，而是你樂觀鎖採用哪一種機制，這裏寫成version意思就是採用版本判斷這個機制，而後還要在主鍵id下面配置<version name=" "/>這個name後面跟的就是數據庫中的字段名。
4. ORACKE建立表空間student
create tablespace student
logging
datafile 'E:\oracle\product\10.2.0\oradata\testserver\ student.dbf'
size 32m
autoextend on
next 32m maxsize 2048m
extent management local;
5. 在mysql中建立一個臨時表 並說明臨時表的使用限制
CREATE TEMPORARY TABLE tmp_table
ALTER DATABASE TEMPFILE ' tmp_table ' AUTOEXTEND ON MAXSIZE 8000M
6. Mysql支持事務嗎
在缺省模式下，MYSQL是autocommit模式的，全部的數據庫更新操做都會即時提交，因此在缺省狀況下，mysql是不支持事務的。
7. 一張表有多個相同的id，查詢出ID相同的，並顯示出有多少個相同的？
Select eid,count(*) from employee group by eid having count(eid)>1
8. 一張學生表student，有字段班級classid，學號id，成績grade
（1）求各個班的平均成績
Select classid,avg(grade) from student group by classid
（2）查詢出比該班平均成績高的學生的全部信息
select w.id,w. grade,b.avg_ grade from student w,(
select classid,avg(grade) avg_grade from student group by classid) b
where w. classid =b. classid and w.grade >b.avg_grade;
9. 改錯 select c1,c2,c3 from T1 group by c1,c2 having c1>1
C3不在group by 子句中
10. ORACLE數據庫中系統全局區的簡稱是： 程序全局區是:
系統全局區的簡稱是：SGA 程序全局區是:PGA
11. 去年的今日是哪一天？SQL語句
select add_months(sysdate,-12) from dual
12. 中國人事部想開發一個系統，紀錄全部國民跳槽紀錄，以及對企業信息，國民信息進行管理，中國人事部擁有的資源有:中國全部企業信息，中國國國民信息，根據以上信息，進行數據庫設計
企業信息:eid,name…
國民信息:rid,name…
工做記錄：id,eid,rid,startDate,endDate…
13. 在網絡數據庫中，其他各節點爲終端向A發數據庫請求屬於什麼式的數據庫系統
集中式數據庫系統：在這種系統中，整個DBMS的核心，數據庫和應用程序都放在主機上，用戶經過終端來併發地存取數據，共享數據資源，這種系統又稱爲主從式或主機／終端式系統。
14. 一個用戶具備多個角色請查該表具備該用戶的全部角色的其餘用戶
select distinct eid
from user_role scx
where not exists
(select *from user_role scy
where scy.eid='a00001' and
not exists
(select * from user_role scz
where scz.eid=scx.eid
and scz.rid=scy.rid));
15. 什麼是oracle 的CBO？什麼是RBO？什麼狀況下oracle 使用CBO
Rule Based Optimizer（RBO）基於規則
Cost Based Optimizer（CBO）基於成本，或者講統計信息
ORACLE 提供了CBO、RBO兩種SQL優化器。CBO在ORACLE7 引入，但在ORACLE8i 中才成熟。ORACLE 已經明確聲明在ORACLE9i以後的版本中(ORACLE 10G )，RBO將再也不支持。所以選擇CBO 是必然的趨勢。
CBO和 RBO做爲不一樣的SQL優化器，對SQL語句的執行計劃產生重大影響，若是要對現有的應用程序從RBO向CBO移植，則必須充分考慮這些影響，避免SQL 語句性能急劇降低；可是，對新的應用系統，則能夠考慮直接使用CBO，在CBO模式下進行SQL語句編寫、分析執行計劃、性能測試等工做，這須要開發者對 CBO的特性比較熟悉。
16. 用SQL查出表中主鍵以及表之間的關係
select cu.* from user_cons_columns cu, user_constraints au where cu.constraint_name = au.constraint_name and au.constraint_type = 'P' and au.table_name ='EMP'
17. 獲取某日期的當月最後一天
select last_day(sysdate) from dual;
18. 當數據庫中數據存儲數據不少時，應該怎樣優化？
1、把數據、日誌、索引放到不一樣的I/O設備上，增長讀取速度，之前能夠將Tempdb應放在RAID0上，SQL2000不在支持。數據量（尺寸）越大，提升I/O越重要.
2、縱向、橫向分割表，減小表的尺寸(sp_spaceuse)
3、升級硬件
4、根據查詢條件,創建索引,優化索引、優化訪問方式，限制結果集的數據量。注意填充因子要適當（最好是使用默認值0）。索引應該儘可能小，使用字節數小的列建索引好（參照索引的建立）,不要對有限的幾個值的字段建單一索引如性別字段
5、提升網速;
19. 用一個SQL語句清楚XX子段的重複記錄，保留主建最小的一條
delete from people where xx in (select xx from people group by xx having count(xx) > 1)
and id not in (select min(id) from people group by xx
20. How to avoid sql injection？ 翻譯就是 如何避免SQL注入？
1， 使用參數化的過濾性語句 要防護SQL注入，用戶的輸入就絕對不能直接被嵌入到SQL語句中。相反，用戶的輸入必須進行過濾，或者使用參數化的語句
2， 還要避免使用解釋程序，由於這正是黑客們藉以執行非法命令的手段。
3， 防範SQL注入，還要避免出現一些詳細的錯誤消息，由於黑客們能夠利用這些消息。要使用一種標準的輸入確認機制來驗證全部的輸入數據的長度、類型、語句、企業規則等
4， 還有很重要的一點 應該在Web應用程序開發過程的全部階段實施代碼的安全檢查。首先，要在部署Web應用以前實施安全測試，還應當在部署以後用漏洞掃描工具和站點監視工具對網站進行測試
21. 項目中 出入庫單據超過100萬條,系統在單據調出,保存過程當中速度較慢,緣由有哪些？怎麼提升速度？
答：慢有不少狀況，
狀況1：遠程查詢，其實可能查詢不慢，因爲數據量大，傳輸過程慢
狀況2：WHERE 後面的比較數據太多，好比 like 類的語句
狀況3：須要哪一個字段只取那個字段就好了，好比select * from a與select b,c,d from a速度是有差距的
提升速度方案：數據庫按期維護，壓縮，把不經常使用的數據備份後放入備份庫裏，查詢時查備份庫等；索引約束過多會引發插入數據過慢、索引與檢索沒法起到做用；SQL優化很重要；存儲的服務器性能也很重要，100萬的數據量已經能夠考慮分區存儲數據了；（第七次考試）
操做系統、項目管理、前沿技術、軟件測試、智力題
1. Ajax、jms、pojo名詞的理解
Ajax：異步JavaScript和XML，是一種用於建立更好更快以及交互性更強的 Web 應用程序的技術。
Jms：（java message service）JAVA消息服務。是一個Java平臺中關於面向消息中間件（MOM）的API。
主要實現各個應用程序之間的通信。包括點對點和廣播
Pojo：簡單的Java對象，實際就是普通JavaBeans。POJO有一些private的參數做爲對象的屬性。而後針對每一個參數定義了get和set方法做爲訪問的接口
2. 列舉五個如今時髦的技術，並說明理由
struts struts2 ibatis hibernate spring ejb jquery extjs
3. 若是你同事犯了很大的錯，可是在會議上，你的領導沒有批評你的同事，卻批評了你，你該怎麼辦？
開會的時候即便有再大的委屈也不能爭吵或者在會上解釋，由於這樣每每會拔苗助長，能夠過後找領導解釋，這樣既保證了領導的權威，並在他冷靜後再解釋也能達到咱們想要的結果。
4. 剛纔的辦公室裏有哪幾中電器設備？考察學生對身邊事務的觀察力；
5. 醫生交給你6個藥丸，讓你每隔半小時吃一次，多久才能吃完？
一次吃一顆：兩個半小時吃完
一次吃兩顆：一個小時吃完
一次吃三顆：30分鐘吃完
一次吃6顆：幾秒鐘
6. 小明參加400米賽跑，他超過了第二名，那麼他如今是第幾名？
第二名
7. 若是你的項目程序運行很慢你估計是那點的問題
系統優化涉及到軟件的各個方面：需求、模塊劃分、數據庫設計、程序編碼以及一些特殊的優化方法如緩存技術等。 在系統開發告一段落狀況下，提升已有系統的性能，減小如內存、數據庫、網絡帶寬等資源的佔用。
硬件方面：CPU和風扇是否正常運轉並足夠製冷，是否有足夠的內存和磁盤空間等
8. Linux在目錄user下新建文件夾T和t1，在t1下新建T2
ü 強力刪除t1目錄及其下全部
ü 拷貝文件A.txt到/root/t2路徑下
ü 修改/etc/profile文件後，除重啓計算機外，如何即時生效？
ü 用命令的方法導出D:\mysql，Bin路徑D:\mysql\bin
9. XP中IIS中是否能夠同時安裝2個wed?爲何？如何操做？
答：能夠；
ü 創建第一個Web站點
好比本機的IP地址爲192.168.0.1，本身的網頁放在D:\Wy目錄下，網頁的首頁文件名爲Index.htm，如今想根據這些創建好本身的Web服務器。
對於此Web站點，咱們能夠用現有的「默認Web站點」來作相應的修改後，就能夠輕鬆實現。請先在「默認Web站點」上單擊右鍵，選「屬性」，以進入名爲「默認Web站點屬性」設置界面。
1）．修改綁定的IP地址：轉到「Web站點」窗口，再在「IP地址」後的下拉菜單中選擇所需用到的本機IP地址「192.168.0.1」。
2）．修改主目錄：轉到「主目錄」窗口，再在「本地路徑」輸入（或用「瀏覽」按鈕選擇）好本身網頁所在的「D:\Wy」目錄。
3）．添加首頁文件名：轉到「文檔」窗口，再按「添加」按鈕，根據提示在「默認文檔名」後輸入本身網頁的首頁文件名「Index.htm」。
4）．添加虛擬目錄：好比你的主目錄在「D:\Wy」下，而你想輸入「192.168.0.1/test」的格式就可調出「E:\All」中的網頁文件，這裏面的「test」就是虛擬目錄。請在「默認Web站點」上單擊右鍵，選「新建→虛擬目錄」，依次在「別名」處輸入「test」，在「目錄」處輸入「E:\All」後再按提示操做便可添加成功。
5）．效果的測試：打開IE瀏覽器，在地址欄輸入「192.168.0.1」以後再按回車鍵，此時就可以調出你本身網頁的首頁，則說明設置成功！
注：具體不一樣的電腦會有不一樣的選項名稱，但大致上仍是能夠找到了（多試一下）。
ü 添加更多的Web站點
1）．多個IP對應多個Web站點
若是本機已綁定了多個IP地址，想利用不一樣的IP地址得出不一樣的Web頁面，則只需在「默認Web站點」處單擊右鍵，選「新建→站點」，而後根據提示在「說明」處輸入任意用於說明它的內容（好比爲「個人第二個Web站點」）、在「輸入Web站點使用的IP地址」的下拉菜單處選中需給它綁定的IP地址便可；當創建好此Web站點以後，再按上步的方法進行相應設置。
2）．一個IP地址對應多個Web站點
當按上步的方法創建好全部的Web站點後，對於作虛擬主機，能夠經過給各Web站點設不一樣的端口號來實現，好比給一個Web站點設爲80，一個設爲81，一個設爲82……，則對於端口號是80的Web站點，訪問格式仍然直接是IP地址就能夠了，而對於綁定其餘端口號的Web站點，訪問時必須在IP地址後面加上相應的端口號，也即便用如 「http://192.168.0.1:81」 的格式。
很顯然，改了端口號以後使用起來就麻煩些。若是你已在DNS服務器中將全部你須要的域名都已經映射到了此唯一的IP地址，則用設不一樣「主機頭名」的方法，可讓你直接用域名來完成對不一樣Web站點的訪問。
好比你本機只有一個IP地址爲192.168.0.1，你已經創建（或設置）好了兩個Web站點，一個是「默認Web站點」，一個是「個人第二個Web站點」，如今你想輸入「www.enanshan.com」可直接訪問前者，輸入「www.popunet.com」可直接訪問後者。其操做步驟以下：
（1）請確保已先在DNS服務器中將你這兩個域名都已映射到了那個IP地址上；並確保全部的Web站點的端口號均保持爲80這個默認值。
（2）再依次選「默認Web站點→右鍵→屬性→Web站點」，單擊「IP地址」右側的「高級」按鈕，在「此站點有多個標識下」雙擊已有的那個IP地址（或單擊選中它後再按「編輯」按鈕），而後在「主機頭名」下輸入「www.enanshan.com」再按「肯定」 按鈕保存退出。
（3）接着按上步一樣的方法爲「個人第二個Web站點」設好新的主機頭名爲「www.popunet.com」便可。
（4）最後，打開你的IE瀏覽器，在地址欄輸入不一樣的網址，就能夠調出不一樣Web站點的內容了。
ü 多個域名對應同個Web站點
你只需先將某個IP地址綁定到Web站點上，再在DNS服務器中，將所需域名所有映射向你的這個IP地址上，則你在瀏覽器中輸入任何一個域名，都會直接獲得所設置好的那個網站的內容。
10. excel中不須要顯示單元格數值爲0的數值時？如何操做
工具→選項→視圖→選項卡里面下方有一個「零值」，前面的勾取消便可
11. excel是否能夠隱藏網格線？
能夠，工具→選項→視圖→選項卡里面下方有一個「網格線」，前面的勾取消便可
12. 會計科目按性質分哪幾類？
答：資產、負債、全部者權益、收入、費用。
13. 一份好的缺陷報告要那些關鍵要素？
1. 缺陷概要
2. 簡單的缺陷描述
3. 產生缺陷的先決條件及重現步驟
4. 預期結果和實際結果，必要的截圖
5. 嚴重性及優先級
6. 標記該缺陷出現的頻率
14. 一個優秀的測試要那些素質
測試的目標是找出軟件缺陷，軟件測試員得基本素質是：打破砂鍋問到底
測試員應具有的素質：
1. 探索精神：不會懼怕進入陌生的環境
2. 故障排除能手：善於發現問題的癥結
3. 不懈努力：不停的嘗試。他們可能會碰到轉瞬即逝或者難以重建的軟件缺陷，不會心存僥倖，而是盡一切可能去尋找
4. 創造性：測試顯而易見的事實那不是軟件測試員，他們的工做是想出富有創意甚至超常的手段來尋找軟件缺陷
5. 追求完美：力求完美，可是知道某些沒法企及時不去苛求，而是盡力接近目標
6. 判斷準確：軟件測試員要決定測試內容、測試時間，以及看到的問題是否算真正的缺陷
7. 說服力：善於表達觀點，代表軟件缺陷爲什麼必須修復，並經過實際演示力陳觀點
8. 在編程方面受過教育
15. C語言：函數打開，關閉，隨機讀寫問件
FILE *fp;/*定義文件類型的指針,它將指向你所要打開的文件,之後向文件寫入數據或者是從文件中讀取數據都須要用到他*/
Include 「stdio.h」
Fp=fopen() //打開文件
fclose(fp) //關閉文件
fseek(FILE *stream, long offset, int fromwhere);
16. 黑盒，白盒測試是什麼？區別？
黑盒：也稱功能測試或數據驅動測試。把被測試對象當作一個黑盒子，測試人員徹底不考慮程序內部結構和處理過程。只在軟件的接口處進行測試，根據需求規格說明書檢查程序是否知足功能要求。黑盒測試有如下幾個方面，但主要仍是功能部分測試。
1. 正確性：計算結果，命名等
2. 可用性：是否知足軟件的需求說明
3. 邊界值
4. 性能：正常使用時系統完成一個任務須要的時間是否在能夠接受的範圍內
5. 壓力測試：多用戶狀況考慮使用
6. 錯誤恢復：錯誤處理，頁面數據驗證等
白盒：也稱結構測試或邏輯驅動測試。把測試對象看做一個打開的盒子，測試人員須瞭解程序的內部結構和處理過程，以檢查處理過程的細節爲基礎，對程序中儘量多的邏輯路徑進行測試，檢查內部控制結構和數據結構是否有錯，實際的運行狀態和預期的狀態是否一致。白盒測試主要特徵是測試對象進入了代碼內部，根據開發人員本身對代碼的理解和接觸所進行的軟件測試，這一階段測試以軟件開發人員爲主。
17. 3G的瞭解和見解
3G是一個比較熱的話題，WCDMA,TDSCDMA,CDMA2000三種標準開啓了三國爭霸的序幕，對於電信行業的發展這是好事，畢竟競爭有利於消費者，但3G業務仍是偏高。
3G是第三代移動通訊技術的簡稱，是指支持高速數據傳輸的蜂窩移動通信技術，3G服務能同時傳送聲音及數據信息。其表明特徵是提供高速數據業務。3G是將無線通與國際互聯網等多媒體通訊結合的新一代移動通訊系統。3表明3G時代下的移動+寬帶+固網+手機+……融合。
18. 12個球，其中一個重量不同，稱三次，找出不同的那個
12顆球分3組。
第一次使用天平：任意將兩組至於天平上每邊4顆，有兩種狀況：
A：若是天平任保持平衡，那麼那一顆就在其他4顆裏。
第二次，在其他4顆裏任選兩顆，放在天平上，便可排除掉兩顆。
B：若是不平衡，則任意在天平一側的盤子裏拿兩顆和其他4顆中的兩顆互換。此爲第二次使用天平。
如天平平衡，那麼你拿走的那兩顆就有一顆是要找的。如天平不平衡，那麼放進去的那兩顆就有一顆是
第三次，將其中一顆與已知的一顆標準球稱，便可知道結果。
19. 美國有多少輛汽車？
答：（分析）這道試題並不難，我想它可能只是想考察一下應聘者的應變能力，即在短期內快速應對不規範問題的能力。我當時的回答是：美國有多少人？這些人裏又有多少人會開車？而會開車的人裏又有多少有這樣的經濟能力能夠購買汽車？能夠購買汽車的人裏是否是都已經買了？這些問題解決了，那答案天然就知道了。
企業回覆：很明顯，這是一道答案開放的試題。它是爲了考察應聘者可否對一個問題進行符合邏輯的創造性思考，並迅速經過這種思考尋求到解決問題的辦法。至於答案，咱們顯然並不關心。這道題的指向性很明顯，應聘者是否能在很短的時間裏對出其不意的問題作出反應，並可以合乎邏輯地回答這樣的問題，咱們一樣但願可以獲得出其不意的答案。有很多人經過在網上搜集這種試題來準備答案，顯然違背了企業的本意，你們要記住：重複的答案都不是好答案。
同類型題目:
世界上一共有多少個鋼琴調音師？ 調音師的人數取決於有多少鋼琴須要調音。調音師的工做量由鋼琴的數量和調音的頻度決定。美國共有3億人口，按三口之家計算，全美國共有1億個家庭，若是一半家庭即5000萬個家庭屬於富裕階層，擁有鋼琴比例按10％這個比例可能有點偏高，但在推算大體比例時是容許的計算，那麼就有500萬個家庭擁有鋼琴，這樣，全美國就有500萬架鋼琴。若是每架鋼琴一年調音一次，一個調音師一年調音1000架次的話，那麼全美國調音師的數量就是500萬除以1000，等於5000人。世界人口有60多億，是美國的20倍，但調音師應該不足美國的20倍。大致推算一下可知，美國的調音師數量約佔全世界的1／4，全世界的調音師應該有2萬人。
深圳華爲公司 筆試題
1. 單項選擇題
1．Java是從（ ）語言改進從新設計。
A．Ada B．C++ C．Pasacal D．BASIC
答案：B
2．下列語句哪個正確（ ）
A． Java程序經編譯後會產生machine code
B． Java程序經編譯後會產生byte code
C． Java程序經編譯後會產生DLL
D． 以上都不正確
答案：B
3．下列說法正確的有（ ）
A． class中的constructor不可省略
B． constructor必須與class同名，但方法不能與class同名
C． constructor在一個對象被new時執行
D． 一個class只能定義一個constructor
答案：C
4．提供Java存取數據庫能力的包是（ ）
A．java.sql B．java.awt C．java.lang D．java.swing
答案：A
5．下列運算符合法的是（ ）
A．&& B．<> C．if D．:=
答案：A
6．執行以下程序代碼
a=0;c=0;
do{
--c;
a=a-1;
}while(a>0); 後，C的值是（ ）
A．0 B．1 C．-1 D．死循環
答案：C
7．下列哪種敘述是正確的（ ）
A． abstract修飾符可修飾字段、方法和類
B． 抽象方法的body部分必須用一對大括號{ }包住
C． 聲明抽象方法，大括號無關緊要
D． 聲明抽象方法不可寫出大括號
答案：D
8．下列語句正確的是（ ）
A． 形式參數可被視爲local variable
B． 形式參數可被字段修飾符修飾
C． 形式參數爲方法被調用時，真正被傳遞的參數
D． 形式參數不能夠是對象
答案：A
9．下列哪一種說法是正確的（ ）
A． 實例方法可直接調用超類的實例方法
B． 實例方法可直接調用超類的類方法
C． 實例方法可直接調用其餘類的實例方法
D． 實例方法可直接調用本類的類方法
答案：D
2、 多項選擇題
1．Java程序的種類有（ ）
A．類（Class） B．Applet C．Application D．Servlet
答案：BC
2．下列說法正確的有（ ）
A． 環境變量可在編譯source code時指定
B． 在編譯程序時，所能指定的環境變量不包括class path
C． javac一次可同時編譯數個Java源文件
D． javac.exe能指定編譯結果要置於哪一個目錄（directory）
答案：BCD
3．下列標識符不合法的有（ ）
A．new B．$Usdollars C．1234 D．car.taxi
答案：ACD
4．下列說法錯誤的有（ ）
A． 數組是一種對象
B． 數組屬於一種原生類
C． int number=[]={31,23,33,43,35,63}
D． 數組的大小能夠任意改變
答案：BCD
5．不能用來修飾interface的有（ ）
A．private B．public C．protected D．static
答案：ACD
6．下列正確的有（ ）
A． call by value不會改變實際參數的數值
B． call by reference能改變實際參數的參考地址
C． call by reference不能改變實際參數的參考地址
D． call by reference能改變實際參數的內容
答案：ACD
7．下列說法錯誤的有（ ）
A． 在類方法中可用this來調用本類的類方法
B． 在類方法中調用本類的類方法時可直接調用
C． 在類方法中只能調用本類中的類方法
D． 在類方法中絕對不能調用實例方法
答案：ACD
8．下列說法錯誤的有（ ）
A． Java面嚮對象語言允許單獨的過程與函數存在
B． Java面嚮對象語言允許單獨的方法存在
C． Java語言中的方法屬於類中的成員（member）
D． Java語言中的方法一定隸屬於某一類（對象），調用方法與過程或函數相同
答案：ABC
9．下列說法錯誤的有（ ）
A． 能被java.exe成功運行的java class文件必須有main()方法
B． J2SDK就是Java API
C． Appletviewer.exe可利用jar選項運行.jar文件
D． 能被Appletviewer成功運行的java class文件必須有main()方法
答案：BCD
3、 判斷題
1．Java程序中的起始類名稱必須與存放該類的文件名相同。（ ） 正確
2．Unicode是用16位來表示一個字的。（ ）正確
3．原生類中的數據類型都可任意轉換。（ ） 錯誤
一、給定以下JAVA 程序片段:
class A{
public A(){
system.out.println(「A」);
}
}
class B extends A{
public B(){
System.out.println(「B」);
}
public static void main(String[] args){
B b=new B();
}
} 上述程序將( ).(選擇一項)
A、 不能經過編譯
B、經過編譯,輸出爲: A B
C、經過編譯,輸出爲: B
D、經過編譯,輸出爲: A
二、某一 java程序中有以下代碼：
Datalnputstream din=new DataInputstream（
new BufferedInputstream (new FileInputstream(「employee.dat」) ));
假設在employee.dat文件中只有以下一段字符：abcdefg。則：System.out.println(din)在屏幕上打印（）．（選擇一項）
A、A
B、B
C、97
D、98
三、給定java代碼片斷，以下：
int i=0,j=-1;
switch(i){
case 0,1:j=1;
case 2:j=2;
}
System.out.print("j="+j); 編譯運行，正確的是（）。（選擇一項）
A、程序編譯出錯
B、j=1
C、j=2
D、j=0
四、在Java中，下面關於構造函數的描述正確的是（）。（選擇一項）
A、類必須有顯式構造函數
B、它的返回類型是void
C、它和類有相同的名稱，但它不能帶任何參數
D、以上皆非
五、 在JAVA編程中，Swing包中的組件處理事件時，下面（）是正確的。（選擇一項）
A、 Swing包中的組件也是採用事件的受權得理模型來處理事件的
B、 Swing包中組件產生的事件類型，也都帶有一個Ｊ字母，如：JmouseEvent
C、Swing包中的組件也能夠採用事件的傳遞處理機制
D、 Swing包的組件所對應的事件適配器也是帶有Ｊ字母的，如：JmouseAdapter
六、public class EqTest {
public static void main(String args[]){
EqTest e=new EqTest();
}
EqTest(){
String s="Java"; String s2="java";
//在這兒放置測試代碼
{
System.out.println("相等");
}else {
System.out.println("不相等");
}
}
} 在上面的Java代碼的註釋行位置，放置（）測試代碼能輸出「相等」結果。（選擇一項）
A、if(s==s2)
B、if(s.equals(s2))
C、if(s.equalsIgnoreCase(s2))
D、if(s.noCaseMatch(s2))
七、 在類的說明符中，被指定爲私有的數據能夠被如下（）訪問。（選擇一項）
A、程序中的任何函數
B、其餘類的成員函數
C、類中的成員函數
D、派生類中的成員函數
八、 在JAVA編程中，如下（）命令用來執行java類文件。（選擇一項）
A、javac
B、java
C、appletviewer
D、以上全部選項都不正確
九、Java中，下面的方法能夠正確的建立一個Swing標籤組件是（）（選擇兩項）
A、ImageIcon icon = new ImageIcon(
B、ImageIcon icon = new ImageIcon(
C、ImageIcon icon=new ImageIcon(
D、JLabel label=new JLabel(SwingConstants.LEFT);
十、分析下面的用Java語言編寫的trythis()方法：
public void trythis(){
try{
System.out.print("a");
problem();
}catch(RuntimeException e){
System.out.print("b");
}catch(Exception e){
System.out.print("c");
}finally{
System.out.print("d");
}
System.out.print("e");
} 當該方法被調用時，若是其中的problem()方法引起一個RuntimeException類的異常，那麼輸出結果將是（）。（選擇一項）
A、abcde
B、abd
C、abde
D、abe
十一、 public class MyClass1{
public static void main (String argv[]){
}
_____ class MyInner { }
} 在以上java代碼中的橫線上，可放置（）修飾符。（選擇三項）
A、public
B、private
C、static
D、friend
十二、public class test3{
public static void main(String args[]){
for(int i=0;i<3;i++){
for(int j=3; j>0;j--){
if(i==j)
continue;
System.out.println(「i=」+i+」j=」+j)
}
}
}
} 上面的JAVA代碼編譯運行後，下列選項中，（）會出如今輸出結果中，（選擇三項）
A、i=0 j=3
B、i=0 j=0
C、i=2 j=2
D、i=0 j=2
E、i=1 j=2
1三、以下Java代碼段，體現了（）概念。（選擇一項）
.........
public void aMethod(String s){ .........}
public void aMethod(int i){.........}
public void aMethod(int I,float f){ .........}
.........
A、多繼承
B、重載
C、重寫
D、多態
1四、java語言中，下列時處理輸出操做的全部類的基礎的是（）（選擇一個）
A、DataOutput
B、OutputStream
C、BufferedOutputStream
D、IOStream
1五、在jave中，類Worker是類Person的子類，Worker的構造方法中有一句」super()」, 該語句 （ ）。（選擇一項）
A、調用類Worker 中定義的super()方法
B、調用類Person中定義的super()方法
C、調用類Person的構造函數
D、句法錯誤
1六、在Java中，關於final關鍵字的說法正確的是（）。（選擇兩項）
A、若是修飾變量，則一旦賦了值，就等同一個常量
B、若是修飾類，則該類只能被一個子類繼承
C、若是修飾方法，則該方法不能在子類中被覆蓋
D、若是修飾方法，則該方法所在的類不能被繼承
1七、在Java中,下列選項表示字符」a」值的是().(選擇一項)
A、'a'
B、"a"
C、new Character(a)
D、\000a
1八、給定java代碼片斷，以下：
Integer a = new Integer(3);
Integer b = new Integer(3);
System.out.println(a==b); 運行後，這段代碼將輸出（）。（選擇一項）
A、true
B、false
C、0
D、1
1九、Java程序中讀入用戶輸入的一個值，要求建立一個自定義的異常，若是輸入值大於10，使用throw語句顯式地引起異常，異常輸出信息爲「something’s wrong！」，語句爲（）。（選擇一項）
A、if (I>10) throw Exception(「something’s wrong！」);
B、if (I>10) throw Exception e (「something’s wrong！」);
C、if (I>10) throw new Exception(「something’s wrong！」);
D、if (I>10) throw new Exception e (「something’s wrong！」);
20、42.給定兩個java程序,以下:Text.java的編譯運行結果是(). (選擇一項)
pubilc interface Face{ int count=40; }
pubilc class Text implements Face{
private static int counter;
pubilc static void main(String[]args){
System.out.println(++counter);
}
}
A、40
B、41
C、0
D、1
2一、給定一個Java程序代碼，以下：運行編譯後，輸出結果是(). (選擇一項)
pubilc class Test{
int count = 9;
pubilc void count1(){
int count = 10;
System.out.println("count1"+count);
}
pubilc void count2(){
System.out.println("count2"+count);
}
pubilc static void main(String args[]){
Test t =new Twst();
t.count1();
t.count2();
}
}
A、count1=9 count2=9
B、count1=10 count2=9
C、count1=10 count2=10
D、count1=9 count2=10
2二、給定java代碼以下：要使用這段代碼可以編譯成功，橫線處能夠填入().(選擇兩項)
pubilc int count(char c,int i,double d){ return______; }
A、c*i
B、c*(int)d
C、(int)c*d
D、i*d
2三、 在 JAVA編程中，Java編譯器會將Java程序轉換爲（）。（選擇一項）
A、字節碼
B、可執行代碼
C、機器代碼
D、以上全部選項都不正確
2四、在J2EE中，下列元素通過排序的集合類是（）。（選擇一項）
A、LinkedList
B、Stack
C、Hashtable
D、TreeSet
2五、分析下面的Java程序：
public class yy {
public static void main(String[] ards) throws Exception {
try {
throw new Exception();
}catch(Exception e){
System.out.println("Caught in main()");
}
System.out.println("nothing");
}
} 輸出結果爲（）。（選擇一項）
A、Caught in main() nothing
B、Caught in main()
C、nothing
D、沒有任何輸出
2六、編譯並運行下面的Java代碼段：
char c='a'; switch (c) {
case 'a': System.out.println("a");
default: System.out.println("default");
} 輸出結果是（）。（選擇一項）
A、代碼沒法編譯，由於switch語句沒有一個合法的表達式
B、a default
C、a
D、default
2七、在Java中，執行下面的語句後，c的值爲（）。（選擇一項）
String s= "Jessica "; char c=s.charAt(6);
A、null www.87717.com
B、' '
C、'c '
D、'a '
2八、在J2EE中，下面的代碼中出現編譯錯誤的是（）。（選擇一項）
A、File f = new File("/","autoexec.bat");
B、DataInputStream din = new DataInputStream(new FileInputStream("autoexec.bat"));
C、InputStreamReader in = new InputStreamReader(System.in);
D、OutputStreamWriter out = new OutputStreamWriter(System.in);
2九、在JavaSwing編程中，要獲取每次選擇的JComboBox對象的選項值，能夠使用()類型的監聽器. (選擇兩項)
A、ActionListener
B、ltemListener
C、KeyListener
D、SelectionListener
30、在Java中，下面關於包的陳述中正確的是（）。（選擇兩項）
A、包的聲明必須是源文件的第一句代碼
B、包的聲明必須緊跟在import語句的後面
C、只有公共類才能放在包中
D、能夠將多個源文件中的類放在同一個包中
3一、在Java中，要想使只有定義該類所在的包內的類能夠訪問該類，應該用（ ）關鍵字。（選擇一項）
A、不須要任何關鍵字
B、private
C、final
D、protected
3二、包pack1的類class1中有成員方法：
protected void method_1(){…}
private void method_2(){…}
public void method_3(){…}
void method_4(){…}, 在包pack2中的類class2是class1的子類，你在class2中能夠調用方法（）。（選擇兩項）
A、method_1
B、method_2
C、method_3
D、method_4
3三、在Java語言中，小明在他的包mypackage中定義了類My_Class，在mypackage的子包mysubpackage中也有個類My_Class。小明用.import mypackage：引入包，執行其中的語句：My_Class NewClass=New My_Class();時，將發生（）。（選擇一項）
A、建立一個類mypackage.My_Class對象
B、建立一個類mypackage. Mysubpackage.My_Class的對象
C、該語句是錯誤的
D、建立一個類mypackage.My_Class的對象和一個類mypackage. Mysubpackage.My_Class的對象
3四、在JavaSwing編程中，給定一個java程序main方法的代碼片斷以下:
JFrame jf=new JFrame();
jf.getContentpane().setLayout(null);
jf.setSize(200,200);
jf.setVisible(true); //a
要在界面上顯示以下組件，則應在A處填入(). (選擇一項)
A、JTextArea text = text JTextArea(100,100);
text.setBounds(10,10,150,100); jf.getContentpane().add(text);
B、JTextField text = text JTextField(100,100); JScrollpane text=new JScrollpane(text);
jf.setBounds(10,10,150,100);jf.getContentpane().add(jp);
C、JTextArea text = new JTextArea(100,1); JScrollpane jp=new JScrollpane(text);
jp.setBounds(10,10,150,100); jf.getContentpane().add(jp);
D、JTextArea text = new JTextArea(100,100);JScrollpane
jp=new JScrollpane(text); jp.setBounds(10,10,150,100);
jf.getContentpane().add(jp);
3五、在JAVA語言中，你的按鈕要實現下面的功能：當鼠標按下按鈕時，顯示「鼠標已按下」；當釋放按鍵時，顯示「鼠標已釋放」。你必須具體定義接口MouseListener的（）方法。（選擇兩項）
A、mouseClicked
B、mouseEntered
C、mouseExited
D、mousePressed
E、mouseReleaseed
3六、JAVA中，爲了辨別用戶關閉窗口的時間，要實現監聽器接口（）。（選擇一項）
A、MouseListener
B、ActionListener
C、WindowListener
D、以上都要
3七、在Java語言中，當一個類的某個變量聲明爲protected時下列說法正確的是（）。（選擇兩項）
A、只有同一類中的成員才能訪問它
B、不一樣包中的任何其餘類都可以訪問它
C、同包中的任何其餘類可以訪問它
D、不一樣包中的子類能夠訪問該變量
3八、在Java事件處理模型中，當按下鼠標按鈕時，處理（）事件。（選擇一項）
A、mouseReleased
B、mouseExited
C、mousePressed
D、mouseDown
3九、 String s1=new String(「Hello」); String s2=new String(「there」); String s3=new String("0"); 上面是JAVA程序的一些聲明，如下選項中可以經過編譯的是（）。（選擇一項）
A、a) s3=s1+s2
B、b) s3=s1&s2
C、c) s3=s1||s2
D、d) s3=s1&&s2
40、在Java中，調用Math.random() 方法可能返回的結果是（）。（選擇一項）
A、132.34
B、0.342
C、29.34E10
D、1.0009
4一、 在Java語言中，Panel默認的佈局管理器是（）。（選擇一項）
A、BorderLayout
B、FlowLayout
C、GridLayout
D、GridBagLayout
4二、public class MyClass1 {
public static void main(String argv[]){ }
______class MyInner{} } 在以上Java代碼的橫線上，可放置（）修飾符。（選擇兩項）
A、public
B、private
C、implements
D、friend
4三、在java中，下列賦值語句正確的是（）。（選擇二項）
A、char c='a';
B、char c="a";
C、char c=97;
D、char c=new Character('a');
4四、與傳統的過程編程不一樣，面向對象方法的主要思想是（）。（選擇兩項）
A、真實反映用戶的實際需求
B、將現實世界的一切抽象爲實體或對象
C、將現實世界細分爲一個過程化實現
D、將軟件組織成爲對象的集合，將數據結構和行爲結合在一塊兒
4五、在Java中，根據你的理解，下列方法（）多是類Orange的構造方法。(選擇3項)
A、Orange（）{…}
B、Orange（…）｛…｝
C、Public void Orange(){…}
D、Public Orange(){…}
E、Public Orange Constuctor(){…}
4六、45.在Java中,()藉口位於集合框架的頂層. (選擇一項)
A、Map
B、Collection
C、Set
D、List
4七、給定某java程序片斷，以下： int i=1; int j=i++; if((i>++j)&&(i++==j)) i+=j; System.out.println(i); 該程序運行後，i的輸出結果爲（）。（選擇一項）
A、1
B、2
C、3
D、4
4八、在Java中，假設咱們有一個實現ActionListener接口的類，如下方法中（）可以爲一個Button類註冊這個類。（選擇一項）
A、addListener()
B、addActionListener()
C、addButtonListener()
D、setListener()
4九、44.在JAVA中的佈局管理器，如下說法中錯誤的是(). (選擇一項)
A、FlowLayout以由上到下的方式從左到右排列組件
B、BorderLayout使用 "東"."西"."南"."北","居中"來指定組件的位置
C、GridLayout能夠建立網格佈局，網格佈局中各組的大小能夠任意調整
D、能夠經過容器的setLayout方法爲容器指定佈局管理
50、研究下面的Java代碼：
public class testException{
public static void main(String args[]){
int n[]={0,1,2,3,4};
int sum=0;
try {
for(int i=1;i<6;i++)
sum=sum+n[i];
System.out.println("sum="+sum);
} catch(ArrayIndexOutOfBoundsExpception e) {
System.out.println("數組越界");
} finally{
System.out.println("程序結束");
}
}
} 輸出結果將是（）。（選擇一項）
A、10 數組越界 程序結束
B、10 程序結束
C、數組越界 程序結束
D、程序結束
一、在java中若是聲明一個類爲final，表示什麼意思？
答：final是最終的意思，final可用於定義變量、方法和類但含義不一樣，聲明爲final的類不能被繼承。
二、父類的構造方法是否能夠被子類覆蓋（重寫）？
答：父類的構造方法不能夠被子類覆蓋，由於父類和子類的類名是不可能同樣的。
三、請講述String 和StringBuffer的區別。
答：String 類所定義的對象是用於存放「長度固定」的字符串。
StringBuffer類所定義的對象是用於存放「長度可變更」的字符串。
四、若是有兩個類A、B（注意不是接口），你想同時使用這兩個類的功能，那麼你會如何編寫這個C類呢？
答：由於類A、B不是接口，因此是不能夠直接繼承的，但能夠將A、B類定義成父子類，那麼C類就能實現A、B類的功能了。假如A爲B的父類，B爲C的父類，此時C就能實現A、B的功能。
五、結合Java視頻Lesson5（多線程），分析sleep()和wait()方法的區別。
答： Sleeping睡眠的意思 : sleep() 方法用來暫時停止執行的線程。在睡眠後，線程將進入就緒狀態。
waiting等待的意思: 若是調用了 wait() 方法，線程將處於等待狀態。用於在兩個或多個線程併發運行時。
六、談談你對抽象類和接口的理解。
答：定義抽象類的目的是提供可由其子類共享的通常形式、子類能夠根據自身須要擴展抽象類、抽象類不能實例化、抽象方法沒有函數體、抽象方法必須在子類中給出具體實現。他使用extends來繼承。
接口：一個接口容許一個類從幾個接口繼承而來，Java 程序一次只能繼承一個類但能夠實現幾個接口，接口不能有任何具體的方法，接口也可用來定義可由類使用的一組常量。其實現方式是interface來實現。
- 1. j2EE經典面試題
- 2. J2EE經典面試題及答案05
- 3. j2EE 面試題
- 4. J2EE面試題
- 5. 經典面試題
- 6. 經典測試面試題
- 7. Spark經典面試題
- 8. php經典面試題
- 9. 經典.net面試題目
- 10. [轉]Loadrunner經典面試題
- 更多相關文章...
- • Swift 字典 - Swift 教程
- • Lua 調試(Debug) - Lua 教程
- • 爲了進字節跳動，我精選了29道Java經典算法題，帶詳細講解
- • 使用阿里雲OSS+CDN部署前端頁面與加速靜態資源
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. j2EE經典面試題
- 2. J2EE經典面試題及答案05
- 3. j2EE 面試題
- 4. J2EE面試題
- 5. 經典面試題
- 6. 經典測試面試題
- 7. Spark經典面試題
- 8. php經典面試題
- 9. 經典.net面試題目
- 10. [轉]Loadrunner經典面試題