Java面試題整理

Java面向對象

1. super()與this()的區別？

This（）：當前類的對象,super父類對象。

Super（）：在子類訪問父類的成員和行爲,必須受類繼承規則的約束

而this他代表當前對象,當然所有的資源都可以訪問.

在構造函數中,如果第一行沒有寫super(),編譯器會自動插入.但是如果父類沒有不帶參數的構造函數,或這個函數被私有化了(用private修飾).此時你必須加入對父類的實例化構造.而this就沒有這個要求,因爲它本身就進行實例化的構造.
而在方法中super和this使用的方法就差不多了.只不過super 要考慮是否能訪問其父類的資源.

2. 作用域public,protected,private,以及不寫時的區別？

Ø Public:不同包、同一包、類內都可用

Ø Private：類內

Ø Protected: 不同包的子類、同一包、類內都可用

Ø 不寫時:同一包內、類內

3. 編程輸出如下圖形。

* * * * *

* * * *

* * *

* *

代碼如下：

public class Print {
    public static void main(String[] args) {
       for (int i = 0; i < 5; i++){
           for (int j = 5; j > i; j--) {
              System.out.print("*");
           }
           System.out.println();
       }
    }
}

4. JAVA的事件委託機制和垃圾回收機制

java 事件委託機制的概念,一個源產生一個事件並將它送到一個或多個監聽器那裏。在這種方案中，監聽器簡單的等待，直到它收到一個事件。一旦事件被接受，監聽器將處理這個事件，然後返回。

垃圾回收機制垃圾收集是將分配給對象但不再使用的內存回收或釋放的過程。如果一個對象沒有指向它的引用或者其賦值爲null,則次對象適合進行垃圾回收

5. 在JAVA中，如何跳出當前的多重嵌套循環？

用break; return 方法。

6. 什麼是java序列化，如何實現java序列化？(寫一個實例)

序列化:

處理對象流的機制，所謂對象流也就是將對象的內容進行流化。可以對流化後的對象進行讀寫操作，也可將流化後的對象傳輸於網絡之間。序列化是爲了解決在對對象流進行讀寫操作時所引發的問題。

序列化的實現：

將需要被序列化的類實現Serializable接口，該接口沒有需要實現的方法，implements Serializable只是爲了標註該對象是可被序列化的，然後使用一個輸出流(如：FileOutputStream)來構造一個ObjectOutputStream(對象流)對象，接着，使用ObjectOutputStream對象的writeObject(Object obj)方法就可以將參數爲obj的對象寫出(即保存其狀態)，要恢復的話則用輸入流。

7. 一個".java"源文件中是否可以包括多個類（不是內部類）？有什麼限制？

可以。如果這個類的修飾符是public，其類名與文件名必須相同。

8. 排序都有哪幾種方法？請列舉。用JAVA實現一個快速排序？

排序的方法有：插入排序（直接插入排序、希爾排序），交換排序（冒泡排序、快速排序），選擇排序（直接選擇排序、堆排序），歸併排序，分配排序（箱排序、基數排序）

快速排序的僞代碼。

9. Overload和Override的區別。Overloaded的方法是否可以改變返回值的類型?

方法的

重寫Override，子類覆蓋父類的方法，將子類傳與父類的引用調用的還是子類的方法。

重載Overloading 一個類多個方法，名稱相同，參數個數類型不同。

兩者都是Java多態性的不同表現。

Overloaded的方法是可以改變返回值的類型。

1， public class Ctest()
{
    Public static void main()
{
System.out.prinln(8+8+”88”+8+8);
}
}
168888

10. Final類有什麼特點？

屬性常量

方法不可以overridding

類不可以繼承

11. 繼承時候類的執行順序問題,一般都是選擇題,問你將會打印出什麼?

答:父類：

package test;
public class FatherClass
{
public FatherClass()
{
System.out.println("FatherClassCreate");
}
}

子類:

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

ChildClass Create

12. 內部類的實現方式?

答：示例代碼如下：

package test;
public class OuterClass
{
private class InterClass
{
Public Interlass()
{
System.out.println("InterClass Create");
}
}
public OuterClass()
{
InterClass ic = new InterClass();
System.out.println("OuterClassCreate");
}
public static void main(String[] args)
{
OuterClass oc = new OuterClass();
}
}

輸出結果:

C:>java test/OuterClass

InterClass Create

OuterClass Create

13. 用JAVA實現一種排序，JAVA類實現序列化的方法(二種)？

14. 如在COLLECTION框架中，實現比較要實現什麼樣的接口？

15. 用插入法進行排序代碼如下

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 接口

16. 編程：編寫一個截取字符串的函數，輸入爲一個字符串和字節數，輸出爲按字節截取的字符串。但是要保證漢字不被截半個，如"我ABC"4，應該截爲"我AB"，輸入"我ABC漢DEF"，6，應該輸出爲"我ABC"而不是"我ABC+漢的半個"。

答：代碼如下：

public static void split(String source,int num) throws Exception
    {
       int k=0;
       String temp="";
       for (int i = 0; i<source.length(); i++)
       { 
           byte[]b=(source.charAt(i)+"").getBytes();
           k=k+b.length;
           if(k>num)
           {
              break;
           }
           temp=temp+source.charAt(i);      
       } 
       System.out.println(temp);
    }

15、Java編程,打印昨天的當前時刻

public class YesterdayCurrent{
public void main(String[] args){
Calendar cal = Calendar.getInstance();
cal.add(Calendar.DATE, -1);
System.out.println(cal.getTime());
}
}

16、文件讀寫,實現一個計數器

public int getNum(){
int i = -1;
try{
String stri="";
BufferedReader in = new BufferedReader(new FileReader(f));
while((stri=in.readLine())!=null){
i = Integer.parseInt(stri.trim());
}
in.close();
}catch(Exception e){
e.printStackTrace();
}
return i;
}
public void setNum(){
int i = getNum();
i++;
try{
PrintWriter out=new PrintWriter(new BufferedWriter(newFileWriter(f,false)));
out.write(String.valueOf(i)); //可能是編碼的原因，如果直接寫入int的話，將出現java編碼和windows編碼的混亂，因此此處寫入的是String
out.close() ;
}catch(Exception e){
e.printStackTrace();
}
}

17、指出下面程序的運行結果。

class A{
static{
System.out.print("1");
}
public A(){
System.out.print("2");
}
}
class B extends A{
static{
System.out.print("a");
}
public B(){
System.out.print("b");
}
}
public class Hello{
public static void main(String[] ars){
A ab = new B(); //執行到此處,結果: 1a2b
ab = new B(); //執行到此處,結果: 1a2b2b
}
}

　　注:類的static 代碼段,可以看作是類首次加載(被虛擬機加載)執行的代碼,而對於類的加載,首先要執行其基類的構造,再執行其本身的構造

18、抽象類和接口的區別？

(1)接口可以被多重implements,抽象類只能被單一extends

(2)接口只有定義,抽象類可以有定義和實現

(3)接口的字段定義默認爲:public static final, 抽象類字段默認是"friendly"(本包可見)

當功能需要累積時用抽象類，不需要累積時用接口。

19、什麼是類的返射機制?

通過類(Class對象)，可以得出當前類的fields、method、construtor、interface、superClass、modified等，同是可以通過類實例化一個實例、設置屬性、喚醒方法。Spring中一切都是返射、struts、hibernate都是通過類的返射進行開發的。

20、類的返射機制中的包及核心類?

 java.lang.Class

 java.lang.refrection.Method

 java.lang.refrection.Field

 java.lang.refrection.Constructor

 java.lang.refrection.Modifier

 java.lang.refrection.Interface

21、得到Class的三個過程是什麼?

對象.getClass()

類.class或Integer.type(int) Integer.class(java.lang.Integer)

Class.forName();

22、如何喚起類中的一個方法？

產生一個Class數組，說明方法的參數

通過Class對象及方法參數得到Method

通過method.invoke(實例,參數值數組)喚醒方法

23、如何將數值型字符轉換爲數字（Integer，Double）？

Integer.parseInt(“1234”)

Double.parseDouble(“123.2”)

24、如何將數字轉換爲字符？

1+””

1.0+””

25、如何去小數點前兩位，並四捨五入。

double d=1256.22d;

d=d/100;

System.out.println(Math.round(d)*100);

26、如何取得年月日，小時分秒？

Calendar c=Calendar.getInstance();

c.set(Calendar.YEAR,2004);

c.set(Calendar.MONTH,0);

c.set(Calendar.DAY_OF_MONTH,31);

System.out.println(c.get(Calendar.YEAR)+" "+(c.get(Calendar.MONTH)+1)+" "+c.get(Calendar.DAY_OF_MONTH));

27、如何取得從1970年到現在的毫秒數

Java.util.Date dat=new Date();

long now=dat.getTime();

28、如何獲取某個日期是當月的最後一天？

當前日期加一天，若當前日期與結果的月份不相同，就是最後一天。

取下一個月的第一天，下一個月的第一天-1

public static void main(String[] args)
    {
       Calendarc=Calendar.getInstance();
       c.set(Calendar.YEAR,2004);
       c.set(Calendar.MONTH,0);
       c.set(Calendar.DAY_OF_MONTH,30);
       Calendarc1=(Calendar)c.clone();
       System.out.println(c.get(Calendar.YEAR)+"  "+(c.get(Calendar.MONTH)+1)+"  "+c.get(Calendar.DAY_OF_MONTH));
        
       c.add(Calendar.DAY_OF_MONTH,1);
       if(c.get(Calendar.MONTH)!=c1.get(Calendar.MONTH))
       {
           System.out.println("是最後一天");
       }
       else
       {
           System.out.println("不是取後一天");
            
       }
    }

29、如何格式化日期？

Import java.text. SimpleDateFormat;

SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-ddhh:mm:ss");

Date dat=new Date();

//把日期轉化爲字符串

String str=sdf.format(dat);

System.out.println(str);

//將字符串轉化爲日期

Java.util.Date d1=sdf.parse(“yyyy-mm-dd”);

30、編碼轉換，怎樣實現將GB2312編碼的字符串轉換爲ISO-8859-1編碼的字符串。

String a=new String("中".getBytes("gb2312"),"iso-8859-1");

String a=new String("中".getBytes("iso-8859-1"));

32、String s = new String("xyz");創建了幾個StringObject?

New了一個,”XYZ”本來又是一個

兩個

33、float型floatf=3.4是否正確?

 報錯，應當是float f=3.4f

 如果是float f=3(整數)正確

35、說出一些常用的類，包，接口，請各舉5個

常用的類：BufferedReader BufferedWriter FileReader FileWirter String Integer

常用的包：java.lang java.awt java.io java.util java.sql javax.xmljavax.sevlet javax.ejb. java.net javax.faces

常用的接口： List Map Document NodeList EjbObject EjbHome SessionBean EntityBean

36、java中會存在內存泄漏嗎，請簡單描述。

會。如：int i,i2; return (i-i2); //when i爲足夠大的正數,i2爲足夠大的負數。結果會造成溢位，導致錯誤。

37、java中實現多態的機制是什麼？

靜態的多態:方法名相同，參數個數或類型不相同。(overloading)

動態的多態:

子類覆蓋父類的方法，將子類的實例傳與父類的引用調用的是子類的方法

實現接口的實例傳與接口的引用調用的實現類的方法。

38、垃圾回收器的基本原理是什麼？垃圾回收器可以馬上回收內存嗎？有什麼辦法主動通知虛擬機進行垃圾回收？

動態內存

存放類實例

靜態內存

類本身

垃圾收集主要針對的是動態內存，一般當內存不夠用時會進行垃圾收集。

或通過System.gc()手動收集，但不保證一定執行。

39、靜態變量和實例變量的區別？

static i = 10; //常量

class A a; a.i =10;//可變

靜態方法可以調用靜態變量。

實現方法可以調用靜態變量、實例變量

41、是否可以從一個static方法內部發出對非static方法的調用？

不可以,如果其中包含對象的method()；不能保證對象初始化.

42、寫clone()方法時，通常都有一行代碼，是什麼？

Clone 有缺省行爲，super.clone();他負責產生正確大小的空間，並逐位複製。

43、JAVA語言如何進行異常處理，關鍵字：throws,throw,try,catch,finally分別代表什麼意義？在try塊中可以拋出異常嗎？

Try:執行部分，產生異常

Catch:捕捉異常

Finally:不管有沒有異常都執行

Throws:在方法聲明處聲明要拋出的異常，調用者必須對其進行處理。

Throw:拋出一個異常

在try中可以拋出異常，一般與聲明的異常相同。

自定義異常要繼承於Exception或Exception的子類

45、冒泡排序法

//相鄰兩個數比較，將最小或最大的放到後面，最後面數的不參與比較

public class BubbleSort {
    private static int al[] = new int[10];
    publicBubbleSort() {
       al[0]=2;
       al[1]=3;
       al[2]=23;
       al[3]=45;
       al[4]=1;
       al[5]=67;
       al[6]=23;
       al[7]=80;
       al[8]=35;
       al[9]=72;
    }
    public static void main(String[] args) {
       BubbleSort bs = new BubbleSort();
       System.out.println("排序前：");
       display(al);
        
       for(int i=0;i<al.length;i++) {
        
           for (int j = 0; j < al.length-i-1; j++) {
               
              if(al[j]>al[j+1]) {
                  swap(j,j+1);
              }
           }
       }
       System.out.println();
       System.out.println("排序後：");
       display(al);
    }
    private static void display(int[] al2) {
       for (int i = 0; i < al2.length; i++) {
           System.out.print(al2[i]+"  ");
       }
    }
    private static void swap(int i,int j) {
       int temp = al[i];
       al[i]= al[j];
       al[j] = temp;
    }
}

46、String and StringBuffer的區別？

String:長度給定不可變，當多個字符串聯合時要先轉爲StringBuffer，再聯合，速度慢。

StringBuffer:長度可變,可以將多個字符串值直接聯合，效率高

47、用java代碼編寫堆棧

public class Stack {
   
    int[] data;
    int maxSize;
    int top;
    public Stack(int maxSize) {
       this.maxSize = maxSize;
       data = new int[maxSize];
       top = -1;
    }
     
    /**
     * 依次加入數據
     * @param data 要加入的數據
     * @return 添加是否成功
     */
    public boolean push(int data) {
       if(top+1== maxSize) {
           System.out.println("棧已滿!");
           return false;
       }
       this.data[++top] = data;
       return true;
    }
     
    /**
     * 從棧中取出數據
     * @return 取出的數據
     */
    public int pop() throws Exception{
       if(top==-1) {
           throw new Exception("棧已空!");
       }
       return this.data[top--];
    }
     
    public static void main(String[] args) throwsException {
       Stack stack=new Stack(1000);
       stack.push(1);
       stack.push(2);
       stack.push(3);
       stack.push(4);
       stack.push(5);
       while(stack.top>=0)
       {
           System.out.println(stack.pop());
       }    
    }
}

48、集合的作用是什麼?

數據的傳送增、刪、改、查、constainsAll，可以存放不同類型的對象。

49、集合的通用方法有那些?通用方法是什麼?(操作)

集合List 的遍歷方法有：

Iterator:

Enumeration

For

Get

set

Collection的通用方法有：

Iterator()

Add()

Clear();

remove()

