935
常見麵試題匯總
轉自： https://blog.csdn.net/u010509143/article/details/11812299
1、用String的方法將數據類型轉換為String。
2、有一個不定長度的String，其中前麵是字母，後邊是數字,例如：”abcd123.456″,
要求寫一個方法得到其中的數字以String的形式返回,數字保留小數點後兩位，不四舍五入，截去多餘小
數,例如：”abcd123.456″，得到”123.45″
如果數字沒有小數點,要得到兩位為0的小數，例如：”abcd123″，得到”123.00″.
答案如下:
1、String.valueOf(1.23)
2、 public String getString(String str){
String getNumber;
getNumber = str.replaceAll(“[a-z|A-Z]“, ”");
if(getNumber.indexOf(“.”) == -1){
getNumber = getNumber+”.00″;
} else {
if(getNumber.indexOf(“.”)== getNumber.length()-1){
getNumber = getNumber+”00″;
} else if (getNumber.indexOf(“.”)== getNumber.length()-2){
getNumber = getNumber+”0″;
} else {
getNumber = getNumber.substring(0, getNumber.indexOf(“.”)+3);
}
}
return getNumber;
}
—————————————————————-
1 麵向對象的特征？
1）對象
對象是運行期的基本實體，它是一個封裝了數據和操作這些數據的代碼的邏輯實體。
2）類
類是具有相同類型的對象的抽象。一個對象所包含的所有數據和代碼可以通過類來構造。
3）封裝
封裝是將數據和代碼捆綁到一起，避免了外界的幹擾和不確定性。對象的某些數據和代碼可以是私有的，
不能被外界訪問，以此實現對數據和代碼不同級別的訪問權限。
4）繼承
繼承是讓某個類型的對象獲得另一個類型的對象的特征。通過繼承可以實現代碼的重用：從已存在的類派
生出的一個新類將自動具有原來那個類的特性，同時，它還可以擁有自己的新特性。
5）多態
多態是指不同事物具有不同表現形式的能力。多態機製使具有不同內部結構的對象可以共享相同的外部接
口，通過這種方式減少代碼的複雜度。
6）動態綁定
綁定指的是將一個過程調用與相應代碼鏈接起來的行為。動態綁定是指與給定的過程調用相關聯的代碼隻
有在運行期才可知的一種綁定，它是多態實現的具體形式。
7）消息傳遞
對象之間需要相互溝通，溝通的途徑就是對象之間收發信息。消息內容包括接收消息的對象的標識，需要
調用的函數的標識，以及必要的信息。消息傳遞的概念使得對現實世界的描述更容易。
2 tomcat的內存的配置？
tomcat默認可以使用的內存為128MB，在較大型的應用項目中，這點內存是不夠的，需要調大。
Unix下，在文件{tomcat_home}/bin/catalina.sh的前麵，增加如下設置：
JAVA_OPTS=’-Xms【初始化內存大小】 -Xmx【可以使用的最大內存】’
需要把這個兩個參數值調大。例如：
JAVA_OPTS=’-Xms256m -Xmx512m’
表示初始化內存為256MB，可以使用的最大內存為512MB
3 doGet() 和 doPost() 的區別？
doGet() 和 doPost() 接收兩個參數：HttpServletRequest 請求和HttpServletResponse響應。
HTTP 協議要麼通過在 URL 中放置參數來向 Web 服務器傳遞信息，要麼獨立於 URL 傳遞信息。第一種稱
作 GET 命令，而第二種稱作 POST 命令。GET 命令的優點是，URL 包含了檢索請求信息所需的所有信息
。因此，可將其加入書簽以便將來重新調用。而 POST 命令獨立於 URL 發送附加信息，提供了更好的安
全性。當需要發送比較大量的信息時，該方法也更為合適。其缺點就是不能被加入書簽。
4 常用的標準的sql語句？
增加: insert into tbl_emp(name,password,id) values(yxx,123,12);
刪除:delete from tbl_emp where name= ”yxx”;
查詢: select * from tbl_emp where name=”yxx”;
更新: update tbl_emp set name=”xiaoxin” where id = 12;
5 string 和 stringbuffer的區別?
它們都是處理字符串的類,但是它們有一個最大的區別,那就是,String對象是存儲你不能改動的文本字符
串,相反,如果你希望改動,則應使用StringBuffer類作為替換.
６在jsp頁麵中如何傳遞對象?
request，session，application，cookie等
7 常用的集合類?
java.util 中的集合類包含 Java 中某些最常用的類。 最常用的集合類是 List 和 Map。 List 的具體
實現包括 ArrayList 和 Vector，它們是可變大小的列表，比較適合構建、存儲和操作任何類型對象的元
素列表。 List 適用於按數值索引訪問元素的情形。
Map 提供了一個更通用的元素存儲方法。 Map 集合類用於存儲元素對（稱作“鍵”和“值”），其中每
個鍵映射到一個值。 從概念上而言，您可以將 List 看作是具有數值鍵的 Map。 而實際上，除了 List
和 Map 都在定義 java.util 中外，兩者並沒有直接的聯係。本文將著重介紹核心 Java 發行套件中附帶
的 Map，同時還將介紹如何采用或實現更適用於您應用程序特定數據的專用 Map。
8 常出現的異常?
9 經常使用的包,接口,類 請各舉出5個?
10 接口和抽象類的區別?
聲明方法的存在而不去實現它的類被叫做抽象類（abstract class），它用於要創建一個體現某些基本行
為的類，並為該類聲明方法，但不能在該類中實現該類的情況。不能創建abstract 類的實例。然而可以
創建一個變量，其類型是一個抽象類，並讓它指向具體子類的一個實例。不能有抽象構造函數或抽象靜態
方法。Abstract 類的子類為它們父類中的所有抽象方法提供實現，否則它們也是抽象類為。取而代之，
在子類中實現該方法。知道其行為的其它類可以在類中實現這些方法。
接口（interface）是抽象類的變體。在接口中，所有方法都是抽象的。多繼承性可通過實現這樣的
接口而獲得。接口中的所有方法都是抽象的，沒有一個有程序體。接口隻可以定義static final成員變量
。接口的實現與子類相似，除了該實現類不能從接口定義中繼承行為。當類實現特殊接口時，它定義（即
將程序體給予）所有這種接口的方法。然後，它可以在實現了該接口的類的任何對象上調用接口的方法。
由於有抽象類，它允許使用接口名作為引用變量的類型。通常的動態聯編將生效。引用可以轉換到接口類
型或從接口類型轉換，instanceof 運算符可以用來決定某對象的類是否實現了接口。
11 動態include()和靜態include()的區別?
12 servlet的生命周期?(介紹過———————————)
13 struts的原理?
14 數據連接池的原理?
連接池允許我們通過一個緩衝池重用現有的連接對象，避免每次使用連接對象時都要新建一個對象。采用
連接池之後，隻要少量的連接對象就可以滿足大量客戶端的需要。
每一個連接池都與一個獨立的連接字符串及其事務上下文關聯。每次打開一個新的連接，數據提供者
會嚐試將指定的連接字符串與連接池的字符串進行匹配。如果匹配失敗，數據提供者創建一個新的連接並
將它加入連接池。連接池被創建之後，除非進程結束，否則不會被拆除。有人認為這種處理方式會影響性
能，其實不然，維護一個不活動的或者空的連接池不需要多少開銷。
連接池創建之後，係統會創建一些連接對象並將它們加入連接池，直至達到額定的最小連接對象數量
。以後，係統會根據需要新建和加入連接對象，一直到達最大連接對象數量限額為止。如果程序請求一個
連接對象時沒有空閑的連接對象可用，且連接池裏麵的對象數量已達到上限，則請求被放入隊列，一旦有
連接被釋放回緩衝池就立即取出使用。
避免用編程的方式構造連接字符串。如果通過合並多個輸入數據的方式構造出連接字符串，很容易給
注入式攻擊以可乘之機。如果必須用到用戶輸入的數據，務必進行嚴格的驗證。
15 j2ee的設計模式?
Session Facade Pattern：使用SessionBean訪問EntityBean
Message Facade Pattern：實現異步調用
EJB Command Pattern：使用Command JavaBeans取代SessionBean，實現輕量級訪問
Data Transfer Object Factory：通過DTO Factory簡化EntityBean數據提供特性
Generic Attribute Access：通過AttibuteAccess接口簡化EntityBean數據提供特性
Business Interface：通過遠程（本地）接口和Bean類實現相同接口規範業務邏輯一致性
16 線程的同步方法?(介紹過——————————————–)
17 四種會話跟蹤技術?
會話作用域ServletsJSP 頁麵描述
page否是代表與一個頁麵相關的對象和屬性。一個頁麵由一個編譯好的 Java servlet 類（可以帶有任何
的 include 指令，但是沒有 include 動作）表示。這既包括 servlet 又包括被編譯成 servlet 的 JSP
頁麵
request是是代表與 Web 客戶機發出的一個請求相關的對象和屬性。一個請求可能跨越多個頁麵，涉及多
個 Web 組件（由於 forward 指令和 include 動作的關係）
session是是代表與用於某個 Web 客戶機的一個用戶體驗相關的對象和屬性。一個 Web 會話可以也經常
會跨越多個客戶機請求
application是是代表與整個 Web 應用程序相關的對象和屬性。這實質上是跨越整個 Web 應用程序，包
括多個頁麵、請求和會話的一個全局作用域
18 解釋 forward include和redirect的不同?
forward與include共亨Request範圍內的對象,而redirect則不行，即：如果一個javabean被聲明為
request範圍的話，則被forward到的資源也可以訪問這個javabean,而redriect則不行。
forward與include基本上都是轉發到context內部的資源，而redirect可以重定向到外部的資源,如：
req.sendRedriect(“https://www.mocuai.com“);
19 jsp的內值對象?
request 用戶端請求，此請求會包含來自GET/POST請求的參數
response 網頁傳回用戶端的回應
pageContext 網頁的屬性是在這裏管理
session 與請求有關的會話期
application servlet 正在執行的內容
out 用來傳送回應的輸出
config servlet的構架部件
page JSP網頁本身
exception 針對錯誤網頁，未捕捉的例外
20 EJB的角色和三個對象
EJB角色主要包括Bean開發者 應用組裝者 部署者 係統管理員 EJB容器提供者 EJB服務器提供者
三個對象是Remote（Local）接口、Home（LocalHome）接口，Bean類
ArithmeticException, ArrayStoreException, BufferOverflowException, BufferUnderflowException,
CannotRedoException, CannotUndoException, ClassCastException, CMMException,
ConcurrentModificationException, DOMException, EmptyStackException,
IllegalArgumentException, IllegalMonitorStateException, IllegalPathStateException,
IllegalStateException,
ImagingOpException, IndexOutOfBoundsException, MissingResourceException,
NegativeArraySizeException, NoSuchElementException, NullPointerException,
ProfileDataException, ProviderException, RasterFORMatException, SecurityException,
SystemException, UndeclaredThrowableException, UnmodifiableSetException,
UnsupportedOperationException
1、jsp有哪些內置對象?作用分別是什麼?
答:JSP共有以下9種基本內置組件（可與ASP的6種內部組件相對應）：
request 用戶端請求，此請求會包含來自GET/POST請求的參數
response 網頁傳回用戶端的回應
pageContext 網頁的屬性是在這裏管理
session 與請求有關的會話期
application servlet 正在執行的內容
out 用來傳送回應的輸出
config servlet的構架部件
page JSP網頁本身
exception 針對錯誤網頁，未捕捉的例外
2、jsp有哪些動作?作用分別是什麼?
答:JSP共有以下6種基本動作
jsp:include：在頁麵被請求的時候引入一個文件。
jsp:useBean：尋找或者實例化一個JavaBean。
jsp:setProperty：設置JavaBean的屬性。
jsp:getProperty：輸出某個JavaBean的屬性。
jsp:forward：把請求轉到一個新的頁麵。
jsp:plugin：根據瀏覽器類型為Java插件生成OBJECT或EMBED標記
3、JSP中動態INCLUDE與靜態INCLUDE的區別？
答：動態INCLUDE用jsp:include動作實現
<jsp:include page=”included.jsp” flush=”true” />它總是會檢查所含文件中的變化，適合用於包含動態頁麵，並且可以帶參數
靜態INCLUDE用include偽碼實現,定不會檢查所含文件的變化，適用於包含靜態頁麵
<%@ include file=”included.htm” %>
4、兩種跳轉方式分別是什麼?有什麼區別?
答：有兩種，分別為：
<jsp:include page=”included.jsp” flush=”true”>
<jsp:forward page= “nextpage.jsp”/>
前者頁麵不會轉向include所指的頁麵，隻是顯示該頁的結果，主頁麵還是原來的頁麵。執行完後還會回來，相當於函數調用。並且可以帶參數.後者完全轉向新頁麵，不會再回來。相當於go to 語句。
JAVA部分二
1、作用域public,private,protected,以及不寫時的區別
答：區別如下：
作用域 當前類 同一package 子孫類 其他package
public √ √ √ √
protected √ √ √ ×
friendly √ √ × ×
private √ × × ×
不寫時默認為friendly
2、ArrayList和Vector的區別,HashMap和Hashtable的區別
答：就ArrayList與Vector主要從二方麵來說.
一.同步性:Vector是線程安全的，也就是說是同步的，而ArrayList是線程序不安全的，不是同步的
二.數據增長:當需要增長時,Vector默認增長為原來一培，而ArrayList卻是原來的一半
就HashMap與HashTable主要從三方麵來說。
一.曆史原因:Hashtable是基於陳舊的Dictionary類的，HashMap是Java 1.2引進的Map接口的一個實現
二.同步性:Hashtable是線程安全的，也就是說是同步的，而HashMap是線程序不安全的，不是同步的
三.值：隻有HashMap可以讓你將空值作為一個表的條目的key或value
3、char型變量中能不能存貯一個中文漢字?為什麼?
答：是能夠定義成為一個中文的，因為java中以unicode編碼，一個char占16個字節，所以放一個中文是沒問題的
4、多線程有幾種實現方法,都是什麼?同步有幾種實現方法,都是什麼?
答：多線程有兩種實現方法，分別是繼承Thread類與實現Runnable接口
同步的實現方麵有兩種，分別是synchronized,wait與notify
5、繼承時候類的執行順序問題,一般都是選擇題,問你將會打印出什麼?
答:父類：
package test;
public class FatherClass
{
public FatherClass()
{
System.out.println(“FatherClass Create”);
}
}
子類:
package test;
import test.FatherClass;
public class ChildClass extends FatherClass
{
public ChildClass()
{
System.out.println(“ChildClass Create”);
}
public static void main(String[] args)
{
FatherClass fc = new FatherClass();
ChildClass cc = new ChildClass();
}
}
輸出結果：
C:\>java test.ChildClass
FatherClass Create
FatherClass Create
ChildClass Create
6、內部類的實現方式?
答：示例代碼如下：
package test;
public class OuterClass
{
private class InterClass
{
public InterClass()
{
System.out.println(“InterClass Create”);
}
}
public OuterClass()
{
InterClass ic = new InterClass();
System.out.println(“OuterClass Create”);
}
public static void main(String[] args)
{
OuterClass oc = new OuterClass();
}
}
輸出結果:
C:\>java test/OuterClass
InterClass Create
OuterClass Create
再一個例題：
public class OuterClass {
private double d1 = 1.0;
//insert code here
}
You need to insert an inner class declaration at line 3. Which two inner class declarations are
valid?(Choose two.)
A. class InnerOne{
public static double methoda() {return d1;}
}
B. public class InnerOne{
static double methoda() {return d1;}
}
C. private class InnerOne{
double methoda() {return d1;}
}
D. static class InnerOne{
protected double methoda() {return d1;}
}
E. abstract class InnerOne{
public abstract double methoda();
}
說明如下：
一.靜態內部類可以有靜態成員，而非靜態內部類則不能有靜態成員。 故 A、B 錯
二.靜態內部類的非靜態成員可以訪問外部類的靜態變量，而不可訪問外部類的非靜態變量；return d1 出錯。
故 D 錯
三.非靜態內部類的非靜態成員可以訪問外部類的非靜態變量。 故 C 正確
四.答案為C、E
SELEVLET部分三
Servlet方麵
1、說一說Servlet的生命周期?
答:servlet有良好的生存期的定義，包括加載和實例化、初始化、處理請求以及服務結束。這個生存期由javax.servlet.Servlet接口的init,service和destroy方法表達。
2、Servlet版本間(忘了問的是哪兩個版本了)的不同?
希望大家補上，謝謝
3、JAVA SERVLET API中forward() 與redirect()的區別？
答:前者僅是容器中控製權的轉向，在客戶端瀏覽器地址欄中不會顯示出轉向後的地址；後者則是完全的跳轉，瀏覽器將會得到跳轉的地址，並重新發送請求鏈接。這樣，從瀏覽器的地址欄中可以看到跳轉後的鏈接地址。所以，前者更加高效，在前者可以滿足需要時，盡量使用forward()方法，並且，這樣也有助於隱藏實際的鏈接。在有些情況下，比如，需要跳轉到一個其它服務器上的資源，則必須使用sendRedirect()方法。
4、Servlet的基本架構
public class ServletName extends HttpServlet {
public void doPost(HttpServletRequest request, HttpServletResponse response) throws
ServletException, IOException {
}
public void doGet(HttpServletRequest request, HttpServletResponse response) throws
ServletException, IOException {
}
}
1、作用域public,private,protected,以及不寫時的區別
答：區別如下：
作用域 當前類 同一package 子孫類 其他package
public √ √ √ √
protected √ √ √ ×
friendly √ √ × ×
private √ × × ×
不寫時默認為friendly
2、ArrayList和Vector的區別,HashMap和Hashtable的區別
答：就ArrayList與Vector主要從二方麵來說.
一.同步性:Vector是線程安全的，也就是說是同步的，而ArrayList是線程序不安全的，不是同步的
二.數據增長:當需要增長時,Vector默認增長為原來一培，而ArrayList卻是原來的一半
就HashMap與HashTable主要從三方麵來說。
一.曆史原因:Hashtable是基於陳舊的Dictionary類的，HashMap是Java 1.2引進的Map接口的一個實現
二.同步性:Hashtable是線程安全的，也就是說是同步的，而HashMap是線程序不安全的，不是同步的
三.值：隻有HashMap可以讓你將空值作為一個表的條目的key或value
3、char型變量中能不能存貯一個中文漢字?為什麼?
答：是能夠定義成為一個中文的，因為java中以unicode編碼，一個char占16個字節，所以放一個中文是沒問題的
4、多線程有幾種實現方法,都是什麼?同步有幾種實現方法,都是什麼?
答：多線程有兩種實現方法，分別是繼承Thread類與實現Runnable接口
同步的實現方麵有兩種，分別是synchronized,wait與notify
5、繼承時候類的執行順序問題,一般都是選擇題,問你將會打印出什麼?
答:父類：
package test;
public class FatherClass
{
public FatherClass()
{
System.out.println(“FatherClass Create”);
}
}
子類:
package test;
import test.FatherClass;
public class ChildClass extends FatherClass
{
public ChildClass()
{
System.out.println(“ChildClass Create”);
}
public static void main(String[] args)
{
FatherClass fc = new FatherClass();
ChildClass cc = new ChildClass();
}
}
輸出結果：
C:\>java test.ChildClass
FatherClass Create
FatherClass Create
ChildClass Create
6、內部類的實現方式?
答：示例代碼如下：
package test;
public class OuterClass
{
private class InterClass
{
public InterClass()
{
System.out.println(“InterClass Create”);
}
}
public OuterClass()
{
InterClass ic = new InterClass();
System.out.println(“OuterClass Create”);
}
public static void main(String[] args)
{
OuterClass oc = new OuterClass();
}
}
輸出結果:
C:\>java test/OuterClass
InterClass Create
OuterClass Create
再一個例題：
public class OuterClass {
private double d1 = 1.0;
//insert code here
}
You need to insert an inner class declaration at line 3. Which two inner class declarations are
valid?(Choose two.)
A. class InnerOne{
public static double methoda() {return d1;}
}
B. public class InnerOne{
static double methoda() {return d1;}
}
C. private class InnerOne{
double methoda() {return d1;}
}
D. static class InnerOne{
protected double methoda() {return d1;}
}
E. abstract class InnerOne{
public abstract double methoda();
}
說明如下：
一.靜態內部類可以有靜態成員，而非靜態內部類則不能有靜態成員。 故 A、B 錯
二.靜態內部類的非靜態成員可以訪問外部類的靜態變量，而不可訪問外部類的非靜態變量；return d1 出錯。
故 D 錯
三.非靜態內部類的非靜態成員可以訪問外部類的非靜態變量。 故 C 正確
四.答案為C、E
人事方麵的問題：
1 首先自我介紹下自己
2 你認為你大學期間最成功的是什麼？
3 你最大的優勢是什麼？
…….其他的就是一些家庭等情況
這是我前天在中科軟的麵試題，20分，分值最高的一道，我回答的很簡單
題：如何寫出高性能的SQL語句？
–轉
如何寫出性能優良的SQL
（1） 選擇最有效率的表名順序(隻在基於規則的優化器中有效)：
ORACLE的解析器按照從右到左的順序處理FROM子句中的表名，FROM子句中寫在最後的表(基礎表 driving table)將被最先處理，在FROM子句中包含多個表的情況下,你必須選擇記錄條數最少的表作為基礎表。如果有3個以上的表連接查詢, 那就需要選擇交叉表(intersection table)作為基礎表, 交叉表是指那個被其他表所引用的表.
（2） WHERE子句中的連接順序．：
ORACLE采用自下而上的順序解析WHERE子句,根據這個原理,表之間的連接必須寫在其他WHERE條件之前, 那些可以過濾掉最大數量記錄的條件必須寫在WHERE子句的末尾.
（3） SELECT子句中避免使用 ‘ * ‘：
ORACLE在解析的過程中, 會將’*’ 依次轉換成所有的列名, 這個工作是通過查詢數據字典完成的, 這意味著將耗費更多的時間
（4） 減少訪問數據庫的次數：
ORACLE在內部執行了許多工作: 解析SQL語句, 估算索引的利用率, 綁定變量 , 讀數據塊等；
（5） 在SQL*Plus , SQL*Forms和Pro*C中重新設置ARRAYSIZE參數, 可以增加每次數據庫訪問的檢索數據量 ,建議值為200
（6） 使用DECODE函數來減少處理時間：
使用DECODE函數可以避免重複掃描相同記錄或重複連接相同的表.
（7） 整合簡單,無關聯的數據庫訪問：
如果你有幾個簡單的數據庫查詢語句,你可以把它們整合到一個查詢中(即使它們之間沒有關係)
（8） 刪除重複記錄：
最高效的刪除重複記錄方法 ( 因為使用了ROWID)例子：
DELETE FROM EMP E WHERE E.ROWID > (SELECT MIN(X.ROWID)
FROM EMP X WHERE X.EMP_NO = E.EMP_NO);
（9） 用TRUNCATE替代DELETE：
當刪除表中的記錄時,在通常情況下, 回滾段(rollback segments ) 用來存放可以被恢複的信息. 如果你沒有COMMIT事務,ORACLE會將數據恢複到刪除之前的狀態(準確地說是恢複到執行刪除命令之前的狀況) 而當運用TRUNCATE時, 回滾段不再存放任何可被恢複的信息.當命令運行後,數據不能被恢複.因此很少的資源被調用,執行時間也會很短. (譯者按: TRUNCATE隻在刪除全表適用,TRUNCATE是DDL不是DML)
（10） 盡量多使用COMMIT：
隻要有可能,在程序中盡量多使用COMMIT, 這樣程序的性能得到提高,需求也會因為COMMIT所釋放的資源而減少:
COMMIT所釋放的資源:
a. 回滾段上用於恢複數據的信息.
b. 被程序語句獲得的鎖
c. redo log buffer 中的空間
d. ORACLE為管理上述3種資源中的內部花費
（11） 用Where子句替換HAVING子句：
避免使用HAVING子句, HAVING 隻會在檢索出所有記錄之後才對結果集進行過濾. 這個處理需要排序,總計等操作. 如果能通過WHERE子句限製記錄的數目,那就能減少這方麵的開銷. (非oracle中)on、where、having這三個都可以加條件的子句中，on是最先執行，where次之，having最後，因為on是先把不符合條件的記錄過濾後才進行統計，它就可以減少中間運算要處理的數據，按理說應該速度是最快的，where也應該比having快點的，因為它過濾數據後才進行sum，在兩個表聯接時才用on的，所以在一個表的時候，就剩下where跟having比較了。在這單表查詢統計的情況下，如果要過濾的條件沒有涉及到要計算字段，那它們的結果是一樣的，隻是where可以使用rushmore技術，而having就不能，在速度上後者要慢如果要涉及到計算的字段，就表示在沒計算之前，這個字段的值是不確定的，根據上篇寫的工作流程，where的作用時間是在計算之前就完成的，而having就是在計算後才起作用的，所以在這種情況下，兩者的結果會不同。在多表聯接查詢時，on比where更早起作用。係統首先根據各個表之間的聯接條件，把多個表合成一個臨時表後，再由where進行過濾，然後再計算，計算完後再由having進行過濾。由此可見，要想過濾條件起到正確的作用，首先要明白這個條件應該在什麼時候起作用，然後再決定放在那裏
（12） 減少對表的查詢：
在含有子查詢的SQL語句中,要特別注意減少對表的查詢.例子：
SELECT TAB_NAME FROM TABLES WHERE (TAB_NAME,DB_VER) = ( SELECT
TAB_NAME,DB_VER FROM TAB_COLUMNS WHERE VERSION = 604)
（13） 通過內部函數提高SQL效率.：
複雜的SQL往往犧牲了執行效率. 能夠掌握上麵的運用函數解決問題的方法在實際工作中是非常有意義的
（14） 使用表的別名(Alias)：
當在SQL語句中連接多個表時, 請使用表的別名並把別名前綴於每個Column上.這樣一來,就可以減少解析的時間並減少那些由Column歧義引起的語法錯誤.
（15） 用EXISTS替代IN、用NOT EXISTS替代NOT IN：
在許多基於基礎表的查詢中,為了滿足一個條件,往往需要對另一個表進行聯接.在這種情況下, 使用EXISTS(或NOT EXISTS)通常將提高查詢的效率. 在子查詢中,NOT IN子句將執行一個內部的排序和合並. 無論在哪種情況下,NOT IN都是最低效的 (因為它對子查詢中的表執行了一個全表遍曆). 為了避免使用NOT IN ,我們可以把它改寫成外連接(Outer Joins)或NOT EXISTS.
例子：
（高效）SELECT * FROM EMP (基礎表) WHERE EMPNO > 0 AND EXISTS (SELECT ‘X’ FROM DEPT WHERE DEPT.DEPTNO = EMP.DEPTNO AND LOC = ‘MELB’)
(低效)SELECT * FROM EMP (基礎表) WHERE EMPNO > 0 AND DEPTNO IN(SELECT DEPTNO FROM DEPT WHERE LOC = ‘MELB’)
（16） 識別’低效執行’的SQL語句：
雖然目前各種關於SQL優化的圖形化工具層出不窮,但是寫出自己的SQL工具來解決問題始終是一個最好的方法：
SELECT EXECUTIONS , DISK_READS, BUFFER_GETS,
ROUND((BUFFER_GETS-DISK_READS)/BUFFER_GETS,2) Hit_radio,
ROUND(DISK_READS/EXECUTIONS,2) Reads_per_run,
SQL_TEXT
FROM V$SQLAREA
WHERE EXECUTIONS>0
AND BUFFER_GETS > 0
AND (BUFFER_GETS-DISK_READS)/BUFFER_GETS < 0.8
ORDER BY 4 DESC;
（17） 用索引提高效率：
索引是表的一個概念部分,用來提高檢索數據的效率，ORACLE使用了一個複雜的自平衡B-tree結構. 通常,通過索引查詢數據比全表掃描要快. 當ORACLE找出執行查詢和Update語句的最佳路徑時, ORACLE優化器將使用索引. 同樣在聯結多個表時使用索引也可以提高效率. 另一個使用索引的好處是,它提供了主鍵(primary key)的唯一性驗證.。那些LONG或LONG RAW數據類型, 你可以索引幾乎所有的列. 通常, 在大型表中使用索引特別有效. 當然,你也會發現, 在掃描小表時,使用索引同樣能提高效率.
雖然使用索引能得到查詢效率的提高,但是我們也必須注意到它的代價. 索引需要空間來存儲,也需要定期維護, 每當有記錄在表中增減或索引列被修改時, 索引本身也會被修改. 這意味著每條記錄的INSERT , DELETE , UPDATE將為此多付出4 , 5 次的磁盤I/O . 因為索引需要額外的存儲空間和處理,那些不必要的索引反而會使查詢反應時間變慢.。定期的重構索引是有必要的.：
ALTER INDEX <INDEXNAME> REBUILD <TABLESPACENAME>
（18） 用EXISTS替換DISTINCT：
當提交一個包含一對多表信息(比如部門表和雇員表)的查詢時,避免在SELECT子句中使用DISTINCT. 一般可以考慮用EXIST替換, EXISTS 使查詢更為迅速,因為RDBMS核心模塊將在子查詢的條件一旦滿足後,立刻返回結果. 例子：
(低效):
SELECT DISTINCT DEPT_NO,DEPT_NAME FROM DEPT D , EMP E
WHERE D.DEPT_NO = E.DEPT_NO
(高效):
SELECT DEPT_NO,DEPT_NAME FROM DEPT D WHERE EXISTS ( SELECT ‘X’
FROM EMP E WHERE E.DEPT_NO = D.DEPT_NO);
（19） sql語句用大寫的；因為oracle總是先解析sql語句，把小寫的字母轉換成大寫的再執行
（20） 在java代碼中盡量少用連接符“＋”連接字符串！
（21） 避免在索引列上使用NOT 通常，
我們要避免在索引列上使用NOT, NOT會產生在和在索引列上使用函數相同的影響. 當ORACLE”遇到”NOT,他就會停止使用索引轉而執行全表掃描.
1 “你最多能出差多久”
2 “你怎麼看待加班”
第一題答一年以下直接刷掉，第二題答要加班費直接pass
更過分的是讓我和應屆生一起筆試！
工資範圍3000-4000……我簡直無語了，看現在是金融危機就這麼剝削！
真夠牛的！它以為自己真是大爺！
今天到中科軟科麵試了，因為之前投了兩份簡曆，一個是應聘JAVA開發，另一個是BI，因到一個叫金融事業部麵試，以為就是麵試BI的，沒想到一位JJ過來了是麵試開發，拿了兩份題叫1個半小時做完，然後可以走人。JAVA的題比較簡單，內容大概是：
打印乘法口決表：
for(int j=0;j<=i;j++){
System.out.print(j+”X”+i+”=”+j*i +”\t”) ;
if(i=j) System.out.println(“\n”);
}
}
遞歸遍曆某個目錄sinosoft下的所有java文件
public static void lisFile(String str){
File file = new File(str);
if(file.isDirectory()) {
File[] files = file.listFiles();
for(int i = 0; i < files.length; i++) {
String filename = files[i].getName();
if(filename.trim().toLowerCase().endsWith(“.java”)) {
System.out.print(“files: “+files[i].getName()+”\t”) ;
}
if(files[i].isDirectory()){
String nn=files[i].getPath() ;
lisFile(nn) ;
}
}
}
}
給出一個JDBC操作的例子，指出不完善的地方，那個例子就不說了，下麵列出一個常見的：
public static void main(String args[]){
String url = “jdbc:microsoft:sqlserver://localhost:1433;database=NorthWind” ;
String _uname = “dbtest” ;
PreparedStatement psmt = null ;
String _pwd = “889988″ ;
Connection con=null ;
try{
Class.forName(“com.microsoft.jdbc.sqlserver.SQLServerDriver”) ;
System.out.println( “類實例化成功!” );
con = DriverManager.getConnection(url,_uname,_pwd) ;
psmt = con.prepareStatement(“insert into test values(?,?)”) ;
psmt.setString(1, “Jiang hua”) ;
psmt.setString(2, “kyle@163.com“) ;
psmt.executeUpdate() ;
psmt.setString(1, “Xu Fen”) ;
psmt.setString(2, “su3@163.com“) ;
psmt.executeUpdate() ;
}catch(Exception fnot){
fnot.printStackTrace() ;
}finally{
try{
psmt.close() ;
con.close() ;
}catch(Exception e){
e.printStackTrace() ;
}
}
}
SQL 也不難的，給了兩個表，然後對兩個表進行查詢。問了主鍵,外鍵，索引有什麼作用
還有 以Struts框架為例，向別人介紹MVC模式
Java基礎方麵:
1、作用域public,private,protected,以及不寫時的區別
答：區別如下：
作用域 當前類 同一package 子孫類 其他package
public √ √ √ √
protected √ √ √ ×
friendly √ √ × ×
private √ × × ×
不寫時默認為friendly
2、ArrayList和Vector的區別,HashMap和Hashtable的區別
答：就ArrayList與Vector主要從二方麵來說.
一.同步性:Vector是線程安全的，也就是說是同步的，而ArrayList是線程序不安全的，不是同步的
二.數據增長:當需要增長時,Vector默認增長為原來一培，而ArrayList卻是原來的一半
就HashMap與HashTable主要從三方麵來說。
一.曆史原因:Hashtable是基於陳舊的Dictionary類的，HashMap是Java 1.2引進的Map接口的一個實現
二.同步性:Hashtable是線程安全的，也就是說是同步的，而HashMap是線程序不安全的，不是同步的
三.值：隻有HashMap可以讓你將空值作為一個表的條目的key或value
3、char型變量中能不能存貯一個中文漢字?為什麼?
答：是能夠定義成為一個中文的，因為java中以unicode編碼，一個char占16個字節，所以放一個中文是沒問題的
4、多線程有幾種實現方法,都是什麼?同步有幾種實現方法,都是什麼?
答：多線程有兩種實現方法，分別是繼承Thread類與實現Runnable接口
同步的實現方麵有兩種，分別是synchronized,wait與notify
5、繼承時候類的執行順序問題,一般都是選擇題,問你將會打印出什麼?
答:父類：
package test;
public class FatherClass
{
public FatherClass()
{
System.out.println(“FatherClass Create”);
}
}
子類:
package test;
import test.FatherClass;
public class ChildClass extends FatherClass
{
public ChildClass()
{
System.out.println(“ChildClass Create”);
}
public static void main(String[] args)
{
FatherClass fc = new FatherClass();
ChildClass cc = new ChildClass();
}
}
輸出結果：
C:\>java test.ChildClass
FatherClass Create
FatherClass Create
ChildClass Create
6、內部類的實現方式?
答：示例代碼如下：
package test;
public class OuterClass
{
private class InterClass
{
public InterClass()
{
System.out.println(“InterClass Create”);
}
}
public OuterClass()
{
InterClass ic = new InterClass();
System.out.println(“OuterClass Create”);
}
public static void main(String[] args)
{
OuterClass oc = new OuterClass();
}
}
輸出結果:
C:\>java test/OuterClass
InterClass Create
OuterClass Create
再一個例題：
public class OuterClass {
private double d1 = 1.0;
//insert code here
}
You need to insert an inner class declaration at line 3. Which two inner class declarations are
valid?(Choose two.)
A. class InnerOne{
public static double methoda() {return d1;}
}
B. public class InnerOne{
static double methoda() {return d1;}
}
C. private class InnerOne{
double methoda() {return d1;}
}
D. static class InnerOne{
protected double methoda() {return d1;}
}
E. abstract class InnerOne{
public abstract double methoda();
}
說明如下：
一.靜態內部類可以有靜態成員，而非靜態內部類則不能有靜態成員。 故 A、B 錯
二.靜態內部類的非靜態成員可以訪問外部類的靜態變量，而不可訪問外部類的非靜態變量；return d1 出錯。
故 D 錯
三.非靜態內部類的非靜態成員可以訪問外部類的非靜態變量。 故 C 正確
四.答案為C、E
7、垃圾回收機製,如何優化程序?
希望大家補上，謝謝
8、float型float f=3.4是否正確?
答:不正確。精度不準確,應該用強製類型轉換，如下所示：float f=(float)3.4
9、介紹JAVA中的Collection FrameWork(包括如何寫自己的數據結構)?
答：Collection FrameWork如下：
Collection
├List
│├LinkedList
│├ArrayList
│└Vector
│ └Stack
└Set
Map
├Hashtable
├HashMap
└WeakHashMap
Collection是最基本的集合接口，一個Collection代表一組Object，即Collection的元素（Elements）
Map提供key到value的映射
10、Java中異常處理機製，事件機製？
11、JAVA中的多形與繼承？
希望大家補上，謝謝
12、抽象類與接口？
答：抽象類與接口都用於抽象，但是抽象類(JAVA中)可以有自己的部分實現，而接口則完全是一個標識(同時有多重繼承的功能)。
13、Java 的通信編程，編程題(或問答)，用JAVA SOCKET編程，讀服務器幾個字符，再寫入本地顯示？
答:Server端程序:
package test;
import java.net.*;
import java.io.*;
public class Server
{
private ServerSocket ss;
private Socket socket;
private BufferedReader in;
private PrintWriter out;
public Server()
{
try
{
ss=new ServerSocket(10000);
while(true)
{
socket = ss.accept();
String RemoteIP = socket.getInetAddress().getHostAddress();
String RemotePort = “:”+socket.getLocalPort();
System.out.println(“A client come in!IP:”+RemoteIP+RemotePort);
in = new BufferedReader(new
InputStreamReader(socket.getInputStream()));
String line = in.readLine();
System.out.println(“Cleint send is :” + line);
out = new PrintWriter(socket.getOutputStream(),true);
out.println(“Your Message Received!”);
out.close();
in.close();
socket.close();
}
}catch (IOException e)
{
out.println(“wrong”);
}
}
public static void main(String[] args)
{
new Server();
}
};
Client端程序:
package test;
import java.io.*;
import java.net.*;
public class Client
{
Socket socket;
BufferedReader in;
PrintWriter out;
public Client()
{
try
{
System.out.println(“Try to Connect to 127.0.0.1:10000″);
socket = new Socket(“127.0.0.1″,10000);
System.out.println(“The Server Connected!”);
System.out.println(“Please enter some Character:”);
BufferedReader line = new BufferedReader(new
InputStreamReader(System.in));
out = new PrintWriter(socket.getOutputStream(),true);
out.println(line.readLine());
in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
System.out.println(in.readLine());
out.close();
in.close();
socket.close();
}catch(IOException e)
{
out.println(“Wrong”);
}
}
public static void main(String[] args)
{
new Client();
}
};
14、用JAVA實現一種排序，JAVA類實現序列化的方法(二種)？ 如在COLLECTION框架中，實現比較要實現什麼樣的接口？
答:用插入法進行排序代碼如下
package test;
import java.util.*;
class InsertSort
{
ArrayList al;
public InsertSort(int num,int mod)
{
al = new ArrayList(num);
Random rand = new Random();
System.out.println(“The ArrayList Sort Before:”);
for (int i=0;i<num ;i++ )
{
al.add(new Integer(Math.abs(rand.nextInt()) % mod + 1));
System.out.println(“al["+i+"]=”+al.get(i));
}
}
public void SortIt()
{
Integer tempInt;
int MaxSize=1;
for(int i=1;i<al.size();i++)
{
tempInt = (Integer)al.remove(i);
if(tempInt.intValue()>=((Integer)al.get(MaxSize-1)).intValue())
{
al.add(MaxSize,tempInt);
MaxSize++;
System.out.println(al.toString());
} else {
for (int j=0;j<MaxSize ;j++ )
{
if
(((Integer)al.get(j)).intValue()>=tempInt.intValue())
{
al.add(j,tempInt);
MaxSize++;
System.out.println(al.toString());
break;
}
}
}
}
System.out.println(“The ArrayList Sort After:”);
for(int i=0;i<al.size();i++)
{
System.out.println(“al["+i+"]=”+al.get(i));
}
}
public static void main(String[] args)
{
InsertSort is = new InsertSort(10,100);
is.SortIt();
}
}
JAVA類實現序例化的方法是實現java.io.Serializable接口
Collection框架中實現比較要實現Comparable 接口和 Comparator 接口
15、編程：編寫一個截取字符串的函數，輸入為一個字符串和字節數，輸出為按字節截取的字符串。 但是要保證漢字不被截半個，如“我ABC”4，應該截為“我AB”，輸入“我ABC漢DEF”，6，應該輸出為“我ABC”而不是“我ABC+漢的半個”。
答：代碼如下：
package test;
class SplitString
{
String SplitStr;
int SplitByte;
public SplitString(String str,int bytes)
{
SplitStr=str;
SplitByte=bytes;
System.out.println(“The String is:’”+SplitStr+”‘;SplitBytes=”+SplitByte);
}
public void SplitIt()
{
int loopCount;
loopCount=(SplitStr.length()%SplitByte==0)?(SplitStr.length()/SplitByte):(SplitStr.length()/Split
Byte+1);
System.out.println(“Will Split into “+loopCount);
for (int i=1;i<=loopCount ;i++ )
{
if (i==loopCount){
System.out.println(SplitStr.substring((i-1)*SplitByte,SplitStr.length()));
} else {
System.out.println(SplitStr.substring((i-1)*SplitByte,(i*SplitByte)));
}
}
}
public static void main(String[] args)
{
SplitString ss = new SplitString(“test中dd文dsaf中男大3443n中國43中國人
0ewldfls=103″,4);
ss.SplitIt();
}
}
16、JAVA多線程編程。 用JAVA寫一個多線程程序，如寫四個線程，二個加1，二個對一個變量減一，輸出。
希望大家補上，謝謝
17、STRING與STRINGBUFFER的區別。
答：STRING的長度是不可變的，STRINGBUFFER的長度是可變的。如果你對字符串中的內容經常進行操作，特別是內容要修改時，那麼使用StringBuffer，如果最後需要String，那麼使用StringBuffer的toString()方法
Jsp方麵
1、jsp有哪些內置對象?作用分別是什麼?
答:JSP共有以下9種基本內置組件（可與ASP的6種內部組件相對應）：
request 用戶端請求，此請求會包含來自GET/POST請求的參數
response 網頁傳回用戶端的回應
pageContext 網頁的屬性是在這裏管理
session 與請求有關的會話期
application servlet 正在執行的內容
out 用來傳送回應的輸出
config servlet的構架部件
page JSP網頁本身
exception 針對錯誤網頁，未捕捉的例外
2、jsp有哪些動作?作用分別是什麼?
答:JSP共有以下6種基本動作
jsp:include：在頁麵被請求的時候引入一個文件。
jsp:useBean：尋找或者實例化一個JavaBean。
jsp:setProperty：設置JavaBean的屬性。
jsp:getProperty：輸出某個JavaBean的屬性。
jsp:forward：把請求轉到一個新的頁麵。
jsp:plugin：根據瀏覽器類型為Java插件生成OBJECT或EMBED標記
3、JSP中動態INCLUDE與靜態INCLUDE的區別？
答：動態INCLUDE用jsp:include動作實現
<jsp:include page=”included.jsp” flush=”true” />它總是會檢查所含文件中的變化，適合用於包含動態頁麵，並且可以帶參數
靜態INCLUDE用include偽碼實現,定不會檢查所含文件的變化，適用於包含靜態頁麵
<%@ include file=”included.htm” %>
4、兩種跳轉方式分別是什麼?有什麼區別?
答：有兩種，分別為：
<jsp:include page=”included.jsp” flush=”true”>
<jsp:forward page= “nextpage.jsp”/>
前者頁麵不會轉向include所指的頁麵，隻是顯示該頁的結果，主頁麵還是原來的頁麵。執行完後還會回來，相當於函數調用。並且可以帶參數.後者完全轉向新頁麵，不會再回來。相當於go to 語句。
Servlet方麵
1、說一說Servlet的生命周期?
答:servlet有良好的生存期的定義，包括加載和實例化、初始化、處理請求以及服務結束。這個生存期由javax.servlet.Servlet接口的init,service和destroy方法表達。
2、Servlet版本間(忘了問的是哪兩個版本了)的不同?
希望大家補上，謝謝
3、JAVA SERVLET API中forward() 與redirect()的區別？
答:前者僅是容器中控製權的轉向，在客戶端瀏覽器地址欄中不會顯示出轉向後的地址；後者則是完全的跳轉，瀏覽器將會得到跳轉的地址，並重新發送請求鏈接。這樣，從瀏覽器的地址欄中可以看到跳轉後的鏈接地址。所以，前者更加高效，在前者可以滿足需要時，盡量使用forward()方法，並且，這樣也有助於隱藏實際的鏈接。在有些情況下，比如，需要跳轉到一個其它服務器上的資源，則必須使用sendRedirect()方法。
4、Servlet的基本架構
public class ServletName extends HttpServlet {
public void doPost(HttpServletRequest request, HttpServletResponse response) throws
ServletException, IOException {
}
public void doGet(HttpServletRequest request, HttpServletResponse response) throws
ServletException, IOException {
}
}
Jdbc、Jdo方麵
1、可能會讓你寫一段Jdbc連Oracle的程序,並實現數據查詢.
答:程序如下：
package hello.ant;
import java.sql.*;
public class jdbc
{
String dbUrl=”jdbc:oracle:thin:@127.0.0.1:1521:orcl”;
String theUser=”admin”;
String thePw=”manager”;
Connection c=null;
Statement conn;
ResultSet rs=null;
public jdbc()
{
try{
Class.forName(“oracle.jdbc.driver.OracleDriver”).newInstance();
c = DriverManager.getConnection(dbUrl,theUser,thePw);
conn=c.createStatement();
}catch(Exception e){
e.printStackTrace();
}
}
public boolean executeUpdate(String sql)
{
try
{
conn.executeUpdate(sql);
return true;
}
catch (SQLException e)
{
e.printStackTrace();
return false;
}
}
public ResultSet executeQuery(String sql)
{
rs=null;
try
{
rs=conn.executeQuery(sql);
}
catch (SQLException e)
{
e.printStackTrace();
}
return rs;
}
public void close()
{
try
{
conn.close();
c.close();
}
catch (Exception e)
{
e.printStackTrace();
}
}
public static void main(String[] args)
{
ResultSet rs;
jdbc conn = new jdbc();
rs=conn.executeQuery(“select * from test”);
try{
while (rs.next())
{
System.out.println(rs.getString(“id”));
System.out.println(rs.getString(“name”));
}
}catch(Exception e)
{
e.printStackTrace();
}
}
}
2、Class.forName的作用?為什麼要用?
答：調用該訪問返回一個以字符串指定類名的類的對象。
3、Jdo是什麼?
答:JDO是Java對象持久化的新的規範，為java data object的簡稱,也是一個用於存取某種數據倉庫中的對象的標準化API。JDO提供了透明的對象存儲，因此對開發人員來說，存儲數據對象完全不需要額外的代碼（如JDBC API的使用）。這些繁瑣的例行工作已經轉移到JDO產品提供商身上，使開發人員解脫出來，從而集中時間和精力在業務邏輯上。另外，JDO很靈活，因為它可以在任何數據底層上運行。JDBC隻是麵向關係數據庫（RDBMS)JDO更通用，提供到任何數據底層的存儲功能，比如關係數據庫、文件、XML以及對象數據庫（ODBMS）等等，使得應用可移植性更強。
4、在ORACLE大數據量下的分頁解決方法。一般用截取ID方法，還有是三層嵌套方法。
答:一種分頁方法
<%
int i=1;
int numPages=14;
String pages = request.getParameter(“page”) ;
int currentPage = 1;
currentPage=(pages==null)?(1):{Integer.parseInt(pages)}
sql = “select count(*) from tables”;
ResultSet rs = DBLink.executeQuery(sql) ;
while(rs.next()) i = rs.getInt(1) ;
int intPageCount=1;
intPageCount=(i%numPages==0)?(i/numPages):(i/numPages+1);
int nextPage ;
int upPage;
nextPage = currentPage+1;
if (nextPage>=intPageCount) nextPage=intPageCount;
upPage = currentPage-1;
if (upPage<=1) upPage=1;
rs.close();
sql=”select * from tables”;
rs=DBLink.executeQuery(sql);
i=0;
while((i<numPages*(currentPage-1))&&rs.next()){i++;}
%>
//輸出內容
//輸出翻頁連接
合計:<%=currentPage%>/<%=intPageCount%><a href=”List.jsp?page=1″>第一頁</a><a
href=”List.jsp?page=<%=upPage%>”>上一頁</a>
<%
for(int j=1;j<=intPageCount;j++){
if(currentPage!=j){
%>
<a href=”list.jsp?page=<%=j%>”>[<%=j%>]</a>
<%
}else{
out.println(j);
}
}
%>
<a href=”List.jsp?page=<%=nextPage%>”>下一頁</a><a href=”List.jsp?page=<%=intPageCount%>”>最後頁
</a>
Xml方麵
1、xml有哪些解析技術?區別是什麼?
答:有DOM,SAX,STAX等
DOM:處理大型文件時其性能下降的非常厲害。這個問題是由DOM的樹結構所造成的，這種結構占用的內存較多，而且DOM必須在解析文件之前把整個文檔裝入內存,適合對XML的隨機訪問SAX:不現於DOM,SAX是事件驅動型的XML解析方式。它順序讀取XML文件，不需要一次全部裝載整個文件。當遇到像文件開頭，文檔結束，或者標簽開頭與標簽結束時，它會觸發一個事件，用戶通過在其回調事件中寫入處理代碼來處理XML文件，適合對XML的順序訪問
STAX:Streaming API for XML (StAX)
2、你在項目中用到了xml技術的哪些方麵?如何實現的?
答:用到了數據存貯，信息配置兩方麵。在做數據交換平台時，將不能數據源的數據組裝成XML文件，然後將XML文件壓縮打包加密後通過網絡傳送給接收者，接收解密與解壓縮後再同XML文件中還原相關信息進行處理。在做軟件配置時，利用XML可以很方便的進行，軟件的各種配置參數都存貯在XML文件中。
3、用jdom解析xml文件時如何解決中文問題?如何解析?
答:看如下代碼,用編碼方式加以解決
package test;
import java.io.*;
public class DOMTest
{
private String inFile = “c:\\people.xml”;
private String outFile = “c:\\people.xml”;
public static void main(String args[])
{
new DOMTest();
}
public DOMTest()
{
try
{
javax.xml.parsers.DocumentBuilder builder =
javax.xml.parsers.DocumentBuilderFactory.newInstance().newDocumentBuilder();
org.w3c.dom.Document doc = builder.newDocument();
org.w3c.dom.Element root = doc.createElement(“老師”);
org.w3c.dom.Element wang = doc.createElement(“王”);
org.w3c.dom.Element liu = doc.createElement(“劉”);
wang.appendChild(doc.createTextNode(“我是王老師”));
root.appendChild(wang);
doc.appendChild(root);
javax.xml.transform.Transformer transformer =
javax.xml.transform.TransformerFactory.newInstance().newTransformer();
transformer.setOutputProperty(javax.xml.transform.OutputKeys.ENCODING, “gb2312″);
transformer.setOutputProperty(javax.xml.transform.OutputKeys.INDENT, “yes”);
transformer.transform(new javax.xml.transform.dom.DOMSource(doc),
new
javax.xml.transform.stream.StreamResult(outFile));
}
catch (Exception e)
{
System.out.println (e.getMessage());
}
}
}
4、編程用JAVA解析XML的方式.
答:用SAX方式解析XML，XML文件如下：
<?xml version=”1.0″ encoding=”gb2312″?>
<person>
<name>王小明</name>
<college>信息學院</college>
<telephone>6258113</telephone>
<notes>男,1955年生,博士，95年調入海南大學</notes>
</person>
事件回調類SAXHandler.java
import java.io.*;
import java.util.Hashtable;
import org.xml.sax.*;
public class SAXHandler extends HandlerBase
{
private Hashtable table = new Hashtable();
private String currentElement = null;
private String currentValue = null;
public void setTable(Hashtable table)
{
this.table = table;
}
public Hashtable getTable()
{
return table;
}
public void startElement(String tag, AttributeList attrs)
throws SAXException
{
currentElement = tag;
}
public void characters(char[] ch, int start, int length)
throws SAXException
{
currentValue = new String(ch, start, length);
}
public void endElement(String name) throws SAXException
{
if (currentElement.equals(name))
table.put(currentElement, currentValue);
}
}
JSP內容顯示源碼,SaxXml.jsp:
<HTML>
<HEAD>
<TITLE>剖析XML文件people.xml</TITLE>
</HEAD>
<BODY>
<%@ page errorPage=”ErrPage.jsp”
contentType=”text/html;charset=GB2312″ %>
<%@ page import=”java.io.*” %>
<%@ page import=”java.util.Hashtable” %>
<%@ page import=”org.w3c.dom.*” %>
<%@ page import=”org.xml.sax.*” %>
<%@ page import=”javax.xml.parsers.SAXParserFactory” %>
<%@ page import=”javax.xml.parsers.SAXParser” %>
<%@ page import=”SAXHandler” %>
<%
File file = new File(“c:\\people.xml”);
FileReader reader = new FileReader(file);
Parser parser;
SAXParserFactory spf = SAXParserFactory.newInstance();
SAXParser sp = spf.newSAXParser();
SAXHandler handler = new SAXHandler();
sp.parse(new InputSource(reader), handler);
Hashtable hashTable = handler.getTable();
out.println(“<TABLE BORDER=2><CAPTION>教師信息表</CAPTION>”);
out.println(“<TR><TD>姓名</TD>” + “<TD>” +
(String)hashTable.get(new String(“name”)) + “</TD></TR>”);
out.println(“<TR><TD>學院</TD>” + “<TD>” +
(String)hashTable.get(new String(“college”))+”</TD></TR>”);
out.println(“<TR><TD>電話</TD>” + “<TD>” +
(String)hashTable.get(new String(“telephone”)) + “</TD></TR>”);
out.println(“<TR><TD>備注</TD>” + “<TD>” +
(String)hashTable.get(new String(“notes”)) + “</TD></TR>”);
out.println(“</TABLE>”);
%>
</BODY>
</HTML>
EJB方麵
1、EJB2.0有哪些內容?分別用在什麼場合? EJB2.0和EJB1.1的區別?
答：規範內容包括Bean提供者，應用程序裝配者，EJB容器，EJB配置工具，EJB服務提供者，係統管理員。這裏麵，EJB容器是EJB之所以能夠運行的核心。EJB容器管理著EJB的創建，撤消，激活，去活，與數據庫的連接等等重要的核心工作。JSP,Servlet,EJB,JNDI,JDBC,JMS…..
2、EJB與JAVA BEAN的區別？
答:Java Bean 是可複用的組件，對Java Bean並沒有嚴格的規範，理論上講，任何一個Java類都可以是一個Bean。但通常情況下，由於Java Bean是被容器所創建（如Tomcat)的，所以Java Bean應具有一個無參的構造器，另外，通常Java Bean還要實現Serializable接口用於實現Bean的持久性。Java Bean實際上相當於微軟COM模型中的本地進程內COM組件，它是不能被跨進程訪問的。Enterprise Java Bean 相當於DCOM，即分布式組件。它是基於Java的遠程方法調用（RMI）技術的，所以EJB可以被遠程訪問（跨進程、跨計算機）。但EJB必須被布署在諸如Webspere、WebLogic這樣的容器中，EJB客戶從不直接訪問真正的EJB組件，而是通過其容器訪問。EJB容器是EJB組件的代理，EJB組件由容器所創建和管理。客戶通過容器來訪問真正的EJB組件。
3、EJB的基本架構
答:一個EJB包括三個部分:
Remote Interface 接口的代碼
package Beans;
import javax.ejb.EJBObject;
import java.rmi.RemoteException;
public interface Add extends EJBObject
{
//some method declare
}
Home Interface 接口的代碼
package Beans;
import java.rmi.RemoteException;
import jaax.ejb.CreateException;
import javax.ejb.EJBHome;
public interface AddHome extends EJBHome
{
//some method declare
}
EJB類的代碼
package Beans;
import java.rmi.RemoteException;
import javax.ejb.SessionBean;
import javx.ejb.SessionContext;
public class AddBean Implements SessionBean
{
//some method declare
}
J2EE,MVC方麵
1、MVC的各個部分都有那些技術來實現?如何實現?
答:MVC是Model－View－Controller的簡寫。”Model” 代表的是應用的業務邏輯（通過JavaBean，EJB組件實現）， “View” 是應用的表示麵（由JSP頁麵產生），”Controller” 是提供應用的處理過程控製（一般是一個Servlet），通過這種設計模型把應用邏輯，處理過程和顯示邏輯分成不同的組件實現。這些組件可以進行交互和重用。
2、應用服務器與WEB SERVER的區別？
希望大家補上，謝謝
3、J2EE是什麼？
答:Je22是Sun公司提出的多層(multi-diered),分布式(distributed),基於組件(component-base)的企業級應用模型(enterpriese application model).在這樣的一個應用係統中，可按照功能劃分為不同的組件，這些組件又可在不同計算機上，並且處於相應的層次(tier)中。所屬層次包括客戶層(clietn tier)組件,web層和組件,Business層和組件,企業信息係統(EIS)層。
4、WEB SERVICE名詞解釋。JSWDL開發包的介紹。JAXP、JAXM的解釋。SOAP、UDDI,WSDL解釋。
答：Web Service描述語言WSDL
SOAP即簡單對象訪問協議(Simple Object Access Protocol)，它是用於交換XML編碼信息的輕量級協議。
UDDI 的目的是為電子商務建立標準；UDDI是一套基於Web的、分布式的、為Web Service提供的、信息注冊中心的實現標準規範，同時也包含一組使企業能將自身提
最後更新：2017-04-03 15:22:09