1. hibernate中離線查詢去除重復項怎么加條件？
dc.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);
2. http協議及端口,smtp協議及端口
http：超文本傳輸協議 端口 80
smtp：簡單郵件傳輸協議 端口25
4. Servlet創建過程及生命周期Servlet 在容器中運行時，其實例的創建及銷毀等是由容器進行控制。
Servlet 的創建有兩種方法。
1）. 客戶端請求對應的 Servlet 時，創建 Servlet 實例;大部分Servlet 都是這種 Servlet 。
2）. 通過在web.xml 中設置load-on-startup來創建servlet實例，這種實例在Web 應用啟動時，立即創建Servlet 實例
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的實現原理
1、客戶端初始化一個指向Servlet容器（例如Tomcat）的請求
2、這個請求經過一系列的過濾器（Filter）（這些過濾器中有一個叫做ActionContextCleanUp的可選過濾器，這個過濾器對於Struts2和其他框架的集成很有幫助，例如：SiteMesh Plugin）；
3、接着FilterDispatcher被調用，FilterDispatcher詢問ActionMapper來決定這個請求是否需要調用某個Action；
4、如果ActionMapper決定需要調用某個Action，FilterDispatcher把請求的處理交給ActionProxy；
5、ActionProxy通過Configuration Manager詢問框架的配置文件，找到需要調用的Action類；
6、ActionProxy創建一個ActionInvocation的實例。
7、ActionInvocation實例使用命名模式來調用，在調用Action的過程前后，涉及到相關攔截器（Intercepter）的調用。
8、一旦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 的隔離級別
1、Serializable：最嚴格的級別，事務串行執行，資源消耗最大；
2、REPEATABLE READ：(repeatable read)保證了一個事務不會修改已經由另一個事務讀取但未提交（回滾）的數據。避免了“臟讀取”和“不可重復讀取”的情況，但是帶來了更多的性能損失。
3、READ COMMITTED:大多數主流數據庫的默認事務等級，保證了一個事務不會讀到另一個並行事務已修改但未提交的數據，避免了“臟讀取”。該級別適用於大多數系統。
4、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來實現訪問數據庫記錄可以采用下面的幾個步驟：
1、 通過驅動器管理器獲取連接接口。
2、 獲得Statement或它的子類。
3、 限制Statement中的參數。
4、 執行Statement。
5、 查看返回的行數是否超出范圍。
6、 關閉Statement。
7、 處理其它的Statement
8、 關閉連接接
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）
1、模型（Model）
模型是應用程序的主體部分。模型表示業務數據，或者業務邏輯.
2、視圖（View）
視圖是應用程序中用戶界面相關的部分，是用戶看到並與之交互的界面。
3、控制器（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 索引需要占物理空間，除了數據表占數據空間之外，每一個索引還要占一定的物理空間，如果要建立聚 簇索引，那么需要的空間就會更大。
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. 函數和過程的區別？
過程和函數區別如下：
1、標識符不同:函數的標識符為FUNCTION，過程為：PROCEDURE。
2、話法不同：函數中一般不用變量形參，用函數名直接返回函數值；而過程如有返回值，則必須用變量形參返回。
3、函數在定義時一定要進行函數的類型說明，過程則不進行過程的類型說明。
4、調用方式不同:函數的調用出現在表達式中，過程調用，由獨立的過程調用語句來完成。
5、過程一般會被設計成求若干個運算結果，完成一系列的數據處理，或與計算無關的各種
操作；而函數往往只為了求得一個函數值。
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.
1、view視圖層一般運用jsp或者html進行實現，展現給用戶看；
2、controller控制層struts有個文件叫struts-config.xml，該文件里面定義個處理后的跳轉頁面；
3、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的使用方法和用途主要分為幾類？
答 1、內建Annotation——Java5.0版在java語法中經常用到的內建Annotation：
2、開發者自定義Annotation：由開發者自定義Annotation類型；
3、使用第三方開發的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上統一、開放的標准，如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有以下幾點區別？
1、TRUNCATE在各種表上無論是大的還是小的都非常快。如果有ROLLBACK命令DELETE將被撤銷，而TRUNCATE則不會被撤銷。
2、TRUNCATE是一個DDL語言，向其他所有的DDL語言一樣，他將被隱式提交，不能對TRUNCATE使用ROLLBACK命令。
3、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/2、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上統一、開放的標准，如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. 智力題：
1、有一輛火車以15公里/小時從洛杉磯開往紐約，一輛火車以20公里/小時從紐約開往洛杉磯，一只鴿子以30公里/小時從洛杉磯開往紐約，鴿子和兩輛火車同時出發，鴿子遇到火車轉頭，向另一輛火車飛，直到兩輛火車相遇，問鴿子飛了多少公里？
假設洛杉磯到紐約的距離為s
那小鳥飛行的距離就是(s/(15+20))*30。
2、有兩根不勻稱的香，燒完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二級緩存
1、首先要打開二級緩存，在hibernate.cfg.xml中添加如下配置：
<property name="hibernate.cache.use_second_level_cache">true</property>
2、Hibernate的二級緩存使用第三方的緩存工具來實現，所以我們需要指定Hibernate使用哪個
緩存工具。如下配置指定Hibernate使用EhCache緩存工具。
<property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property>
3、Hibernate在默認情況下並不會對所有實體對象進行緩存，所以，我們需要指定緩存哪些對象，
在實體對象的映射文件中（相應的<class>標簽內部），添加如下配置：
<cache usage="read-only"/>
usage="read-only"是“只讀”緩存策略。
注意，這個<cache>標簽只能放在<class>標簽的內部，而且必須處在<id>標簽的前面！！！
這個<cache>標簽放在哪些<class>標簽下面，就說明會多這些類的對象進行緩存
4、對於第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區別
1、Remoting可以靈活的定義其所基於的協議，如果定義為HTTP，則與Web Service就沒有什么區別了，一般都喜歡定義為TCP，這樣比Web Service稍為高效一些
2、Remoting不是標准，而Web Service是標准；
3、Remoting一般需要通過一個WinForm或是Windows服務進行啟動，而Web Service則需要IIS進行啟動。
4、在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/2、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
二、 多項選擇題
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
三、 判斷題
1．Java程序中的起始類名稱必須與存放該類的文件名相同。（ ） 正確
2．Unicode是用16位來表示一個字的。（ ）正確
3．原生類中的數據類型均可任意轉換。（ ） 錯誤
1、給定如下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
2、某一 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
3、給定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
4、在Java中，下面關於構造函數的描述正確的是（）。（選擇一項）
A、類必須有顯式構造函數
B、它的返回類型是void
C、它和類有相同的名稱，但它不能帶任何參數
D、以上皆非
5、 在JAVA編程中，Swing包中的組件處理事件時，下面（）是正確的。（選擇一項）
A、 Swing包中的組件也是采用事件的授權得理模型來處理事件的
B、 Swing包中組件產生的事件類型，也都帶有一個Ｊ字母，如：JmouseEvent
C、Swing包中的組件也可以采用事件的傳遞處理機制
D、 Swing包的組件所對應的事件適配器也是帶有Ｊ字母的，如：JmouseAdapter
6、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))
7、 在類的說明符中，被指定為私有的數據可以被以下（）訪問。（選擇一項）
A、程序中的任何函數
B、其他類的成員函數
C、類中的成員函數
D、派生類中的成員函數
8、 在JAVA編程中，以下（）命令用來執行java類文件。（選擇一項）
A、javac
B、java
C、appletviewer
D、以上所有選項都不正確
9、Java中，下面的方法可以正確的創建一個Swing標簽組件是（）（選擇兩項）
A、ImageIcon icon = new ImageIcon(
B、ImageIcon icon = new ImageIcon(
C、ImageIcon icon=new ImageIcon(
D、JLabel label=new JLabel(SwingConstants.LEFT);
10、分析下面的用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
11、 public class MyClass1{
public static void main (String argv[]){
}
_____ class MyInner { }
} 在以上java代碼中的橫線上，可放置（）修飾符。（選擇三項）
A、public
B、private
C、static
D、friend
12、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
13、如下Java代碼段，體現了（）概念。（選擇一項）
.........
public void aMethod(String s){ .........}
public void aMethod(int i){.........}
public void aMethod(int I,float f){ .........}
.........
A、多繼承
B、重載
C、重寫
D、多態
14、java語言中，下列時處理輸出操作的所有類的基礎的是（）（選擇一個）
A、DataOutput
B、OutputStream
C、BufferedOutputStream
D、IOStream
15、在jave中，類Worker是類Person的子類，Worker的構造方法中有一句”super()”, 該語句 （ ）。（選擇一項）
A、調用類Worker 中定義的super()方法
B、調用類Person中定義的super()方法
C、調用類Person的構造函數
D、句法錯誤
16、在Java中，關於final關鍵字的說法正確的是（）。（選擇兩項）
A、如果修飾變量，則一旦賦了值，就等同一個常量
B、如果修飾類，則該類只能被一個子類繼承
C、如果修飾方法，則該方法不能在子類中被覆蓋
D、如果修飾方法，則該方法所在的類不能被繼承
17、在Java中,下列選項表示字符”a”值的是().(選擇一項)
A、'a'
B、"a"
C、new Character(a)
D、\000a
18、給定java代碼片段，如下：
Integer a = new Integer(3);
Integer b = new Integer(3);
System.out.println(a==b); 運行后，這段代碼將輸出（）。（選擇一項）
A、true
B、false
C、0
D、1
19、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
21、給定一個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
22、給定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
23、 在 JAVA編程中，Java編譯器會將Java程序轉換為（）。（選擇一項）
A、字節碼
B、可執行代碼
C、機器代碼
D、以上所有選項都不正確
24、在J2EE中，下列元素經過排序的集合類是（）。（選擇一項）
A、LinkedList
B、Stack
C、Hashtable
D、TreeSet
25、分析下面的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、沒有任何輸出
26、編譯並運行下面的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
27、在Java中，執行下面的語句后，c的值為（）。（選擇一項）
String s= "Jessica "; char c=s.charAt(6);
A、null www.87717.com
B、' '
C、'c '
D、'a '
28、在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);
29、在JavaSwing編程中，要獲取每次選擇的JComboBox對象的選項值，可以使用()類型的監聽器. (選擇兩項)
A、ActionListener
B、ltemListener
C、KeyListener
D、SelectionListener
30、在Java中，下面關於包的陳述中正確的是（）。（選擇兩項）
A、包的聲明必須是源文件的第一句代碼
B、包的聲明必須緊跟在import語句的后面
C、只有公共類才能放在包中
D、可以將多個源文件中的類放在同一個包中
31、在Java中，要想使只有定義該類所在的包內的類可以訪問該類，應該用（ ）關鍵字。（選擇一項）
A、不需要任何關鍵字
B、private
C、final
D、protected
32、包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
33、在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的對象
34、在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);
35、在JAVA語言中，你的按鈕要實現下面的功能：當鼠標按下按鈕時，顯示“鼠標已按下”；當釋放按鍵時，顯示“鼠標已釋放”。你必須具體定義接口MouseListener的（）方法。（選擇兩項）
A、mouseClicked
B、mouseEntered
C、mouseExited
D、mousePressed
E、mouseReleaseed
36、JAVA中，為了辨別用戶關閉窗口的時間，要實現監聽器接口（）。（選擇一項）
A、MouseListener
B、ActionListener
C、WindowListener
D、以上都要
37、在Java語言中，當一個類的某個變量聲明為protected時下列說法正確的是（）。（選擇兩項）
A、只有同一類中的成員才能訪問它
B、不同包中的任何其他類都能夠訪問它
C、同包中的任何其他類能夠訪問它
D、不同包中的子類可以訪問該變量
38、在Java事件處理模型中，當按下鼠標按鈕時，處理（）事件。（選擇一項）
A、mouseReleased
B、mouseExited
C、mousePressed
D、mouseDown
39、 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
41、 在Java語言中，Panel默認的布局管理器是（）。（選擇一項）
A、BorderLayout
B、FlowLayout
C、GridLayout
D、GridBagLayout
42、public class MyClass1 {
public static void main(String argv[]){ }
______class MyInner{} } 在以上Java代碼的橫線上，可放置（）修飾符。（選擇兩項）
A、public
B、private
C、implements
D、friend
43、在java中，下列賦值語句正確的是（）。（選擇二項）
A、char c='a';
B、char c="a";
C、char c=97;
D、char c=new Character('a');
44、與傳統的過程編程不同，面向對象方法的主要思想是（）。（選擇兩項）
A、真實反映用戶的實際需求
B、將現實世界的一切抽象為實體或對象
C、將現實世界細分為一個過程化實現
D、將軟件組織成為對象的集合，將數據結構和行為結合在一起
45、在Java中，根據你的理解，下列方法（）可能是類Orange的構造方法。(選擇3項)
A、Orange（）{…}
B、Orange（…）｛…｝
C、Public void Orange(){…}
D、Public Orange(){…}
E、Public Orange Constuctor(){…}
46、45.在Java中,()借口位於集合框架的頂層. (選擇一項)
A、Map
B、Collection
C、Set
D、List
47、給定某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
48、在Java中，假設我們有一個實現ActionListener接口的類，以下方法中（）能夠為一個Button類注冊這個類。（選擇一項）
A、addListener()
B、addActionListener()
C、addButtonListener()
D、setListener()
49、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、程序結束
1、在java中如果聲明一個類為final，表示什么意思？
答：final是最終的意思，final可用於定義變量、方法和類但含義不同，聲明為final的類不能被繼承。
2、父類的構造方法是否可以被子類覆蓋（重寫）？
答：父類的構造方法不可以被子類覆蓋，因為父類和子類的類名是不可能一樣的。
3、請講述String 和StringBuffer的區別。
答：String 類所定義的對象是用於存放“長度固定”的字符串。
StringBuffer類所定義的對象是用於存放“長度可變動”的字符串。
4、如果有兩個類A、B（注意不是接口），你想同時使用這兩個類的功能，那么你會如何編寫這個C類呢？
答：因為類A、B不是接口，所以是不可以直接繼承的，但可以將A、B類定義成父子類，那么C類就能實現A、B類的功能了。假如A為B的父類，B為C的父類，此時C就能實現A、B的功能。
5、結合Java視頻Lesson5（多線程），分析sleep()和wait()方法的區別。
答： Sleeping睡眠的意思 : sleep() 方法用來暫時中止執行的線程。在睡眠后，線程將進入就緒狀態。
waiting等待的意思: 如果調用了 wait() 方法，線程將處於等待狀態。用於在兩個或多個線程並發運行時。
6、談談你對抽象類和接口的理解。
答：定義抽象類的目的是提供可由其子類共享的一般形式、子類可以根據自身需要擴展抽象類、抽象類不能實例化、抽象方法沒有函數體、抽象方法必須在子類中給出具體實現。他使用extends來繼承。
接口：一個接口允許一個類從幾個接口繼承而來，Java 程序一次只能繼承一個類但可以實現幾個接口，接口不能有任何具體的方法，接口也可用來定義可由類使用的一組常量。其實現方式是interface來實現。