50、說出ArrayList,Vector, LinkedList的存儲性能和特性HashMap和Hashtable的區別

ArrayList Vector:以數組的方式存儲，增、刪慢，查、改快

ArrayList:線程不安全，速度快

Vector:線程安全，速度慢(synchoronized)

LikedList:以單鏈表的方式存儲，增、刪快，查、改慢

HashMap與Hashtable都實現的Map接口,HashTable線程安全，HashMap線程不安全。

51、Collection 和Collections的區別。

Collection是集合的根接口，其下有set及list

Collections是集合的算法。

52、Set裏的元素是不能重複的，那麼用什麼方法來區分重複與否呢? 是用==還是equals()? 它們有何區別?用contains來區分是否有重複的對象。還是都不用。

在比較時先調用hashCode方法，如果不相同，證明不相等。

如果相同，再調用equals方法，如果equals方法相同，證明相等，不相同，證明不相等。

==:主要用在基本數據類型及引用

Equals:主要是對象或對象引用的比較。

集合中是否包含某一個元素用contains來判斷。

53、List, Set, Map是否繼承自Collection接口?

List,set繼承於Collection

Map沒有繼承於Collection，其相對是獨立的。

屬於Collection類型的對象，可以通過構造函數將一個集合構造成另外一個集合。

54、面向對象的特徵有哪些方面

1.抽象：

找共性，將共有的屬性、方法放到父類中

2.繼承：

子類繼承於父類，具有父類的所有屬性與方法，可以重用，也可以覆蓋。

3.封裝：

一個類包括多個屬性及方法。

4. 多態性：

動態:

靜態:

55、String是最基本的數據類型嗎?

基本數據類型包括byte、int、char、long、float、double、boolean和short。

java.lang.String類是final類型的，因此不可以繼承這個類、不能修改這個類。爲了提高效率節省空間，我們應該用StringBuffer類

56、int 和 Integer 有什麼區別？

Int是基本數據類型，不是對象，佔一個內存空間，沒有方法。與其同類的有long,char,doble

Integer是封裝類，具有方法及屬性。與其同類的有Long,Double.Float

57、運行時異常與一般異常有何異同？

運行時異常:java JVM拋出的異常，代碼中不用處理。

一般異常:用戶拋出的異常，如果用throws 聲明瞭，調用這個方法的代碼必須對其處理。

58、&和&&的區別？

&:與: 左邊若爲false右邊還執行。

&&:短路與,左邊若爲false右邊不執行。

59、final, finally, finalize的區別？

final 用於聲明屬性，方法和類，分別表示屬性不可變，方法不可覆蓋，類不可繼承。

finally是異常處理語句結構的一部分，表示總是執行。

finalize是Object類的一個方法，在垃圾收集器執行的時候會調用被回收對象的此方法，可以覆蓋此方法提供垃圾收集時的其他資源回收，例如關閉文件等。

算符可以用來決定某對象的類是否實現了接口。

62、heap和stack有什麼區別？

棧是一種線形集合，其添加和刪除元素的操作應在同一段完成。棧按照後進先出的方式進行處理。

堆是棧的一個組成元素

63、Static Nested Class 和Inner Class的不同？

Static Nested Class是被聲明爲靜態（static）的內部類，它可以不依賴於外部類實例被實例化。而通常的內部類需要在外部類實例化後才能實例化。

64、什麼時候用assert？

assertion (斷言)在軟件開發中是一種常用的調試方式，很多開發語言中都支持這種機制。在實現中，assertion就是在程序中的一條語句，它對一個boolean表達式進行檢查，一個正確程序必須保證這個boolean表達式的值爲true；如果該值爲false，說明程序已經處於不正確的狀態下，系統將給出警告或退出。一般來說，assertion用於保證程序最基本、關鍵的正確性。assertion檢查通常在開發和測試時開啓。爲了提高性能，在軟件發佈後，assertion檢查通常是關閉的。

65、GC是什麼? 爲什麼要有GC?

GC是垃圾收集的意思（Gabage Collection）,內存處理是編程人員容易出現問題的地方，忘記或者錯誤的內存回收會導致程序或系統的不穩定甚至崩潰，Java提供的GC功能可以自動監測對象是否超過作用域從而達到自動回收內存的目的，Java語言沒有提供釋放已分配內存的顯示操作方法。

66、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;（可以正確編譯）

67、Math.round(11.5)等於多少? Math.round(-11.5)等於多少?

Math.round(11.5)==12 Math.round(-11.5)==-11round方法返回與參數最接近的長整數，參數加1/2後求其floor.

68、Java有沒有goto?

java中的保留字，現在沒有在java中使用。

69、給我一個你最常見到的runtime exception

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

一般異常:

IOException

FileNotFoundException

SqlException

70、接口是否可繼承接口? 抽象類是否可實現(implements)接口? 抽象類是否可繼承實體類(concrete class)?

接口可以繼承接口。抽象類可以實現(implements)接口，抽象類是否可繼承實體類，但前提是實體類必須有明確的構造函數。任何抽象類都是實際類Object的子類。

71、abstract的method是否可同時是static,是否可同時是native，是否可同時是synchronized?

都不能

72、數組有沒有length()這個方法?String有沒有length()這個方法？

數組沒有length()這個方法,有length這個屬性

String有length()這個方法.

73、構造器Constructor是否可被override?

構造器Constructor不能被繼承，因此不能重寫Overriding，但可以被重載Overloading。

74、是否可以繼承String類?

String類是final類故不可以繼承。

75、swtich是否能作用在byte上，是否能作用在long上，是否能作用在String上?

switch（expr1）中，expr1是一個整數表達式。因此傳遞給 switch 和 case 語句的參數應該是 int、 short、 char 或者 byte。long,string都不能作用於swtich。

76、try {}裏有一個return語句，那麼緊跟在這個try後的finally {}裏的code會不會被執行，什麼時候被執行，在return前還是後?

會執行，在return前執行。

77、編程題: 用最有效率的方法算出2乘以8等於幾?

2 << 3

78、兩個對象值相同(x.equals(y) == true)，但卻可有不同的hash code，這句話對不對?

不對，有相同的hash code。

79、當一個對象被當作參數傳遞到一個方法後，此方法可改變這個對象的屬性，並可返回變化後的結果，那麼這裏到底是值傳遞還是引用傳遞?

是引用傳遞

基本數據類型:值

對象: 引用

80、四種會話跟蹤技術

Session

Hidden

url 重寫

81、編程題: 寫一個Singleton出來。

Singleton模式主要作用是保證在Java應用程序中，一個類Class只有一個實例存在。

一般Singleton模式通常有幾種種形式:

第一種形式: 定義一個類，它的構造函數爲private的，它有一個static的private的該類變量，在類初始化時實例話，通過一個public的getInstance方法獲取對它的引用,繼而調用其中的方法。

public class Singleton {

private Singleton(){}

　　 //在自己內部定義自己一個實例，是不是很奇怪？

　　 //注意這是private 只供內部調用

　　 private static Singletoninstance = new Singleton();

　　 //這裏提供了一個供外部訪問本class的靜態方法，可以直接訪問　　

　　 public static SingletongetInstance() {

　　　　 return instance; 　　

　　 }

第二種形式:

public class Singleton {

　　private static Singleton instance = null;

　　public static synchronized Singleton getInstance() {

　　//這個方法比上面有所改進，不用每次都進行生成對象，只是第一次　　　　

　　//使用時生成實例，提高了效率！

　　if (instance==null)

　　　　instance＝new Singleton();

return instance; 　　}

}

其他形式:

定義一個類，它的構造函數爲private的，所有方法爲static的。

一般認爲第一種形式要更加安全些

83、Java中的異常處理機制的簡單原理和應用。

原理

有錯直接轉到異常處理部分或向上拋出。

應用:

JAVA的異常就是錯誤，有兩種一種是運行時，編碼可以不用捕捉。一種是一般異常，如果throws聲明瞭，必須進行處理。

84、垃圾回收的優點和原理。並考慮2種回收機制。

優點:

程序員不用管內存，jvm自動完成，開發方便。運行優先非常低，程序無法清楚實例什麼時候被消毀。

85、描述一下JVM加載class文件的原理機制?

JVM中類的裝載是由ClassLoader和它的子類來實現的,Java ClassLoader 是一個重要的Java運行時系統組件。它負責在運行時查找和裝入類文件的類。

86、char型變量中能不能存貯一箇中文漢字?爲什麼?

能夠定義成爲一箇中文的，因爲java中以unicode編碼，一個char佔16個字節，所以放一箇中文是沒問題的

88、寫一個程序，從文件（c:\test.txt）中查出字符串”mobnet”出現的次數？

java基礎類庫(io流，集合類，線程，Socket，AWT，Swing,sql)

1、java中有幾種類型的流？JDK爲每種類型的流提供了一些抽象類以供繼承，請說出他們分別是哪些類？

字節流，字符流。字節流繼承於InputStream OutputStream，字符流繼承於Reader Writer。在java.io包中還有許多其他的流，低層流與調層流，高層流主要是爲了提高性能和使用方便。

2、啓動一個線程是用run()還是start()?

啓動一個線程是調用start()方法，啓動線程並調用run方法。

3、線程的基本概念、線程的基本狀態以及狀態之間的關係

線程是進程內的併發，沒有自已內存空間，共享進程的，線程間的通信成本較低。

Java中的線程有四種狀態分別是：運行、就緒、掛起、結束。

4、多線程有幾種實現方法,都是什麼?同步有幾種實現方法,都是什麼? 用什麼關鍵字修飾同步方法? stop()和suspend()方法爲何不推薦使用？

Extends Thread
Implements Runnable
同步
Public synchronized aa()
{
}
Public void cc(object aa)
{
    synchronized(aa)
{
}
}

用synchoronized修飾同步方法。

答：多線程有兩種實現方法，分別是繼承Thread類與實現Runnable接口

同步的實現方面有兩種，分別是synchronized,wait與notify

反對使用stop()，是因爲它不安全。它會解除由線程獲取的所有鎖定，而且如果對象處於一種不連貫狀態，那麼其他線程能在那種狀態下檢查和修改它們。結果很難檢查出真正的問題所在。suspend()方法容易發生死鎖。調用suspend()的時候，目標線程會停下來，但卻仍然持有在這之前獲得的鎖定。此時，其他任何線程都不能訪問鎖定的資源，除非被"掛起"的線程恢復運行。對任何線程來說，如果它們想恢復目標線程，同時又試圖使用任何一個鎖定的資源，就會造成死鎖。所以不應該使用suspend()，而應在自己的Thread類中置入一個標誌，指出線程應該活動還是掛起。若標誌指出線程應該掛起，便用wait()命其進入等待狀態。若標誌指出線程應當恢復，則用一個notify()重新啓動線程。

5、集合框架有什麼?

Collection Map

List set HashMap

ArrayList linkedList HashSet TreeSet

12、設計4個線程，其中兩個線程每次對j增加1，另外兩個線程對j每次減少1。寫出程序

public class TestThread
{
    private int j;
    public synchronized void inc()
    {
       j++;
       System.out.println(Thread.currentThread().getName()+ "-inc:" + j);
    }
    public synchronized void dec()
    {
       j--;
       System.out.println(Thread.currentThread().getName()+ "-dec:" + j);
    }
    public static void main(String[]args)
    {
       TestThread t=new TestThread();
       for (int i = 0; i < 2; i++)
       {
           Thread inc=new Thread(newInc(t));
           Thread dec=new Thread(newDec(t));
           inc.start();
           dec.start();
       }
    }
}
class Inc implements Runnable
{
       private TestThread obj;
       public Inc(TestThread obj)
       {
           this.obj=obj;
       }
       public void run()
       {
//         for (int i = 0; i <100; i++)
//         {
              this.obj.inc();
//         }
       }
    }
    class Dec implements Runnable
    {
       private TestThread obj;
       public Dec(TestThread obj)
       {
           this.obj=obj;
       }
       public void run()
       {
//         for (int i = 0; i <100; i++)
//         {
              this.obj.dec();
//         }
       }
    }

13、同步和異步有和異同，在什麼情況下分別使用他們？舉例說明。

同步：上一段代碼沒的完成，下一段必須等到上一段代碼完成後纔可以執行。如買票排隊

異步：上一段代碼沒的完成，下一段不必等到上一段代碼完成就可以執行。如手機發送短信。

14、sleep() 和 wait() 有什麼區別?

Sleep是指休眠給定的時間，當這個時間達到之後，線程會再次醒來。

Wait是等待狀態，多長時間不清楚，由另一個線程將其喚醒。

15、當一個線程進入一個對象的一個synchronized方法後，其它線程是否可進入此對象的其它方法?

如只其它方法是同步方法，不可以進入。如果不是可以進入。

17、輸入輸出流的理解:

在java使用流的機制進行數據的傳送，從文件到內存是輸入流，從內存到文件是輸出流，輸入流可以通過read讀取，輸出流以write或print寫入，對於流可以是分爲高層流和低層流，低層以一個字節或字符爲單位進行處理，高層流以一批數據爲單位進行處理。

FileInputStream（System.in）至InputSteamReader至BufferReader

OutputSteam(System.out)至printStream

FileReader至BufferedReader

FileWriter 至 PrintWriter或bufferWriter

分類:

字節(二進制)

FileInputStream(低層輸入流)

FileOutputStream(低層輸出流)

PrintStream(高層流) System.out.println()

字符(一個char)

FileReader

FileWriter

18、請寫一個程序的讀寫，要求用兩種方式一種是低層流另一種是高層流。

import java.io.FileWriter;
import java.io.InputStream;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.io.FileReader;
public class Untitled1 {
    public static voidwriteFileChar() throws Exception {
        FileWriter f = newFileWriter("c:\\aa.txt");
        InputStream is = System.in;
        int c = is.read();
        while (((char) c) != 'x') {
            f.write(c);
            c = is.read();
        }
        f.close();
        is.close();
    }
public static void writeFileString() throws Exception {
        FileWriter f = newFileWriter("c:\\aa.txt");
        BufferedWriter bwr=newBufferedWriter(f);
        BufferedReader bf = newBufferedReader(new InputStreamReader(System.in));
        String c = bf.readLine();
        while(!c.equals("stop")) {
           bwr.write(c+"\r\n");
            c = bf.readLine();
        }
        bwr.close();
        f.close();
        bf.close();
    }
     
    public static voidreadFileChar() throws Exception {
       FileReader f = newFileReader("c:\\aa.txt");
       int c = f.read();
       while (c!=-1) {
          System.out.print((char)c);
           c=f.read();
       }
       f.close();
   }
   
   public static voidreadFileString() throws Exception {
       BufferedReader bf = newBufferedReader(new FileReader("c:\\aa.txt"));
       String c = bf.readLine();
       while (c!=null)
       {
           System.out.println(c);
           c=bf.readLine();
       }
       bf.close();
   }
   
   
    public static void main(String[]args) throws Exception {
        readFileString();
    }
}

19、如何列出某個目錄下的所有文件

Import java.io.File;
File f=new File("C:\\");
        File[] f1=f.listFiles();
        for(inti=0;i<f1.length;i++)
        {
            if(f1[i].isDirectory())
            {
               System.out.println("dirctory is"+f1[i].getName());
            }
            else
            {
               System.out.println("file is"+f1[i].getName());
            }
        }
    }

//1.     如何列出某個目錄下的所有子目錄
public static void main(String[] args) throws Exception
{
       getFile(newFile("C:\\entityBean"),"\t");
}
public static void getFile(File f,String sem) throws Exception
{
       System.out.println(sem+f.getName());
        File fl[]=f.listFiles();
        if(fl.length>=1)
        {
            for(inti=0;i<fl.length;i++)
            {
                if(fl[i].isDirectory())
                {
                   getFile(fl[i],sem+"\t");
                }
            }
        }
    }
//2.     判斷一個文件或目錄是否存在
  File f=newFile("C:\\entityBean");
   if(f.exists())
   {
         System.out.println("exist");
   }
    else
    {
        System.out.println("notexist");
    }
Socket

20、用socket通訊寫出客戶端和服務器端的通訊，要求客戶發送數據後能夠回顯相同的數據？

public class ServerSocket_1
{
    public static void main(String[]args)
            throws Exception
    {
        ServerSocket ss = newServerSocket(4001);
        Socket s = ss.accept();
        BufferedReader br = newBufferedReader(new InputStreamReader(s.
                getInputStream()));
        PrintStream ps=newPrintStream(s.getOutputStream());
        String temp = br.readLine();
        while (true)
        {
           System.out.println("客戶端:"+temp);
            ps.println(temp);
            if(temp.equals("stop"))
            {
                break;
            }
            temp = br.readLine();
        }
        br.close();
        ps.close();
        ss.close();
    }
}
   
public class ClientSocket
{
  public static void main(String[]args) throws Exception
  {
      Socket s = newSocket("localhost", 4001);
      PrintStream ps = newPrintStream(s.getOutputStream());
      BufferedReader br = newBufferedReader(new InputStreamReader(System.in));
      BufferedReader br_server = newBufferedReader(new InputStreamReader(s.
              getInputStream()));
      String temp = br.readLine();
      while (true)
      {
          ps.println(temp);
          temp =br_server.readLine();
          System.out.println("服務器的信息:" + temp);
          if(temp.equals("stop"))
          {
              break;
          }
          temp = br.readLine();
      }
      s.close();
      br.close();
      br_server.close();
  }
}

23、介紹JAVA中的CollectionFrameWork(包括如何寫自己的數據結構)?

答：Collection FrameWork如下：

Collection

├List

│├LinkedList

│├ArrayList

│└Vector

│　└Stack

└Set

Map

├Hashtable

├HashMap

└WeakHashMap

Collection是最基本的集合接口，一個Collection代表一組Object，即Collection的元素（Elements）

Map提供key到value的映射

24、請說出你所知道的線程同步的方法

HashTable中的put,get,remove

Vector的相關方法。

jdbc數據訪問技術

1、JDBC如何做事務處理？

Con.setAutoCommit(false)

Con.commit();

Con.rollback();

2、寫出幾個在Jdbc中常用的接口

preparedStatement,callableStatement,statement,Connection,ResultSet

3、簡述你對Statement,PreparedStatement,CallableStatement的理解

statement用於執行靜態 SQL 語句並返回它所生成結果的對象，在執行時確定sql。

PreparedStatement表示預編譯的 SQL 語句的對象。 SQL 語句被預編譯並且存儲在 PreparedStatement 對象中。然後可以使用此對象高效地多次執行該語句，可以傳參數，在得到PreparedStatement對象時確定sql.

CallableStatement用於執行 SQL 存儲過程的接口。如果有輸出參數要註冊說明是輸出參數。

4、Java中訪問數據庫的步驟？

1連接Oracle數據庫

Class.forName(“oracle.jdbc.driver.OracleDriver”);

Connection con=DriverManager.openConnection(“jdbc:oracle:thin:@localhost:1521:DataBase ”,” UserName”,”Password ”)

1. 利用JDBC檢索出表中的數據

Class.forName(“”);

Connection con=DriverManager.openConnection(“ ”,” ”,” ”)

preparedStatment ps=Con.preparedStatment(“select * from ［table］”);

ResultSet rs=ps.executeQuery();

While(rs.next)

{

Rs.getString(1) 或rs.getString(“字段名”)

}

5、JDBC中的核心類及其作用是什麼?

DriverManager

                            Class.forName();
                            DriverManager.openConnection(“”,”sa”,””)
              Connection 
              PreparedStatement(Statement)
                            ResultSet  rs=executeQuery()  dql
                                          While(rs.next())
                                          {
   
}
                            executeUpdate()  dml ddl

6、執行存儲過程用那一個類，如何操作輸出參數?(操作)

CallableStatement c=con. prepareCall ("{call getCustomerName(?,?)}");
c.setString(1,"1");
c.registerOutParameter(2,java.sql.Types.VARCHAR);
c.execute();
c.getString(2);

8、可能會讓你寫一段Jdbc連Oracle的程序.

Class.forName("oracle.jdbc.driver.OracleDriver");

Connectioncon=DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:accp","system","system");

9、Class.forName的作用?爲什麼要用?

註冊一個數據庫驅動，將驅動加載到當前的JVM中。

10、Jdo是什麼?

JDO是Java對象持久化的新的規範，爲java data object的簡稱,也是一個用於存取某種數據倉庫中的對象的標準化API。JDO提供了透明的對象存儲，因此對開發人員來說，存儲數據對象完全不需要額外的代碼（如JDBCAPI的使用）。這些繁瑣的例行工作已經轉移到JDO產品提供商身上，使開發人員解脫出來，從而集中時間和精力在業務邏輯上。另外，JDO很靈活，因爲它可以在任何數據底層上運行。JDBC只是面向關係數據庫（RDBMS)JDO更通用，提供到任何數據底層的存儲功能，比如關係數據庫、文件、XML以及對象數據庫（ODBMS）等等，使得應用可移植性更強。(o/rMapping工具集合處理)

11、在ORACLE大數據量下的分頁解決方法。一般用截取ID方法，還有是三層嵌套方法

create or replace package myPack
is
    type c_type is ref cursor;
    procedure getPage(v_sqlvarchar2,pageSize number,pageIndex number,c out c_type);
end;
   
create or replace  package  body myPack
is
    procedure getPage(v_sqlvarchar2,pageSize number,pageIndex number,c out c_type)
  is
    pageTotal int:=0;
    pageFirstRow int:=0;
    pageLastRow int:=0;
    rowTotal int:=0;
  begin
    execute immediate 'selectcount(*)  from ('||v_sql||')' intorowTotal;
   pageTotal:=ceil(rowTotal/pageSize);
    if(pageIndex<1) then
          raise_application_error(-20001,'頁數不能小於1');
    end if;
    if(pageIndex>pageTotal) then
          raise_application_error(-20001,'頁數太大，不能讀取');
    end if;
   pageFirstRow:=(pageIndex-1)*pageIndex+1;
   pageLastRow:=pageFirstRow+pageSize;
    open c for ' select * from'||v_sql||' where rownum<'||
         pageLastRow||'minus select* from '||v_sql
         ||' whererownum<'||pageFirstRow;  
  end;
end;

Web編程Jsp&Servlet技術

1、簡單說說tomcat的配置？

JAVA_HOME=JDK的根目錄

CATALINA_HOME=tomcat的根目錄

CATALINA-HOME\conf\server.xml:可以配置tomcat的端口，可以配置tomcat中下連接池。

CATALINA-HOME\common\lib:存放公用的類包

在My eclipse中如何配置tomcat

在eclipse中,選擇windows->preference->MyEclipse->ApplicationServer->Tomcat

選擇Tomcat 的安裝目錄，並選擇TomCat所需的jdk，選擇enable,確定即可。

2、JSP中動態INCLUDE與靜態INCLUDE的區別？

jsp:include:在運行時調用另一個頁面，變量是可以重複的。

<%@include file=””%>:在轉譯時合在一起，會成爲同一個類，變量不可以重複。

3、forward和redirect的區別？

forward: 轉發，在下一個頁面中,request保留上一個頁面中的request的所有值

redirect: 跳轉，不傳遞request對象。

4、Servlet的體系結構是什麼?

Servlet

GenericServlet

HttpServlet

自定義

5、如何實現一個自定義的servlet?

extends HttpServlet 並覆蓋doPost或doGet方法

在web.xml中進行部署

6、Servlet的生命週期是什麼?

Init

多次執行doGet或doPost

destroy

7、jsp就是一個servlet是否正確?

對

8、請羅列jsp中的腳本、指令及動作?

腳本

<%%> <%=%> <%!%> <%----%>

指令

<%@page contentType=”text/html;charset=utf-8” language=”java” import=””%>

<%@include file=””%>

<%@taglib uri=”” prefix=””%>

動作:

<jsp:useBean class=”” id=”” scope=””> 在scope中如果沒有實例化一個對象，如果有直接用以前的。

<jsp:getProperty name=”” property=””> 向一個bean中設置屬性值

<jsp:forward> jsp頁的轉發

<jsp:include page=””> 導入一個jsp頁面

9、JSP的內置對象及方法

Request request表示HttpServletRequest對象。取客戶端表單域信息及cookie, header, 和session

response response表示HttpServletResponse對象，對客戶端的響應返回文本、寫cookies。

out out 向客戶端打印html文本.

pageContext :當前jsp頁面的上下文環境，可以得到session、request、application等內置對象，在自定義標籤中使用的很多。

session session表示一個請求的javax.servlet.http.HttpSession對象。Session一個用戶多個頁面共享同一變量。

applicationapplicaton 表示一個javax.servle.ServletContext對象。存放容器級的變量。

config config表示一個javax.servlet.ServletConfig對象。該對象用於存取servlet實例的初始化參數。

page page表示從該頁面產生的一個servlet實例

exception:異常，當iserrorpage=true

10、說出在JSP頁面裏是怎麼分頁的?

頁面需要保存以下參數：(數據庫的分頁及比較)

總行數：根據sql語句得到總行數

每頁顯示行數：設定值

當前頁數：請求參數

頁面根據當前頁數和每頁行數計算出當前頁第一行行數，定位結果集到此行，對結果集取出每頁顯示行數的行即可。

數據庫:

Sqlserver:

SELECT TOP 頁大小 *

FROM TestTable

WHERE (ID NOT IN

(SELECT TOP 頁大小*(頁數-1) id

FROM 表

ORDER BY id))

ORDER BY ID

--pageSize=5 頁大小

--pageIndex=2 所要的頁

--如果有主鍵可以，沒以及鍵不行

select top 5 *

from aa where a1 not in

(select top 5 a1 from aaorder by a1)

order by a1;

oracle:

select * from '||v_sql||' whererownum<'||

pageLastRow||'minus select* from '||v_sql

||' whererownum<'||pageFirstRow;

Session

先取出數據中的所有信息封裝到對象並保存在session中，轉發到jsp頁面做如下處理。

<tableborder="1">

<tr>

</tr>

List l=(List)session.getAttribute("as");

//一頁顯示多少行

int pageSize=3;

//總頁數

int pageCount=0;

int currentPage=1;

if(l!=null &&l.size()>0)

{

pageCount=(l.size()/pageSize)+(l.size()%pageSize==0?0:1);

if(request.getParameter("page")!=null)

{

currentPage=Integer.parseInt(request.getParameter("page"));

}

if(currentPage<1)

{

currentPage=1;

}

if(currentPage>pageCount)

{

currentPage=pageCount;

}

for (int i =(currentPage-1)*pageSize; i <(currentPage-1)*pageSize+pageSize; i++)

{

if(i>=l.size())

{

break;

}

Aa aa=(Aa)l.get(i);

<tr>

</tr>

}

<tr>

if(currentPage!=1)

{

<ahref="page.jsp?page=1">首頁</a>  

<ahref="page.jsp?page=<%=currentPage-1%>">上一頁</a>  

}

if(currentPage!=pageCount)

{

<ahref="page.jsp?page=<%=pageCount%>">最後一頁</a>  

}

</td>

</tr>

</table>

11、include的兩種實現方式的區別?

<@include file>:在將jsp生成servlet類前將兩個文件和在一起，生成一個java類，一起運行的。所以是一家子，當中的變量名不能重名。

<jsp:include page>:是兩個類，是一個調用關係，在運行時動態的調用，不是一家子，可以重複變量。

12、jsp頁面中兩種跳轉方式分別是什麼?有什麼區別?

轉發: 保留上次的request

<jsp:forward>

actionMapping.findForWard(“”);

pageContext.forward();

request.getRequestDispacher(“a.jsp”).forward(request,response)

跳轉:不保留上次的request

Response.setRedirect(“”)

13、描述JSP和Servlet的區別、共同點、各自應用的範圍

Jsp主要在於頁面的顯示動態生成頁面，可以與html標記一起使用，其還是要生成爲一個servlet。

Servlet：主要是控制的處理，如調用業務層，跳轉不同的jsp頁面。

Mvc:

Jsp:v

Servlet:c

14、在JSP中如何讀取客戶端的請求，如何確定某個Jsp文件的真實路徑？

Request.getparameter(“”)

<%=application.getRealPath("aa.jsp") %>

15、描述Cookie和Session的作用，區別和各自的應用範圍，Session工作原理。

Cookie:主要用在保存客戶端，其值在客戶端與服務端之間傳送，不安全，存儲的數據量有限。

Session:保存在服務端，每一個session在服務端有一個sessionID作一個標識。存儲的數據量大，安全性高。佔用服務端的內存資源。

16、說明Jsp中errorPage的作用，應用範圍。

正常頁面中

%@page erropage=”error.jsp”%

錯誤頁面

<%@page iserrorpage=”true”%>

有一內置對象:exception

17、介紹在Jsp中如何使用JavaBeans

<jsp:useBean class=”” id=”” scope=””/>

New 類();

19、簡單介紹JSP的標記庫

做一個標記處理類 extends TagSupport

通過tld說明標記處理的類的前綴及後綴

在web.xml中說明tld文件

<taglib-uri>

<taglib-location>

在jsp頁面是引用tld<%@taglib uri=”” prefix=””%>

20、Servlet中的核心類有那些，各有什麼特點?

ServletContext：容器，放置全局變量

setAtribute()

getAttribute()

ServletConfig：一個servlet的配置

getInitParameter(”名稱”)

HttpServletRequest：封裝的所有的請求

getParameterValue(”名稱”)

getParameterValues(”稱”)

getSession();

getAttribute(” 名稱”);

getRequestDispatch(”a.jsp”).forward(request,response)

HttpServletResponse：響應

getOut();

sendRedirect(””)

HttpSession：一個用戶多個頁面共享同一變量

setAttribute(””,””)

21、Servlet中重要的包有那些，有什麼區別?

javax.servlet.*；javax.servlet.http.*;

22、說出Servlet的生命週期，並說出Servlet和CGI的區別？

Servlet被服務器實例化後，容器運行其init方法，請求到達時運行其service方法，service方法自動派遣運行與請求對應的doXXX方法（doGet，doPost）等，當服務器決定將實例銷燬的時候調用其destroy方法。

與cgi的區別在於servlet處理服務器進程中，它通過多線程方式運行其service方法，一個實例可以服務於多個請求，並且其實例一般不會銷燬，而CGI對每個請求都產生新的進程，服務完成後就銷燬，所以效率上低於servlet。

23、什麼情況下調用doGet()和doPost()？

Jsp頁面中的form標籤裏的method屬性爲get時調用doGet()，爲post時調用doPost()。

25、如何現實servlet的單線程模式

在doGet及doPost方法前加入synchoronized

JSP:

<%@ pageisThreadSafe="true"%>

27、Request對象的主要方法：

setAttribute(String name,Object)：設置名字爲name的request的參數值

getAttribute(String name)：返回由name指定的屬性值

getAttributeNames()：返回request對象所有屬性的名字集合，結果是一個枚舉的實例

getCookies()：返回客戶端的所有Cookie對象，結果是一個Cookie數組

getCharacterEncoding()：返回請求中的字符編碼方式

getContentLength()：返回請求的Body的長度

實例

getInputStream()：返回請求的輸入流，用於獲得請求中的數據

getMethod()：獲得客戶端向服務器端傳送數據的方法

getParameter(String name)：獲得客戶端傳送給服務器端的有name指定的參數值

getParameterNames()：獲得客戶端傳送給服務器端的所有參數的名字，結果是一個枚舉的實例

getParameterValues(String name)：獲得有name指定的參數的所有值

getProtocol()：獲取客戶端向服務器端傳送數據所依據的協議名稱

getQueryString()：獲得查詢字符串

getRequestURI()：獲取發出請求字符串的客戶端地址

getRemoteAddr()：獲取客戶端的IP地址

getRemoteHost()：獲取客戶端的名字

getSession([Boolean create])：返回和請求相關Session

getServerName()：獲取服務器的名字

getServletPath()：獲取客戶端所請求的腳本文件的路徑

getServerPort()：獲取服務器的端口號

removeAttribute(String name)：刪除請求中的一個屬性

28、我們在web應用開發過程中經常遇到輸出某種編碼的字符，如iso8859-1等，如何輸出一個某種編碼的字符串？

Public String translate (String str) {

String tempStr = "";

try {

tempStr = newString(str.getBytes("ISO-8859-1"), "GBK");

tempStr = tempStr.trim();

}

catch (Exception e) {

System.err.println(e.getMessage());

}

return tempStr;

}

30、Servlet執行時一般實現哪幾個方法?

public void init(ServletConfig config)

public ServletConfig getServletConfig()

public String getServletInfo()

public void service(ServletRequest request,ServletResponse response)

public void destroy()

5Hibernate持久層技術

1、在myeclipse加入hibernate環境的全過程是什麼?

Db-browers加入配置連接

新建工程

加入hibernate環境，指定*.hbm.xml及HibernateSessionFactory文件所在的位置

2、hibernate的核心配置文件是什麼及其作用?

Hibernate.cfg.xml:數據庫連接、指定相關的映射文件

*.hbm.xml:具體的o/r mapping說明

3、hibernate的核心類是什麼，它們的相互關係是什麼?重要的方法是什麼?

Configuration

SessionFactory

Session如下方法

Save

load

Update

Delete

Query q=CreateQuery(“from Customer where customerName=:customerName”)

beginTransaction

Transaction

Commit()

4、關聯:

one-to-many

inverse:主控方，外鍵的關係有誰控制

inverse=false 是主控方，外鍵是由它控制的

inverse=true 是被控方，外鍵與它沒關係

要想實現主控方的控制必須將被控方作爲主控方的屬性

cascade:級聯

主表增從表增

主表修從表修

主表刪從表刪

lazy:延遲

lazy=false：一下將所有的內容取出，不延時(常用)

lazy=true：取出部分內容，其餘內容動態去取

通過get可以取出對方的所有內容

5、hibernate中的one-to-many或many-to-one中常用的方式是什麼?

主控方在many這邊，不及連刪除

6、Criteria 的作用?

Criteriac=session.createCriteria(Customer.class);

//設置條件

c.add(Expression.ge(“字段名”,”值對象”))

ge:>=

gt:>

le:<=

lt:<

eq:=

//排序

c.addOrder(Order.asc(“字段名”))

//分頁

c.setFirstResult(1)//從第2行開始提取

c.setMaxResults(5)//返回5行

7、DetachedCriteria的作用？

產生時不需要session

DetachedCriteria dc=DetachedCriteria.forClass(Customer.class)

Criteriac=Dc.getExecutableCriteria(session)

8、Query

1 個或多個屬性查詢:

Query query=session.createQuery(”select customername,customerid from Customer”)

List l=query.list();

For(int i=0;i<l.size();i++)

{

Obejct[]object=(Object[])l.get(i);

Object[0] object[1]

}

分組: "select count(*),productname from Product group byproductname order by productname"

取值與屬性一樣

配置的查詢,在*.hbm.xml中

<queryname="sql">

<![CDATA[

fromProduct where productid=:productid

]]>

</query>

Queryquery=session.getNamedQuery(sql);

聯接1

"from Customer as customerjoin fetch customer.buySet"：將多的放到buySet屬性中，得出的結是Customer有一個，Buy有多個

聯接2

"from Customer as customer join customer.buySet":得出的對象,customer與buy是1對1

子查詢:

"from Customer as customerwhere (select count(*) from customer.buySet)>1"

9、繼承關係的實現

1、兩個表，子類重複父類的屬性。

2、一個表，子類父類共用一個表

<discriminatorcolumn="DISCRIMINATOR_USERTYPE" type="string"/>

<subclassname="admin" discriminator-value="admin">

<propertyname="adminRemark" column="admin_remark"type="string" />

</subclass>

</class>

3、兩個表，子類引用父類的主鍵，享用公共的字段或屬性。

<idname="userid" column="USERID" type="string">

<generatorclass="assigned"/>

</id>

<propertyname="pwd" column="pwd" type="string" />

<joined-subclassname="Guest" table="guest">

<keycolumn="USERID"/>

<propertyname="guestRemark" column="guest_remark"type="string" />

</joined-subclass>

</class>

批量刪除

Queryquery=session.createQuery("update"或"delete");

query.executeUpdate();

10、tomcat連接池:在容器中預先產生了n個連接實例,客戶端不用重新實例化，可以直接取。

6.1、在tomcat-5.0\conf\server.xml中</host>前面加入如下內容

<Contextpath="/app1" docBase="app1" debug="0" reloadable="true"crossContext="true">

<Resourcename="jdbc/sa" auth="Container" type="javax.sql.DataSource"/>

<ResourceParamsname="jdbc/sa">

<name>factory</name>

<value>org.apache.commons.dbcp.BasicDataSourceFactory</value>

</parameter>

<name>driverClassName</name>

<value>com.microsoft.jdbc.sqlserver.SQLServerDriver</value>

</parameter>

<value>jdbc:microsoft:sqlserver://127.0.0.1:1433;DatabaseName=jspdev;SelectMethod=cursor</value>

</parameter>

<name>username</name>

</parameter>

<name>password</name>

</parameter>

<name>maxActive</name>

</parameter>

<name>maxIdle</name>

</parameter>

<name>maxWait</name>

</parameter>

</ResourceParams>

</Context>

6.2、將sql-server包拷貝到C:\tomcat-5\common\lib

6.3、jdbc測試代碼

Context initCtx = newInitialContext();

ContextenvCtx = (Context)initCtx.lookup("java:comp/env");

ds = (DataSource)envCtx.lookup("jdbc/sa");

Connection conn =ds.getConnection();

6.4、hibernate通過連接池實現連接

<session-factoryname="foo">

<propertyname="connection.datasource">java:comp/env/jdbc/sa</property>

<propertyname="show_sql">true</property>

<propertyname="dialect">org.hibernate.dialect.SQLServerDialect</property>

<mappingresource="com/accp/t15/Customer.hbm.xml"/>

</session-factory>

11、對象的三大狀態

自由(transient)

與session無關

持久(persistent)

由session來管理

在持久狀態中通過get方法取出對方

遊離(detached)

被session拋棄

12、hibernate常見優化策略

用最新版本的hibernate

制定合理的緩存策略

採用合理的session管理機制

儘量使用延遲加載

many

大文本、大文件

設定合理的批處理參數(batch-size)

如有可能，選用uuid作爲主鍵生成器

如有可能，選用基於version的樂觀鎖替代悲觀鎖

開發過程中，打開hibernate的SQl日誌輸出(hibernate.show_sql=true)，通過觀察hibernate生成的sql語句進一步瞭解其實現原理，從而指事實上更好的實現策略。

6. iBatis持久層技術

用ibatis的原因:

只對開發團隊提供幾條SelectSQL（或存儲過程）以獲取所需數據，具體的表結構不予公開。

開發規範中要求，所有牽涉到業務邏輯部分的數據庫操作，必須在數據庫層由存儲過程實現

系統數據處理量巨大，性能要求極爲苛刻，這往往意味着我們必須通過經過高度優化的SQL語句

（或存儲過程）才能達到系統性能設計指標。

jdbc、hibernate、ibatis的區別

jdbc:手動

手動寫sql

delete、insert、update要將對象的值一個一個取出傳到sql中,不能直接傳入一個對象。

select:返回的是一個resultset，要從ResultSet中一行一行、一個字段一個字段的取出，然後封裝到一個對象中，不直接返回一個對象。

ibatis的特點:半自動化

sql要手動寫

delete、insert、update:直接傳入一個對象

select:直接返回一個對象

hibernate:全自動

不寫sql,自動封裝

delete、insert、update:直接傳入一個對象

select:直接返回一個對象

ibatis的核心配置文件:

sqlmapclient.xml：數據庫連接及相關o/rMapping的映射文件(hibernate.cfg.xml)

sqlmapBuy.xml:具體的o/rmapping映射(*.hbm.xml)

四大標記:

select

update

delete

insert

procedure

ibatis的核心類:

SqlMapClientBuilder:加載配置文件，返回一個會話。

SqlMapClient:具體的會話

List list=queryForList("標籤名",object);

Object obj=queryForObject("標籤名",object);

delete("標籤名",object)

update("標籤名",object)

insert("標籤名",object)

工程的使用:

將ibatisfactory拷貝到工程目錄下

將ms的3個包及ibatis的三個包拷貝到/WEB-INF/lib下

修改ibatisfactory中的abatorConfig.xml文件

進入ibatisfactory目錄運行java -jar abator.jar abatorConfig.xml true

將sql標記、select、update、insert、delete的副本刪除

spring&ibatis:

dataSource

sqlMapClient:SqlMapClientFactoryBean

configLocation

classpath:sqlMapClient.xml

/WEB-INF/sqlMapClient.xml

dataSource

transactionManager:DataSourceTransactionManager

dataSource

customerDao extendsSqlMapClientDaoSupport

sqlMapClient

buyDao

sqlMapClient

Facade

buyDao

customerDao

abstractProxy:TransactionProxyFactoryBean

transactionManager

transactionAttributes

facadeProxy

target:façade

7 Structs界面控制層技術

1、請說出struts框架的幾大組件？

1、MVC

2、標籤庫

3、校驗框架

4、國際化

5、tiles

3、struts的核心類有那些，在MVC模式中其對應的關係是什麼？

ActionServlet

RequestProcessor

Action

actionMapping(struts-config.xml)

actionFormard

ActionForm

Jsp

Dao

Manager(facade)

4、Struts的處理請求的全過程是什麼?

url-> ActionServlet(process)-> RequestProcessor(process)->實例化form ->填充form值->進行校驗->實例化action->調用execute

5、在struts中如何通過一個url找到一個action，它的核心配置文件是什麼?

配置文件是struts-config.xml

6、爲什麼使用MVC，其主要目的是什麼?

讓v與M強制解耦，提高可重用性（旅館的服務員(C)）

7、對於MVC在action中對應有類有幾種，各有什麼作用?

 Action:

1) 基本的

 DispatchAction:

2) 存在多個方法，根據頁面傳入的表單域的值調用不同的方法，表單域的名稱在<action param=””/>標記中進行配置

 LookupDispatchAction

3) 多個按鈕用同一個action的不同方法。實現getMap方法,說明每一個按鈕在*.properties中的鍵名及鍵值，在struts-config.xml通過parameter說明按鈕的名稱，按鈕的值對應*.properties的值，通過值找鍵名，通過鍵名找Map中的鍵名找到值就是相應的方法。

 MappingDispatchAction:未知

 forwordAction:直接跳轉到不同頁面不執行邏輯(???)

 類所在的包:org.apache.struts.actions.ForwardAction

8、struts的標記有幾類，請列舉並說明其作用?

Bean:

<bean:define scope=”” name=”” property=”” id=””/>

<bean:write name=”customer” property=”customerName”/>

<bean:message key=””/>國際化

Logic:

<logic:iteator> //將集合的內容取出

<logic:present> //

<logic:equals> //

Html:

<html:file>上傳文件

<html:select property=”sex”>

<html:optionscollection=”” property=”” labelProperty=””/>

</html:select>

9、如何在struts中配置數據源在,什麼文件?用什麼標籤?如何取出DataSource?

Struts-config.xml

<data-sources>

<data-sourcekey="data"type="org.apache.commons.dbcp.BasicDataSource">

<set-propertyproperty="driverClassName" value="com.microsoft.jdbc.sqlserver.SQLServerDriver" />

<set-property property="url" value="jdbc:microsoft:sqlserver://localhost:1433;databaseName=t23"/>

<set-property property="username"value="sa" />

<set-property property="password"value="" />

</data-source>

</data-sources>

DataSourceds=(DataSource)this.getServlet().getServletContext().getAttribute("data");

Connectioncon=ds.getConnection();

10、如何實現struts的validator框架？

 手動:

 publicclass myForm extends ActionForm

 {

 publicActionErrors validate()

 {

actionErrors.add(ActionErrors.GLOBAL_MESSAGE,newActionMessage("properties中的鍵名"));

 }

 struts-config.xml中修改action的標籤validate=true

 input="錯誤頁面"

 如果validate方法中的ActionErrors不爲空且size>0時

 會回到input頁面。

 自動

 publicclass myForm extends ValidateForm

 {

 不能覆蓋validate方法。

 //publicvoid validate()

 //{



 //}

 }

 在struts-config.xml文件中加入插件

 <plug-in className="org.apache.struts.validator.ValidatorPlugIn">

 <set-propertyproperty="pathnames"value="/WEB-INF/validator-rules.xml,/WEB-INF/validation.xml" />

 </plug-in>

 修改validation.xml中的內容

 errors.required={0}is required.

 errors.minlength={0}can not be less than {1} characters.

 <formset>

 <formname="loginForm">

 <fieldproperty="userName" depends="required">

 <arg0key="userName" />

 </field>

 <fieldproperty="pwd" depends="required,minlength">

 <arg0key="pwd" />

 <arg1key="${var:minlength}" resource="false"/>

 <var>

 <var-name>minlength</var-name>

 <var-value>6</var-value>

 </var>

 </field>

 </form>

 </formset>

 struts-config.xml中修改action的標籤validate=true

 input="/錯誤頁面"

12、如何實現國際化?

國際化:不用修改代碼，就適用於不同的語言國家

本地化:如果要適應一個國家，要修改源代碼

實現過程:

在struts-config.xml中用如下標籤說明資源文件名，注意其只是文件名，沒有語言_國家

<message-resourcesparameter="struts.ApplicationResources" />

在資源文件對應的目錄struts中加入適應不同語言、國家的properties文件

ApplicationResources_zh_CN.properties中國

ApplicationResources_en_US.propertiesus

如果不是英語要轉碼

native2ascii -encoding gb2312 源ApplicationResources_zh_CN.properties

在jsp頁面中用

<bean:messagekey=""/>取出信息

8 Spring應用框架技術

1、Spring和Struts的區別？
strusts：是一種基於MVC模式的一個web層的處理。

Spring:提供了通用的服務，ioc/di aop,關心的不僅僅web層，應當j2ee整體的一個服務，可以很容易融合不同的技術struts hibernateibatis ejb remote springJDBC springMVC

2、什麼是aop，aop的作用是什麼?

Oop：縱向的業務

Aop：oop的一個橫向的服務，是對oop進一步的補充，提供安全、事務、日誌等的集中式處理，相關的裝備before、around、after exception

3、aop中的關鍵名詞有些那些，相互關係是什麼?

攔截器: 代理

裝備(advice)

目標對象

關切點:條件

連接點:方法、屬性

4、依賴注入的方式有幾種，各是什麼?

Setter

Interface

constructor

5、spring中的核心類有那些，各有什麼作用?

BeanFactory：產生一個新的實例，可以實現單例模式

BeanWrapper：提供統一的get及set方法

ApplicationContext:提供框架的實現，包括BeanFactory的所有功能

6、ApplicationContext的作用

beanFactory

國際化(getMesage)

資源管理:可以直接讀取一個文件的內容(getResource)

加入web框架中(加入一個servlet或監聽器)

事件處理

7、如何實現資源管理

使用

applicationContext.getResource(“classpath:文件名”):在src根目錄下，在類路徑下

applicationContext.getResource(“classpath:/chap01/文件名”): 以src根目錄下的基準往下走。

applicationContext.getResource(“file:c:/a.properties”)：在系統文件目錄下。

8、如何實現加入web框架中

在web.xml中加入如下同容,在啓動web服務器時加載/WEB-INF/applicationContext.xml中的內容。

<servlet-name>context</servlet-name>

<servlet-class>

org.springframework.web.context.ContextLoaderServlet

</servlet-class>

<load-on-startup>1</load-on-startup>

</servlet>

通過如下類得到ApplicationContext實例

WebApplicationContextUtils.getWebApplicationContext

9、如何實現事件處理

事件

ExtendsApplicationEvent

監聽器

ImplementsApplicationListener

事件源

ImplementsApplicationContextAware

在applicationContext.xml中配置事件源、監聽器

先得到事件源，調用事件源的方法，通知監聽器。

10、spring的ioc及di代表什麼意思?

Ioc:程序在運行過程中，根據配置文件動態加載所依賴的配置類

、如何在spring中實現國際化?

 在applicationContext.xml加載一個bean

<value>message</value>

</property>

</bean>

 在src目錄下建多個properties文件

 對於非英文的要用native2ascii -encoding gb2312 源目轉化文件相關內容

 其命名格式是message_語言_國家。

 頁面中的中顯示提示信息，鍵名取鍵值。

 當給定國家，系統會自動加載對應的國家的properties信息。

 通過applictionContext.getMessage(“鍵名”,”參數”,”區域”)取出相關的信息。

12、spring的配置的主要標籤是什麼?有什麼作用?

<beans>

<propertyname=””>

</property>

</property>

</bean>

</beans>

13、spring與ejb2.0的事務管理比較的優缺點?

測試:

Spring:pojo

Ejb:二個接口一個類,一堆配置文件

事務類型

Spring:jdbc jta hibernate

Ejb:jta

成本

Spring:普通容器(tomcat jboss)

Ejb:weblogic jboss

開發的週期:

Spring遠比ejb快.

14、spring的jdbc與傳統的jdbc有什麼區別，其核心類有那些?

Spring的jdbc:節省代碼，不管連接(Connection)，不管事務、不管異常、不管關閉(con.close() ps.close )

JdbcTemplate(dataSource):增、刪、改、查

TransactionTemplate(transactionManager):進行事務處理

15、在spring中有幾種事務管理，分別是什麼?

代碼管理的事務處理

TransactonTemplate的execute方法中的內部類TransactionCallback中的doInTransaction方法中使用。

public void make()

{

TransactionTemplate jtm=newTransactionTemplate(this.getTransactionManager());

jtm.execute(new myClass1());

}

public class myClass1 implementsTransactionCallback

{

public ObjectdoInTransaction(TransactionStatus trans)

{

JdbcTemplate jdbc=newJdbcTemplate(dataSource);

jdbc.execute("insertinto customer(customerName) values('b')");

return null;

}

容器管理的事務處理

16、在spring中如何配代碼的事務管理?

Datasouce

transactionManager

userDao要注入

Datasouce

transactionManager

通過如下類實現

TransactionTemplate

JdbcTemplate

17、在spring中如何配容器的事務管理，相關的類有那些?

Datasouce

transactionManager

userDao要注入

Datasouce

Proxy代理

Target:userDao：代理對象(目標對象)

transactionAttributes(那些方法需要事務處理)

transactionManager(事務處理服務)

18、如果spring與hibernate結合在一起可以不需要hibernate.cfg.xml文件是否正確?

不需要

19、spring+hibernate的配置文件中的主要類有那些?如何配置?

在myeclipse中先加入spring環境再加入hibernate環境。

如果spring與hibernate結合在一起可以不需要hibernate.cfg.xml文件是否正確?

spring+hibernate的配置文件中的主要類有那些?如何配置?

dataSource

sessionFactory:hibernate.cfg.xml

transactionManager

userDao (extendsHibernateDaoSupport)

sessionFactory

facade

proxy

sessionFactory

transactionManager

facade

20、spring+hibernate的代碼實現中，對於實現類一定繼承於一個類是那一個，它有什麼作用。

extends HibernateDaoSupport，可以節省代碼。

21、如何配置spring+struts?

 在struts-config.xml加入一個插件，通過它加載applicationContext.xml

 在struts-config.xml修改action-mapping標記，具體action交給了DelegateActionProxy

 通過DelegateActionProxy進入一spring的環境。

 在spring的applicationContext.xml加入<bean name="/login"class="" singleton="false"/>

22、如何在web環境中配置applicationContext.xml文件?

<listener-class>

org.springframework.web.context.ContextLoaderListener

</listener-class>

</listener>

或：

<servlet-name>context</servlet-name>

<servlet-class>

org.springframework.web.context.ContextLoaderServlet

</servlet-class>

<load-on-startup>1</load-on-startup>

</servlet>

通過如下方法取出applicationContext實例:

ApplicationContextac=WebApplicationContextUtils.getWebApplicationContext(this.getServletContext);

一、spring工作原理：

1.spring mvc請所有的請求都提交給DispatcherServlet,它會委託應用系統的其他模塊負責負責對請求進行真正的處理工作。
2.DispatcherServlet查詢一個或多個HandlerMapping,找到處理請求的Controller.
3.DispatcherServlet請請求提交到目標Controller
4.Controller進行業務邏輯處理後，會返回一個ModelAndView
5.Dispathcher查詢一個或多個ViewResolver視圖解析器,找到ModelAndView對象指定的視圖對象
6.視圖對象負責渲染返回給客戶端。

二、爲什麼要用spring:

AOP 讓開發人員可以創建非行爲性的關注點，稱爲橫切關注點，並將它們插入到應用程序代碼中。使用 AOP 後，公共服務（比如日誌、持久性、事務等）就可以分解成方面並應用到域對象上，同時不會增加域對象的對象模型的複雜性。

IOC 允許創建一個可以構造對象的應用環境，然後向這些對象傳遞它們的協作對象。正如單詞倒置所表明的，IOC就像反過來的 JNDI。沒有使用一堆抽象工廠、服務定位器、單元素（singleton）和直接構造（straight construction），每一個對象都是用其協作對象構造的。因此是由容器管理協作對象（collaborator）。

Spring即使一個AOP框架，也是一IOC容器。 Spring 最好的地方是它有助於您替換對象。有了 Spring，只要用 JavaBean 屬性和配置文件加入依賴性（協作對象）。然後可以很容易地在需要時替換具有類似接口的協作對象。

三、請你談談SSH整合：

SSH：
Struts（表示層）+Spring（業務層）+Hibernate（持久層）
Struts：
Struts是一個表示層框架，主要作用是界面展示，接收請求，分發請求。
在MVC框架中，Struts屬於VC層次，負責界面表現，負責MVC關係的分發。（View：沿用 JSP，HTTP，Form，Tag，Resourse ；Controller：ActionServlet，struts-config.xml，Action）
Hibernate：
Hibernate是一個持久層框架，它只負責與關係數據庫的操作。
Spring：
Spring是一個業務層框架，是一個整合的框架，能夠很好地黏合表示層與持久層。

四、介紹一下Spring的事務管理：

事務就是對一系列的數據庫操作（比如插入多條數據）進行統一的提交或回滾操作，如果插入成功，那麼一起成功，如果中間有一條出現異常，那麼回滾之前的所有操作。
這樣可以防止出現髒數據，防止數據庫數據出現問題。
開發中爲了避免這種情況一般都會進行事務管理。Spring中也有自己的事務管理機制，一般是使用TransactionMananger進行管理，可以通過Spring的注入來完成此功能。

spring提供了幾個關於事務處理的類：
TransactionDefinition //事務屬性定義
TranscationStatus //代表了當前的事務，可以提交，回滾。
PlatformTransactionManager這個是spring提供的用於管理事務的基礎接口，其下有一個實現的抽象類 AbstractPlatformTransactionManager,我們使用的事務管理類例如 DataSourceTransactionManager等都是這個類的子類。

一般事務定義步驟：

TransactionDefinition td = new TransactionDefinition();
TransactionStatus ts = transactionManager.getTransaction(td);
try
{ //do sth
transactionManager.commit(ts);
}
catch(Exception e){transactionManager.rollback(ts);}

spring提供的事務管理可以分爲兩類：編程式的和聲明式的。編程式的，比較靈活，但是代碼量大，存在重複的代碼比較多；聲明式的比編程式的更靈活。

編程式主要使用transactionTemplate。省略了部分的提交，回滾，一系列的事務對象定義，需注入事務管理對象.
void add(){
transactionTemplate.execute( new TransactionCallback(){
pulic Object doInTransaction(TransactionStatus ts)
{ //do sth}
}
}

聲明式：

使用TransactionProxyFactoryBean:

PROPAGATION_REQUIRED PROPAGATION_REQUIRED PROPAGATION_REQUIRED,readOnly

圍繞Poxy的動態代理能夠自動的提交和回滾事務
org.springframework.transaction.interceptor.TransactionProxyFactoryBean

PROPAGATION_REQUIRED–支持當前事務，如果當前沒有事務，就新建一個事務。這是最常見的選擇。

PROPAGATION_SUPPORTS–支持當前事務，如果當前沒有事務，就以非事務方式執行。

PROPAGATION_MANDATORY–支持當前事務，如果當前沒有事務，就拋出異常。

PROPAGATION_REQUIRES_NEW–新建事務，如果當前存在事務，把當前事務掛起。

PROPAGATION_NOT_SUPPORTED–以非事務方式執行操作，如果當前存在事務，就把當前事務掛起。

PROPAGATION_NEVER–以非事務方式執行，如果當前存在事務，則拋出異常。

PROPAGATION_NESTED–如果當前存在事務，則在嵌套事務內執行。如果當前沒有事務，則進行與PROPAGATION_REQUIRED類似的操作。

五、Spring裏面如何配置數據庫驅動？

使用”org.springframework.jdbc.datasource.DriverManagerDataSource”數據源來配置數據庫驅動。示例如下：
<bean id=”dataSource”>
<property name=”driverClassName”>
<value>org.hsqldb.jdbcDriver</value>
</property>
<property name=”url”>
<value>jdbc:hsqldb:db/appfuse</value>
</property>
<propertyname=”username”><value>sa</value></property>
<propertyname=”password”><value></value></property>
</bean>

六、Spring裏面applicationContext.xml文件能不能改成其他文件名？

ContextLoaderListener是一個ServletContextListener, 它在你的web應用啓動的時候初始化。缺省情況下，它會在WEB-INF/applicationContext.xml文件找Spring的配置。你可以通過定義一個<context-param>元素名字爲”contextConfigLocation”來改變Spring配置文件的位置。示例如下：

<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener <context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/xyz.xml</param-value>
</context-param> </listener-class>
</listener>

七、如何在web應用裏面配置spring?

在web.xml中加入如下同容,在啓動web服務器時加載/WEB-INF/applicationContext.xml中的內容。
<servlet>
<servlet-name>context</servlet-name>
<servlet-class>
org.springframework.web.context.ContextLoaderServlet
</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
通過如下類得到ApplicationContext實例
WebApplicationContextUtils.getWebApplicationContext

八、Spring裏面如何定義hibernate mapping？

添加hibernate mapping 文件到web/WEB-INF目錄下的applicationContext.xml文件裏面。示例如下：
<property name=”mappingResources”>
<list>
<value>org/appfuse/model/User.hbm.xml</value>
</list>
</property>

九、解釋一下Dependency injection(DI,依賴注入)和IOC(Inversion of control,控制反轉)?

依賴注入DI是一個程序設計模式和架構模型，一些時候也稱作控制反轉，儘管在技術上來講，依賴注入是一個IOC的特殊實現，依賴注入是指一個對象應用另外一個對象來提供一個特殊的能力，例如：把一個數據庫連接已參數的形式傳到一個對象的結構方法裏面而不是在那個對象內部自行創建一個連接。控制反轉和依賴注入的基本思想就是把類的依賴從類內部轉化到外部以減少依賴
應用控制反轉，對象在被創建的時候，由一個調控系統內所有對象的外界實體，將其所依賴的對象的引用，傳遞給它。也可以說，依賴被注入到對象中。所以，控制反轉是，關於一個對象如何獲取他所依賴的對象的引用，這個責任的反轉。

十、spring中的BeanFactory與ApplicationContext的作用有哪些？

1. BeanFactory負責讀取bean配置文檔，管理bean的加載，實例化，維護bean之間的依賴關係，負責bean的聲明週期。
2. ApplicationContext除了提供上述BeanFactory所能提供的功能之外，還提供了更完整的框架功能：

a. 國際化支持
b. 資源訪問：Resource rs = ctx. getResource(”classpath:config.properties”),“file:c:/config.properties”
c. 事件傳遞：通過實現ApplicationContextAware接口
3. 常用的獲取ApplicationContext的方法：
FileSystemXmlApplicationContext：從文件系統或者url指定的xml配置文件創建，參數爲配置文件名或文件名數組
ClassPathXmlApplicationContext：從classpath的xml配置文件創建，可以從jar包中讀取配置文件
WebApplicationContextUtils：從web應用的根目錄讀取配置文件，需要先在web.xml中配置，可以配置監聽器或者 servlet來實現
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<servlet>
<servlet-name>context</servlet-name>
<servlet-class>org.springframework.web.context.ContextLoaderServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
這兩種方式都默認配置文件爲web-inf/applicationContext.xml，也可使用context-param指定配置文件
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/myApplicationContext.xml</param-value>
</context-param>

十一、如何在web環境中配置applicationContext.xml文件?

<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>
或：
<servlet>
<servlet-name>context</servlet-name>
<servlet-class>
org.springframework.web.context.ContextLoaderServlet
</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
通過如下方法取出applicationContext實例:
ApplicationContextac=WebApplicationContextUtils.getWebApplicationContext(this.getServletContext);

十二、如何配置spring+struts?

在struts-config.xml加入一個插件，通過它加載applicationContext.xml
Ø 在struts-config.xml修改action-mapping標記，具體action交給了DelegateActionProxy
u 通過DelegateActionProxy進入一spring的環境。
Ø 在spring的applicationContext.xml加入<beanname=”/login” class=”" singleton=”false”/>

十三、spring+hibernate的配置文件中的主要類有那些?如何配置?

dataSource
sessionFactory:hibernate.cfg.xml
transactionManager
userDao (extends HibernateDaoSupport)
sessionFactory
facade
proxy
sessionFactory
transactionManager
facade

在myeclipse中先加入spring環境再加入hibernate環境。
如果spring與hibernate結合在一起可以不需要hibernate.cfg.xml文件是否正確

十四、如何在spring中實現國際化?

在applicationContext.xml加載一個bean
<bean id=”messageSource”class=”org.springframework.context.support.ResourceBundleMessageSource”>
<property name=”basename”>
<value>message</value>
</property>
</bean>
在src目錄下建多個properties文件Ø
對於非英文的要用native2ascii -encoding gb2312 源Ø 目轉化文件相關內容
其命名格式是message_語言_國家。Ø
頁面中的中顯示提示信息，鍵名取鍵值。Ø
Ø 當給定國家，系統會自動加載對應的國家的properties信息。
Ø 通過applictionContext.getMessage(“鍵名”,”參數”,”區域”)取出相關的信息。

十五、spring中的核心類有那些，各有什麼作用?

BeanFactory：產生一個新的實例，可以實現單例模式
BeanWrapper：提供統一的get及set方法
ApplicationContext:提供框架的實現，包括BeanFactory的所有功能

十六、什麼是aop，aop的作用是什麼?

面向切面編程（AOP）提供另外一種角度來思考程序結構，通過這種方式彌補了面向對象編程（OOP）的不足
除了類（classes）以外，AOP提供了切面。切面對關注點進行模塊化，例如橫切多個類型和對象的事務管理
Spring的一個關鍵的組件就是AOP框架，可以自由選擇是否使用AOP
提供聲明式企業服務，特別是爲了替代EJB聲明式服務。最重要的服務是聲明性事務管理，這個服務建立在Spring的抽象事物管理之上
允許用戶實現自定義切面，用AOP來完善OOP的使用
可以把Spring AOP看作是對Spring的一種增強

十七、使用Spring有什麼好處？

◆Spring能有效地組織你的中間層對象,無論你是否選擇使用了EJB。如果你僅僅使用了Struts或其他的包含了J2EE特有APIs的 framework，你會發現Spring關注了遺留下的問題，。

◆Spring能消除在許多工程上對Singleton的過多使用。根據我的經驗，這是一個主要的問題，它減少了系統的可測試性和麪向對象特性。
◆Spring能消除使用各種各樣格式的屬性定製文件的需要,在整個應用和工程中，可通過一種一致的方法來進行配置。曾經感到迷惑，一個特定類要查找迷幻般的屬性關鍵字或系統屬性,爲此不得不讀Javadoc乃至源編碼嗎？有了Spring，你可很簡單地看到類的JavaBean屬性。倒置控制的使用(在下面討論)幫助完成這種簡化。
◆Spring能通過接口而不是類促進好的編程習慣，減少編程代價到幾乎爲零。
◆Spring被設計爲讓使用它創建的應用儘可能少的依賴於他的APIs。在Spring應用中的大多數業務對象沒有依賴於Spring。
◆使用Spring構建的應用程序易於單元測試。
◆Spring能使EJB的使用成爲一個實現選擇,而不是應用架構的必然選擇。你能選擇用POJOs或local EJBs來實現業務接口，卻不會影響調用代碼。
◆Spring幫助你解決許多問題而無需使用EJB。Spring能提供一種EJB的替換物，它們適於許多web應用。例如,Spring能使用AOP提供聲明性事務而不通過使用EJB容器，如果你僅僅需要與單個的數據庫打交道，甚至不需要JTA實現。
■Spring爲數據存取提供了一致的框架,不論是使用JDBC或O/R mapping產品（如Hibernate）。
Spring確實使你能通過最簡單可行的解決辦法解決你的問題。這些特性是有很大價值的。
總結起來，Spring有如下優點：
◆低侵入式設計，代碼污染極低
◆ 獨立於各種應用服務器，可以真正實現Write Once,Run Anywhere的承諾
◆Spring的DI機制降低了業務對象替換的複雜性
◆Spring並不完全依賴於Spring，開發者可自由選用Spring框架的部分或全部

十八、什麼是Spring, 它有什麼特點？

Spring是一個輕量級的控制反轉(IoC)和麪向切面(AOP)的容器框架。

◆輕量——從大小與開銷兩方面而言Spring都是輕量的。完整的Spring框架可以在一個大小隻有1MB多的JAR文件裏發佈。並且Spring所需的處理開銷也是微不足道的。此外，Spring是非侵入式的：典型地，Spring應用中的對象不依賴於Spring的特定類。

◆控制反轉——Spring通過一種稱作控制反轉（IoC）的技術促進了鬆耦合。當應用了IoC，一個對象依賴的其它對象會通過被動的方式傳遞進來，而不是這個對象自己創建或者查找依賴對象。你可以認爲IoC與JNDI相反——不是對象從容器中查找依賴，而是容器在對象初始化時不等對象請求就主動將依賴傳遞給它。
◆面向切面——Spring提供了面向切面編程的豐富支持，允許通過分離應用的業務邏輯與系統級服務（例如審計（auditing）和事務（）管理）進行內聚性的開發。應用對象只實現它們應該做的——完成業務邏輯——僅此而已。它們並不負責（甚至是意識）其它的系統級關注點，例如日誌或事務支持。
◆容器——Spring包含並管理應用對象的配置和生命週期，在這個意義上它是一種容器，你可以配置你的每個bean如何被創建——基於一個可配置原型（prototype），你的bean可以創建一個單獨的實例或者每次需要時都生成一個新的實例——以及它們是如何相互關聯的。然而，Spring不應該被混同於傳統的重量級的EJB容器，它們經常是龐大與笨重的，難以使用。
◆框架——Spring可以將簡單的組件配置、組合成爲複雜的應用。在Spring中，應用對象被聲明式地組合，典型地是在一個XML文件裏。 Spring也提供了很多基礎功能（事務管理、持久化框架集成等等），將應用邏輯的開發留給了你。

十九、請介紹一下Spring框架中Bean的生命週期

一、Bean的定義
Spring通常通過配置文件定義Bean。如：

<?xml version=”1.0″ encoding=”UTF-8″?>
<beans xmlns=”http://www.springframework.org/schema/beans”
xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”
xsi:schemaLocation=”http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-2.0.xsd”>
<bean id=”HelloWorld” class=”com.pqf.beans.HelloWorld”>
<property name=”msg”>
<value>HelloWorld</value>
</property>
</bean>
</beans>

這個配置文件就定義了一個標識爲 HelloWorld 的Bean。在一個配置文檔中可以定義多個Bean。

二、Bean的初始化
有兩種方式初始化Bean。
1、在配置文檔中通過指定init-method 屬性來完成
在Bean的類中實現一個初始化Bean屬性的方法，如init()，如：
public class HelloWorld{
public String msg=null;
public Date date=null;

public void init() {
msg=”HelloWorld”;
date=new Date();
}
……
}
然後，在配置文件中設置init-mothod屬性：
<bean id=”HelloWorld” class=”com.pqf.beans.HelloWorld” init-mothod=”init”>
</bean>

2、實現 org.springframwork.beans.factory.InitializingBean接口
Bean實現InitializingBean接口，並且增加afterPropertiesSet() 方法：

public class HelloWorld implement InitializingBean {
public String msg=null;
public Date date=null;

public void afterPropertiesSet() {
msg=”向全世界問好！”;
date=new Date();
}
……
}

那麼，當這個Bean的所有屬性被Spring的BeanFactory設置完後，會自動調用afterPropertiesSet()方法對Bean進行初始化，於是，配置文件就不用指定 init-method屬性了。

三、Bean的調用
有三種方式可以得到Bean並進行調用：
1、使用BeanWrapper
HelloWorld hw=new HelloWorld();
BeanWrapper bw=new BeanWrapperImpl(hw);
bw.setPropertyvalue(”msg”,”HelloWorld”);
system.out.println(bw.getPropertyCalue(”msg”));

2、使用BeanFactory
InputStream is=new FileInputStream(”config.xml”);
XmlBeanFactory factory=new XmlBeanFactory(is);
HelloWorld hw=(HelloWorld) factory.getBean(”HelloWorld”);
system.out.println(hw.getMsg());

3、使用ApplicationConttext
ApplicationContext actx=new FleSystemXmlApplicationContext(”config.xml”);
HelloWorld hw=(HelloWorld) actx.getBean(”HelloWorld”);
System.out.println(hw.getMsg());

四、Bean的銷燬
1、使用配置文件中的 destory-method 屬性
與初始化屬性 init-methods類似，在Bean的類中實現一個撤銷Bean的方法，然後在配置文件中通過 destory-method指定，那麼當bean銷燬時，Spring將自動調用指定的銷燬方法。

2、實現 org.springframwork.bean.factory.DisposebleBean接口
如果實現了DisposebleBean接口，那麼Spring將自動調用bean中的Destory方法進行銷燬，所以，Bean中必須提供 Destory方法。

二十、AOP裏面重要的幾個名詞概念解釋：

切面（Aspect）：一個關注點的模塊化，這個關注點可能會橫切多個對象。事務管理是J2EE應用中一個關於橫切關注點的很好的例子。在Spring AOP中，切面可以使用通用類（基於模式的風格）或者在普通類中以 @Aspect 註解（@AspectJ風格）來實現。

連接點（Joinpoint）：在程序執行過程中某個特定的點，比如某方法調用的時候或者處理異常的時候。在Spring AOP中，一個連接點總是代表一個方法的執行。通過聲明一個org.aspectj.lang.JoinPoint類型的參數可以使通知（Advice）的主體部分獲得連接點信息。

通知（Advice）：在切面的某個特定的連接點（Joinpoint）上執行的動作。通知有各種類型，其中包括“around”、“before”和“after”等通知。通知的類型將在後面部分進行討論。許多AOP框架，包括Spring，都是以攔截器做通知模型，並維護一個以連接點爲中心的攔截器鏈。

切入點（Pointcut）：匹配連接點（Joinpoint）的斷言。通知和一個切入點表達式關聯，並在滿足這個切入點的連接點上運行（例如，當執行某個特定名稱的方法時）。切入點表達式如何和連接點匹配是AOP的核心：Spring缺省使用AspectJ切入點語法。

引入（Introduction）：（也被稱爲內部類型聲明（inter-typedeclaration））。聲明額外的方法或者某個類型的字段。 Spring允許引入新的接口（以及一個對應的實現）到任何被代理的對象。例如，你可以使用一個引入來使bean實現 IsModified 接口，以便簡化緩存機制。

目標對象（Target Object）：被一個或者多個切面（aspect）所通知（advise）的對象。也有人把它叫做被通知（advised）對象。既然Spring AOP是通過運行時代理實現的，這個對象永遠是一個被代理（proxied）對象。

AOP代理（AOP Proxy）： AOP框架創建的對象，用來實現切面契約（aspect contract）（包括通知方法執行等功能）。在Spring中，AOP代理可以是JDK動態代理或者CGLIB代理。注意：Spring 2.0最新引入的基於模式（schema-based）風格和@AspectJ註解風格的切面聲明，對於使用這些風格的用戶來說，代理的創建是透明的。

織入（Weaving）：把切面（aspect）連接到其它的應用程序類型或者對象上，並創建一個被通知（advised）的對象。這些可以在編譯時（例如使用AspectJ編譯器），類加載時和運行時完成。 Spring和其他純Java AOP框架一樣，在運行時完成織入。

通知的類型：

前置通知（Before advice）：在某連接點（joinpoint）之前執行的通知，但這個通知不能阻止連接點前的執行（除非它拋出一個異常）。

返回後通知（After returning advice）：在某連接點（join point）正常完成後執行的通知：例如，一個方法沒有拋出任何異常，正常返回。

拋出異常後通知（After throwing advice）：在方法拋出異常退出時執行的通知。

後通知（After (finally) advice）：當某連接點退出的時候執行的通知（不論是正常返回還是異常退出）。

環繞通知（Around Advice）：包圍一個連接點（joinpoint）的通知，如方法調用。這是最強大的一種通知類型。環繞通知可以在方法調用前後完成自定義的行爲。它也會選擇是否繼續執行連接點或直接返回它們自己的返回值或拋出異常來結束執行。

環繞通知是最常用的一種通知類型。大部分基於攔截的AOP框架，例如Nanning和JBoss4，都只提供環繞通知。

切入點（pointcut）和連接點（join point）匹配的概念是AOP的關鍵，這使得AOP不同於其它僅僅提供攔截功能的舊技術。切入點使得定位通知（advice）可獨立於OO層次。例如，一個提供聲明式事務管理的around通知可以被應用到一組橫跨多個對象中的方法上（例如服務層的所有業務操作）。

Ejb技術

1、weblogic的熱發佈

將ear、jar、war拷到C:\bea\user_projects\domains\mydomain\applications目錄

weblogic會自動發佈

通過jbuilder將ear或jar或war部署到服務器上。

2、在ejb中實現one-to-many

1、在many中的將外鍵字段屬性刪除

2、在刪除many中的值時要將Collection轉化爲ArrayList，

並反向遍歷ArrayList，先刪除ArrayList中值，根據

ArrayList刪除反回的對象轉化爲many的遠程接口，通過

遠程接口將many刪除

3、ejb所用的技術:

Jndi：java namingdirectory inferface

Rmi： remotemethod invoke

4、實現ejb幾個接口,幾個類?

兩個接口一個類

extends EJBHome

通過jndi得到home接口

create方法調用服務端的ejbCreate方法，在服務端產生一個EntityBean或SessionBean實例，向客戶端返回一個遠程接口。

通過find方法在從服務端找到一個EntityBean實例，向客戶端返回一個遠程接口。

extends EJBObject

在客戶端通過rmi調用遠程服務端方法。

通過remove方法調用服務端的ejbRemove方法，將EnityBean刪除

implements SessionBean

在服務端實現真正的處理，實現核心業務

5、實現ejb相關的配置文件是什麼?

ejb-jar.xml：說明ejb的兩個接口一個類的。

weblogic-ejb-jar.xml:說明ejb的JNDI名

weblogic-rdbms-ejb.xml:o-rMapping實現數據庫表、字段與ejb屬性對應的關係。

ejb2.0的開發

1、用jbuilder集成環境

2、可以用eclipse開發，用源代碼註釋說明，用ant執行xdoclet，xdoclet通

過源代碼註釋自動生相關的配置、兩個接口一個類。

/**

* @stateLess

* @remote

6、ejb的分類?區別

sessionBean

stateless:方法間不保留(1..1)

statefull:方法間保留(1..n)

entityBean:持久化

cmp:增刪改容器

bmp:增刪改手動jdbc

message driver bean

異處的消息處理

7、本地接口與遠程接口的區別。

EJBHome(在不同的進程或主機間調用,即不同的jvm)

EJBObjet

EJBLocalHome(在同一進程，同是jvm中)

EJBLocalObject

8、請求處理的過程?

會話

url

factory

通過jndi得到一個home實例

在客戶端通過home實例在服務端產生一個sessionBean，客戶端返回一個接口

客戶端通過遠程接口調用方法。

9、statefull的生命週期

不存在

setSessionContext

create--->ejbcreate

就緒:可以調用remove方法將sessionBean刪除、可以調用服務端的任何方法。

ejbPassivate(從就緒到掛起)

ejbActivate(從掛起到就緒)

掛起

如果超時自動刪除

10、stateless的生命週期

不存在

setSessionContext

create--->ejbcreate

remove-->ejbremove

就緒

11、entityBean的生命週期:

不存在

setEntityContext

create--->ejbcreate

入池

空房子，沒加載數據

ejbActivate

ejbPassivate

就緒

remove-->ejbRemove

加載了數據庫的數據

12、EJB需直接實現它的業務接口或Home接口嗎，請簡述理由。

遠程接口和Home接口不需要直接實現，

他們的實現代碼是由服務器產生的，

程序運行中通過接口調用服務端產生的實例。

13、EJB的激活機制

以Stateful Session Bean 爲例：其Cache大小決定了內存中可以同時存在的Bean實例的數量，根據MRU或NRU算法，實例在就緒和掛起狀態之間遷移。

就緒:從文件到內存，調用ejbActivate方法

掛起:從內存到文件，調用ejbPassivate方法

14、EJB是基於哪些技術實現的？並說出SessionBean和EntityBean的區別，

EJB包括Session Bean、Entity Bean、Message Driven Bean，基於JNDI、RMI、JTA等技術實現.

SessionBean在J2EE應用程序中被用來完成一些服務器端的業務操作。例如訪問數據庫、調用其他EJB組件.

EntityBean被用來代表應用系統中用到的數據.對於客戶機，

SessionBean是一種非持久性對象，它實現某些在服務器上運行的業務邏輯;

EntityBean是一種持久性對象，它代表一個存儲在持久性存儲器中的實體的對象視圖，或是一個由現有企業應用程序實現的實體.

Session Bean 還可以再細分爲 Stateful Session Bean 與Stateless Session Bean .這兩種的 Session Bean都可以將系統邏輯放在 method之中執行，不同的是 Stateful Session Bean 可以記錄呼叫者的狀態，因此通常來說，一個使用者會有一個相對應的 Stateful Session Bean 的實體.Stateless SessionBean 雖然也是邏輯組件，但是他卻不負責記錄使用者狀態，也就是說當使用者呼叫 StatelessSession Bean 的時候，EJB Container 並不會找尋特定的 Stateless Session Bean 的實體來執行這個 method.換言之，很可能數個使用者在執行某個 Stateless Session Bean 的 methods 時，會是同一個 Bean 的 Instance 在執行.從內存方面來看， Stateful Session Bean 與 Stateless SessionBean 比較， Stateful Session Bean 會消耗 J2EE Server 較多的內存，然而 Stateful Session Bean 的優勢卻在於他可以維持使用者的狀態.

15、EJB的分類是什麼?各有什麼特點?

sessionBean:主機重起消失

Stateless:不記憶

StateFull:一個用戶多個操作可記憶

EntityBean:持久的數據庫中

Cmp：容器通過o/r mapping實現數據的持久化，不寫sql，實現方便，在速度慢。

Bmp:通過jdbc實現持久化,實現複雜，速度快

messageBean：提供異步處理。

10、EJB中主要的配置文件及作用是什麼?

EJB部署時需要三個文件：

 Ejb-jar.xml:

 將二個接口一個類打包在一起，給EJB一個名稱。

 說明當前的sessionBean的事務是由容器處理的。

 其在所有的服務器上是通用的。

 Weblogic-ejb-jar.xml：

 將一個EJB名稱，對應一個JNDI，在僅對weblogic服務器

 Weblogic-rdbms-jar.xml：

 實現o/r mapping的說明,相當於*.hbm.xml

15、說出數據連接池的工作機制是什麼?

容器或相關的應用程序在其池中實例化多個邊接，當應用程序在使用時，容器直接將池中的連接取出應用程序直接使用，同時當應用程序使用完後，容器還可以將連接收回。從而提高系統的效率。

16、EJB2.0有哪些內容?分別用在什麼場合? EJB2.0和EJB1.1的區別?

sessionBean：是一個過程

entityBean：是持久化，代表的是一個業務實體，有主鍵。

Struts+sessionBean+entityBean

EJB2.0加入的本地接口及本地home

EJB1.1中只有遠程接口及遠程home

18、EJB與JAVA BEAN的區別？

Java Bean 是可複用的組件，任何一個Java類都可以是一個Bean。但通常情況下，Java Bean是被容器所創建（如Tomcat）的，所以Java Bean具有如下特點:

一個無參的構造器

實現Serializable接口

私有屬性

公有get set方法

Enterprise Java Bean 是一個分佈式組件，其特點是

基於（RMI）技術的，可以被遠程訪問（跨進程、跨計算機）。

EJB必須被佈署在Webspere、WebLogic容器中，不能直接訪問ejb，而是通過容器訪問ejb,容器是ejb訪問的一個代理。

19、EJB的角色和三個對象

六個角色組成，分別是

EJB組件開發者（Enterprise BeanProvider）:sun

應用組合者（Application Assembler）真正的開發商

部署者（Deployer）:

EJB 服務器提供者（EJB ServerProvider）:sun ibm 小機

EJB 容器提供者（EJB ContainerProvider）:weblogic jboss

系統管理員（SystemAdministrator）:維護員

三個對象是Remote（Local）接口、Home（LocalHome）接口，Bean類

20、EJB容器提供的服務

主要提供

安全

事務管理

分佈式

jts

聲明週期管理

代碼產生

持續性管理

鎖和併發行管理等服務。

21、EJB規範規定EJB中禁止的操作有哪些？

1.不能操作線程和線程API(線程API指非線程對象的方法如notify,wait等)，

2.不能操作awt，

3.不能實現服務器功能，

4.不能對靜態屬生存取，

5.不能使用IO操作直接存取文件系統，

6.不能加載本地庫.，

7.不能將this作爲變量和返回，

8.不能循環調用。

26、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 }

30、如何在weblogic中進行ssl配置與客戶端的認證配置或說說j2ee(標準)進行ssl的配置

缺省安裝中使用DemoIdentity.jks和DemoTrust.jks KeyStore實現SSL，需要配置服務器使用Enable SSL，配置其端口，在產品模式下需要從CA獲取私有密鑰和數字證書，創建identity和trust keystore，裝載獲得的密鑰和數字證書。可以配置此SSL連接是單向還是雙向的。

31如何查看在weblogic中已經發布的EJB?

可以使用管理控制檯，在它的Deployment中可以查看所有已發佈的EJB

WebService技術

1、什麼是Web Service?

Web Service就是爲了使原來各孤立的站點之間的信息能夠相互通信、共享而提出的一種接口。

使用的技術:

HTTP、XML、SOAP（簡單對象訪問協議）、WSDL

優點:

跨平臺、跨語言、跨系統

SOAP協議:

SOAP協議（Simple Object AccessProtocal,簡單對象訪問協議）

Tcp/ipàhttp->soap，soap 通過xml文件傳送信息

缺點：

(1).WebService使用了XML對數據封裝，會造成大量的數據要在網絡中傳輸。

(2).WebService規範沒有規定任何與實現相關的細節，包括對象模型、編程語言，這一點，它不如CORBA。

2、什麼是Web容器?

實現J2EE規範中web協議的應用.該協議定義了web程序的運行時環境,包括:併發性,安全性,生命週期管理等等.

就是在tomcat、weblogic下運行jsp、servlet、struts

3、應用服務器有那些？

BEA WebLogic Server，IBM WebSphere Application Server，Oracle9i Application Server，jBoss，Tomcat

5、如何給weblogic指定大小的內存?

在啓動Weblogic的腳本中（位於所在Domian對應服務器目錄下的startServerName），增加set MEM_ARGS=-Xms32m -Xmx200m，可以調整最小內存爲32M，最大200M

6、如何設定的weblogic的熱啓動模式(開發模式)與產品發佈模式?

可以在管理控制檯中修改對應服務器的啓動模式爲開發或產品模式之一。或者修改服務的啓動文件或者commenv文件，增加set PRODUCTION_MODE=true。

7、如何啓動時不需輸入用戶名與密碼?

修改服務啓動文件，增加 WLS_USER和WLS_PW項。也可以在boot.properties文件中增加加密過的用戶名和密碼.

8、在weblogic管理制臺中對一個應用域(或者說是一個網站,Domain)進行jms及ejb或連接池等相關信息進行配置後,實際保存在什麼文件中?

保存在此Domain的config.xml文件中，它是服務器的核心配置文件。

9、說說weblogic中一個Domain的缺省目錄結構?比如要將一個簡單的helloWorld.jsp放入何目錄下,然的在瀏覽器上就可打入 http://主機:端口號//helloword.jsp就可以看到運行結果了? 又比如這其中用到了一個自己寫的javaBean該如何辦?

Domain 目錄服務器目錄applications，將應用目錄放在此目錄下將可以作爲應用訪問，如果是Web應用，應用目錄需要滿足Web應用目錄要求，jsp文件可以直接放在應用目錄中，Javabean需要放在應用目錄的WEB-INF目錄的classes目錄中，設置服務器的缺省應用將可以實現在瀏覽器上無需輸入應用名。

12、CORBA是什麼?用途是什麼?

CORBA 標準是公共對象請求代理結構(Common Object Request Broker Architecture)，由對象管理組織 (Object Management Group，縮寫爲 OMG)標準化。它的組成是接口定義語言(IDL), 語言綁定(binding:也譯爲聯編)和允許應用程序間互操作的協議。其目的爲：用不同的程序設計語言書寫在不同的進程中運行，爲不同的操作系統開發。

13、說說在weblogic中開發消息Bean時的persistent與non-persisten的差別

persistent方式的MDB可以保證消息傳遞的可靠性,也就是如果EJB容器出現問題而JMS服務器依然會將消息在此MDB可用的時候發送過來，而non－persistent方式的消息將被丟棄。

14、WEB SERVICE名詞解釋。JSWDL開發包的介紹。JAXP、JAXM的解釋。SOAP、UDDI,WSDL解釋。

Web ServiceWeb Service是基於網絡的、分佈式的模塊化組件，它執行特定的任務，遵守具體的技術規範，這些規範使得Web Service能與其他兼容的組件進行互操作。

JAXP(Java API for XML Parsing) 定義了在Java中使用DOM,SAX, XSLT的通用的接口。這樣在你的程序中你只要使用這些通用的接口，當你需要改變具體的實現時候也不需要修改代碼。

JAXM(Java API for XML Messaging) 是爲SOAP通信提供訪問方法和傳輸機制的API。

WSDL是一種 XML 格式，用於將網絡服務描述爲一組端點，這些端點對包含面向文檔信息或面向過程信息的消息進行操作。這種格式首先對操作和消息進行抽象描述，然後將其綁定到具體的網絡協議和消息格式上以定義端點。相關的具體端點即組合成爲抽象端點（服務）。

SOAP即簡單對象訪問協議(Simple Object Access Protocol)，它是用於交換XML編碼信息的輕量級協議。

UDDI 的目的是爲電子商務建立標準；UDDI是一套基於Web的、分佈式的、爲WebService提供的、信息註冊中心的實現標準規範，同時也包含一組使企業能將自身提供的Web Service註冊，以使別的企業能夠發現的訪問協議的實現標準。

j2ee模式（MVC模式、Model1，Model2）

1、j2ee常用的設計模式？說明工廠模式。

Java中的23種設計模式：

Factory（工廠模式）， Builder（建造模式）， FactoryMethod（工廠方法模式），

Prototype（原始模型模式），Singleton（單例模式）， Facade（門面模式），

Adapter（適配器模式）， Bridge（橋樑模式）， Composite（合成模式），

Decorator（裝飾模式）， Flyweight（享元模式）， Proxy（代理模式），

Command（命令模式）， Interpreter（解釋器模式）， Visitor（訪問者模式），

Iterator（迭代子模式）， Mediator（調停者模式）， Memento（備忘錄模式），

Observer（觀察者模式）， State（狀態模式）， Strategy（策略模式），

Template Method（模板方法模式）， Chain Of Responsibleity（責任鏈模式）

工廠模式：工廠模式是一種經常被使用到的模式，根據工廠模式實現的類可以根據提供的數據生成一組類中某一個類的實例，通常這一組類有一個公共的抽象父類並且實現了相同的方法，但是這些方法針對不同的數據進行了不同的操作。首先需要定義一個基類，該類的子類通過不同的方法實現了基類中的方法。然後需要定義一個工廠類，工廠類可以根據條件生成不同的子類實例。當得到子類的實例後，開發人員可以調用基類中的方法而不必考慮到底返回的是哪一個子類的實例。

2、說說你所熟悉或聽說過的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類實現相同接口規範業務邏輯一致性

ejb架構的設計好壞將直接影響系統的性能、可擴展性、可維護性、組件可重用性及開發效率。項目越複雜，項目隊伍越龐大則越能體現良好設計的重要性。

3、解釋下面關於J2EE的名詞

(1)JNDI:Java Naming & Directory Interface,JAVA命名目錄服務.主要提供的功能是：提供一個目錄系統，讓其它各地的應用程序在其上面留下自己的索引，從而滿足快速查找和定位分佈式應用程序的功能.

(2)JMS：Java Message Service,JAVA消息服務.主要實現各個應用程序之間的通訊.包括點對點和廣播.

(3)JTA：Java Transaction API,JAVA事務服務.提供各種分佈式事務服務.應用程序只需調用其提供的接口即可.

(4)JAF: Java Action FrameWork,JAVA安全認證框架.提供一些安全控制方面的框架.讓開發者通過各種部署和自定義實現自己的個性安全控制策略.

(5)RMI:Remote Method Interface,遠程方法調用

4、介紹J2EE、J2SE、J2ME的區別。

J2ee：企業級，主要的application server的web及應用服務

J2se：標準版, 沒有application server

J2me：手機、pda的嵌入式開發

5、開發中都用到了那些設計模式?用在什麼場合?

每個模式都描述了一個在我們的環境中不斷出現的問題，然後描述了該問題的解決方案的核心。通過這種方式，你可以無數次地使用那些已有的解決方案，無需在重複相同的工作。主要用到了MVC的設計模式。用來開發JSP/Servlet或者J2EE的相關應用。簡單工廠模式等。

6、J2EE是什麼？

J2EE 是Sun公司提出的多層(multi-diered),分佈式(distributed),基於組件(component-base)的企業級應用模型(enterpriese application model).在這樣的一個應用系統中，可按照功能劃分爲不同的組件，這些組件又可在不同計算機上，並且處於相應的層次(tier)中。所屬層次包括客戶層(clietntier)組件,web層和組件,Business層和組件,企業信息系統(EIS)層。

7、J2EE是技術還是平臺還是框架？

J2EE本身是一個標準，一個爲企業分佈式應用的開發提供的標準平臺。

J2EE也是一個框架，包括JDBC、JNDI、RMI、JMS、EJB、JTA等技術。

其他

1、當前主流的解析器有那些?

DOM：文檔對象模型(document object model)

SAX

2、Dom解析處理的過程是什麼?

package ss;

importjavax.xml.parsers.DocumentBuilderFactory;

import javax.xml.parsers.DocumentBuilder;

import org.w3c.dom.Document;

import org.w3c.dom.Element;

import org.w3c.dom.Node;

import org.w3c.dom.Attr;

import org.w3c.dom.NodeList;

importjavax.xml.transform.TransformerFactory;

import javax.xml.transform.Transformer;

import javax.xml.transform.dom.DOMSource;

importjavax.xml.transform.stream.StreamResult;

public class XmlParser

{

public static void main(String[] args)

throws Exception

{

xmlwriter();

}

public static void xmlparser()

throws Exception

{

DocumentBuilderFactory xdf = DocumentBuilderFactory.newInstance();

DocumentBuilder db = xdf.newDocumentBuilder();

Document d = db.parse("C:\\A1\\customer.xml");

NodeList nl = d.getElementsByTagName("customer");

for (int i = 0; i < nl.getLength(); i++)

{

Element e = (Element) nl.item(i);

Attr a = e.getAttributeNode("customerID");

System.out.println(a.getNodeValue());

NodeList nl1 = e.getElementsByTagName("customerName");

System.out.println(nl1.item(0).getFirstChild().getNodeValue());

}

public static void xmlwriter() throws Exception

{

DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();

DocumentBuilder db=dbf.newDocumentBuilder();

Document d=db.parse("C:\\A1\\customer.xml");

NodeList nl=d.getElementsByTagName("customerName");

for(int i=0;i<nl.getLength();i++)

{

Element e=(Element) nl.item(i);

System.out.println(e.getFirstChild().getNodeValue()); e.getFirstChild().setNodeValue(e.getFirstChild().getNodeValue()+"111111111111111");

}

TransformerFactory tff=TransformerFactory.newInstance();

Transformer tf=tff.newTransformer();

tf.transform(new DOMSource(d),new StreamResult("c:\\aa.xml"));

}

DocumentBuilderFactory

DocumentBuilerdb

Documentd=db.parse(“具體文件路徑”);

NodeListnl=d.getElementsByTagName(“節點名”)

3、Sax解析處理的過程是什麼?

import org.xml.sax.helpers.DefaultHandler;

import org.xml.sax.SAXException;

import org.xml.sax.Attributes;

import javax.xml.parsers.SAXParser;

import javax.xml.parsers.SAXParserFactory;

public class SaxParser extendsDefaultHandler

{

public void characters(char[] ch, int start, int length)

throws SAXException

{

String temp=new String(ch,start,length);

System.out.println(temp);

}

public void endDocument()

throws SAXException

{

System.out.println("正在開始一個文檔");

}

public void endElement(String namespaceURI, String localName, StringqName)

throws SAXException

{

System.out.println("結束元素"+qName);

}

public void startDocument()

throws SAXException

{

System.out.println("開始文檔");

}

public void startElement(String namespaceURI, String localName,

String qName,Attributes atts)

throws SAXException

{

System.out.println("開始元素"+qName);

}

public static void main(String[] args) throws Exception

{

SAXParserFactory spf=SAXParserFactory.newInstance();

SAXParser sp=spf.newSAXParser();

sp.parse("C:\\A1\\customer.xml",new SaxParser());

}

4、Dom與Sax相比它們的優缺點是什麼?

DOM可以訪問任何一個節點，要將所有資源全部加載，比較耗內存,可以修改。

SAX只能順序讀，不可隨意訪問，不可寫，但速度快。

1. Dom中的核心接口有那些?

Node

TextNode

Element

Arr

NodeList

Document

5、如何將Dom對象寫入到文件中?

TransformerFactory

Transformer通過如下方法進行處理

Transformer(DOMSource(Documentd),ResultStream(OutputStream o))

6、用jdom解析xml文件時如何解決中文問題?

類文件是utf-8，xml文件頭也應是utf-8 如<?xml version="1.0"encoding="UTF-8" ?>

7、XML文檔定義有幾種形式？它們之間有何本質區別？解析XML文檔有哪幾種方式？

a: 兩種形式 dtd schema，

b: 本質區別:schema本身是xml的，可以被XML解析器解析(這也是從DTD上發展schema的根本目的)，

c:有DOM,SAX,STAX等

DOM:處理大型文件時其性能下降的非常厲害。這個問題是由DOM的樹結構所造成的，這種結構佔用的內存較多，而且DOM必須在解析文件之前把整個文檔裝入內存,適合對XML的隨機訪問

SAX:不現於DOM,SAX是事件驅動型的XML解析方式。它順序讀取XML文件，不需要一次全部裝載整個文件。當遇到像文件開頭，文檔結束，或者標籤開頭與標籤結束時，它會觸發一個事件，用戶通過在其回調事件中寫入處理代碼來處理XML文件，適合對XML的順序訪問

STAX:StreamingAPI for XML (StAX)

8、標準建模語言UML中的各種圖?

靜態圖

用例圖、類圖、對象圖、構件、部署,

動態圖(行爲圖)

活動圖,協作圖,狀態、時序

9、BS與CS的聯繫與區別。

C/S是Client/Server的縮寫。服務器通常採用高性能的PC、工作站或小型機，並採用大型數據庫系統，如Oracle、Sybase、Informix或 SQL Server。客戶端需要安裝專用的客戶端軟件。

B/Ｓ是Brower/Server的縮寫，客戶機上只要安裝一個瀏覽器（Browser），如Netscape Navigator或Internet Explorer，服務器安裝Oracle、Sybase、Informix或 SQL Server等數據庫。在這種結構下，用戶界面完全通過WWW瀏覽器實現，一部分事務邏輯在前端實現，但是主要事務邏輯在服務器端實現。瀏覽器通過Ｗeb Server 同數據庫進行數據交互。

C/S 與 B/S 區別：

１．硬件環境不同:

　　C/S 一般建立在專用的網絡上, 小範圍裏的網絡環境, 局域網之間再通過專門服務器提供連接和數據交換服務.

　　B/S 建立在廣域網之上的, 不必是專門的網絡硬件環境,例與電話上網, 租用設備. 信息自己管理. 有比C/S更強的適應範圍, 一般只要有操作系統和瀏覽器就行

２．對安全要求不同

　　C/S 一般面向相對固定的用戶羣, 對信息安全的控制能力很強. 一般高度機密的信息系統採用C/S 結構適宜. 可以通過B/S發佈部分可公開信息.

　　B/S 建立在廣域網之上, 對安全的控制能力相對弱, 可能面向不可知的用戶。

３．對程序架構不同

　　C/S 程序可以更加註重流程, 可以對權限多層次校驗, 對系統運行速度可以較少考慮.

　　B/S 對安全以及訪問速度的多重的考慮, 建立在需要更加優化的基礎之上.比C/S有更高的要求 B/S結構的程序架構是發展的趨勢, 從MS的.Net系列的BizTalk2000 Exchange 2000等, 全面支持網絡的構件搭建的系統.SUN 和IBM推的JavaBean 構件技術等,使 B/S更加成熟.

４．軟件重用不同

　　C/S 程序可以不可避免的整體性考慮,構件的重用性不如在B/S要求下的構件的重用性好.

　　B/S 對的多重結構,要求構件相對獨立的功能. 能夠相對較好的重用.就入買來的餐桌可以再利用,而不是做在牆上的石頭桌子

５．系統維護不同

　　C/S 程序由於整體性, 必須整體考察, 處理出現的問題以及系統升級. 升級難. 可能是再做一個全新的系統

　　B/S 構件組成,方面構件個別的更換,實現系統的無縫升級. 系統維護開銷減到最小.用戶從網上自己下載安裝就可以實現升級.

６．處理問題不同

　　C/S 程序可以處理用戶面固定, 並且在相同區域, 安全要求高需求, 與操作系統相關. 應該都是相同的系統

　　B/S 建立在廣域網上, 面向不同的用戶羣, 分散地域, 這是C/S無法作到的. 與操作系統平臺關係最小.

７．用戶接口不同

　　C/S 多是建立的Window平臺上,表現方法有限,對程序員普遍要求較高

　　B/S 建立在瀏覽器上, 有更加豐富和生動的表現方式與用戶交流. 並且大部分難度減低,減低開發成本.

８．信息流不同

　　C/S 程序一般是典型的中央集權的機械式處理, 交互性相對低

　　B/S 信息流向可變化, B-BB-C B-G等信息、流向的變化, 更像交易中心。

10、Uml的概念是什麼?主要的工具是什麼

Uml：統一建模語言工具:Rational Rose

11、Uml的概念中的九大圖形是什麼?最重的三個圖是什麼?各有什麼特點?

類圖

繼承

關聯:(1..n n..1 n..n)

依賴

實現接口

聚集

組成

類圖的生命週期(開發的所有階段都使用)

總體設計

詳細設計

開發：以類圖進行開發

測試

Use-case圖

關係

用例與用例

包含(include):必須調用

擴展(extends):可以調用也可以不調用

角色與角色的關係

泛化

用例與角色的關係:

用例與角色：通知

角色與用例：調用

元素

用例

角色

系統邊界

Use-case圖的生命週期

需求

整體設計

測試(單元測試、集成測試、系統測試、用戶驗收)

時序

元素

橫座標：對象

縱座標: 時間

作用

找類

找方法

驗證系統的正確

生命週期

詳細設計

活動(流程圖)

作用

分析業務

構件圖

作用:說明組件與組件之間的關係，依賴關係

部署

作用:說明安裝軟件的主機之間的關係，系統運行時的性能的主要影響者。

協作

對象與對象之間的調用協作。

狀態

一個對象狀態在不同的動作下的變化。

對象

說明對象

原文地址:http://blog.csdn.net/zhou9898/article/details/7079393

牧之-_-

發佈了25 篇原創文章 · 獲贊 4 · 訪問量 8萬+

私信關注

Java 面試

Java面向對象

1. super()與this()的區別？

2. 作用域public,protected,private,以及不寫時的區別？

3. 編程輸出如下圖形。

4. JAVA的事件委託機制和垃圾回收機制

5. 在JAVA中，如何跳出當前的多重嵌套循環？

6. 什麼是java序列化，如何實現java序列化？(寫一個實例)

7. 一個".java"源文件中是否可以包括多個類（不是內部類）？有什麼限制？

8. 排序都有哪幾種方法？請列舉。用JAVA實現一個快速排序？

9. Overload和Override的區別。Overloaded的方法是否可以改變返回值的類型?

10. Final類有什麼特點？

11. 繼承時候類的執行順序問題,一般都是選擇題,問你將會打印出什麼?

12. 內部類的實現方式?

13. 用JAVA實現一種排序，JAVA類實現序列化的方法(二種)？

14. 如在COLLECTION框架中，實現比較要實現什麼樣的接口？

15. 用插入法進行排序代碼如下

16. 編程：編寫一個截取字符串的函數，輸入爲一個字符串和字節數，輸出爲按字節截取的字符串。 但是要保證漢字不被截半個，如"我ABC"4，應該截爲"我AB"，輸入"我ABC漢DEF"，6，應該輸出爲"我ABC"而不是"我ABC+漢的半個"。

15、Java編程,打印昨天的當前時刻

16、文件讀寫,實現一個計數器

17、指出下面程序的運行結果。

18、抽象類和接口的區別？

19、什麼是類的返射機制?

20、類的返射機制中的包及核心類?

21、得到Class的三個過程是什麼?

22、如何喚起類中的一個方法？

23、如何將數值型字符轉換爲數字（Integer，Double）？

24、如何將數字轉換爲字符？

25、如何去小數點前兩位，並四捨五入。

26、如何取得年月日，小時分秒？

27、如何取得從1970年到現在的毫秒數

28、如何獲取某個日期是當月的最後一天？

29、如何格式化日期？

30、編碼轉換，怎樣實現將GB2312編碼的字符串轉換爲ISO-8859-1編碼的字符串。

32、String s = new String("xyz");創建了幾個StringObject?

33、float型floatf=3.4是否正確?

35、說出一些常用的類，包，接口，請各舉5個

36、java中會存在內存泄漏嗎，請簡單描述。

37、java中實現多態的機制是什麼？

38、垃圾回收器的基本原理是什麼？垃圾回收器可以馬上回收內存嗎？有什麼辦法主動通知虛擬機進行垃圾回收？

39、靜態變量和實例變量的區別？

41、是否可以從一個static方法內部發出對非static方法的調用？

42、寫clone()方法時，通常都有一行代碼，是什麼？

43、JAVA語言如何進行異常處理，關鍵字：throws,throw,try,catch,finally分別代表什麼意義？在try塊中可以拋出異常嗎？

45、冒泡排序法

46、String and StringBuffer的區別？

47、用java代碼編寫堆棧

48、集合的作用是什麼?

49、集合的通用方法有那些?通用方法是什麼?(操作)

50、說出ArrayList,Vector, LinkedList的存儲性能和特性HashMap和Hashtable的區別

51、Collection 和Collections的區別。

52、Set裏的元素是不能重複的，那麼用什麼方法來區分重複與否呢? 是用==還是equals()? 它們有何區別?用contains來區分是否有重複的對象。還是都不用。

53、List, Set, Map是否繼承自Collection接口?

54、面向對象的特徵有哪些方面

55、String是最基本的數據類型嗎?

56、int 和 Integer 有什麼區別？

57、運行時異常與一般異常有何異同？

58、&和&&的區別？

59、final, finally, finalize的區別？

62、heap和stack有什麼區別？

63、Static Nested Class 和Inner Class的不同？

64、什麼時候用assert？

65、GC是什麼? 爲什麼要有GC?

66、short s1 = 1; s1 = s1 + 1;有什麼錯? short s1 = 1; s1 += 1;有什麼錯?

67、Math.round(11.5)等於多少? Math.round(-11.5)等於多少?

68、Java有沒有goto?

69、給我一個你最常見到的runtime exception

70、接口是否可繼承接口? 抽象類是否可實現(implements)接口? 抽象類是否可繼承實體類(concrete class)?

71、abstract的method是否可同時是static,是否可同時是native，是否可同時是synchronized?

72、數組有沒有length()這個方法?String有沒有length()這個方法？

73、構造器Constructor是否可被override?

74、是否可以繼承String類?

75、swtich是否能作用在byte上，是否能作用在long上，是否能作用在String上?

76、try {}裏有一個return語句，那麼緊跟在這個try後的finally {}裏的code會不會被執行，什麼時候被執行，在return前還是後?

77、編程題: 用最有效率的方法算出2乘以8等於幾?

78、兩個對象值相同(x.equals(y) == true)，但卻可有不同的hash code，這句話對不對?

79、當一個對象被當作參數傳遞到一個方法後，此方法可改變這個對象的屬性，並可返回變化後的結果，那麼這裏到底是值傳遞還是引用傳遞?

80、四種會話跟蹤技術

81、編程題: 寫一個Singleton出來。

83、Java中的異常處理機制的簡單原理和應用。

16. 編程：編寫一個截取字符串的函數，輸入爲一個字符串和字節數，輸出爲按字節截取的字符串。但是要保證漢字不被截半個，如"我ABC"4，應該截爲"我AB"，輸入"我ABC漢DEF"，6，應該輸出爲"我ABC"而不是"我ABC+漢的半個"。