Java程序員面試分類真題5

Java程序員面試分類真題5(總分：100.00，做題時(shí)間：120分鐘)一、單項(xiàng)選擇題(總題數(shù)：25，分?jǐn)?shù)：50.00)1.

已知有如下定義：Strings="hello,world";，下面表達(dá)式中，不合法的是______。

（分?jǐn)?shù)：2.00）

A.s+="world"

B.charc=s[1]

√

C.intlen=s.length()

D.Stringt=s.toLowerCase()解析：對(duì)于選項(xiàng)A，Java允許string類進(jìn)行+操作，雖然String是不變類，但語句s+="world"會(huì)生成一個(gè)新的字符串對(duì)象，其內(nèi)容為“helloworldworld”，因此，選項(xiàng)A正確。

對(duì)于選項(xiàng)B，在Java語言中，String是一個(gè)類，s是一個(gè)字符串對(duì)象，而不是數(shù)組，因此，沒有提供類似于數(shù)組根據(jù)索引隨機(jī)訪問的功能，因此，選項(xiàng)B錯(cuò)誤。

對(duì)于選項(xiàng)C，String類提供了length()方法來計(jì)算字符串的長度，因此，選項(xiàng)C正確。

對(duì)于選項(xiàng)D，String類提供了toLowerCase()方法，該方法用來把字符串中所有字符轉(zhuǎn)換為小寫字母，因此，選項(xiàng)D正確。2.

有如下程序段：

intx=3;

inty=3;

Strings1="Hello";

Strings2="Hello";

則表達(dá)式x==y與s2==s1的結(jié)果分別為______。

（分?jǐn)?shù)：2.00）

A.true與true

√

B.false與true

C.true與false

D.false與false解析：3.

有如下代碼：

Stringstr1="abcd";

Stringstr2="ab"+new

String("cd");

System.err.println(str1==str2);

上面程序的運(yùn)行結(jié)果是______。

（分?jǐn)?shù)：2.00）

A.true

B.false

√

C.不確定

D.編譯錯(cuò)誤解析：4.

在Java語言中，打印語句System.out.println("3"+4)的輸出結(jié)果是______。

（分?jǐn)?shù)：2.00）

A.34

√

B.7

C.3

D.4解析：本題中，由于“3”是字符串，因此，在執(zhí)行"3"+4的過程中，首先把4轉(zhuǎn)換為字符串“4”，然后再執(zhí)行字符串拼接，結(jié)果為“34”，因此，程序的運(yùn)行結(jié)果為34。所以，選項(xiàng)A正確。

如果把題目改成System.out.println(3+4)，由于+操作兩邊的變量都是int類型，因此，此時(shí)會(huì)先執(zhí)行加操作，結(jié)果為7，然后把7輸出。5.

有如下代碼：

publicclassTest

{

publicstaticvoidmain(String[]args)

{

Strings;

System.out.println("s="+s);

}

}

上述代碼的輸出結(jié)果是______。

（分?jǐn)?shù)：2.00）

A.代碼得到編譯，并輸出“s=null”

B.代碼得到編譯，并輸出“s=”

C.由于Strings沒有初始化，代碼不能編譯通過

√

D.代碼得到編譯，但捕獲到NullPointException異常解析：在Java語言中，任何變量只有被初始化后才能被使用，如果沒有被初始化就直接使用，是無法編譯通過的。本題中，由于Strings沒有初始化，代碼不能編譯通過。所以，選項(xiàng)C正確。6.

有如下代碼：

publicclassTest

{

publicstaticvoidstringReplace(Stringtext)

{

text=text+"c";

}

publicstaticvoidbufferReplace(StringBuffertext)

{

text=text.append("c");

}

publicstaticvoidmain(Stringargs[])

{

StringtextString=newString("ab");

StringBuffertextBuffer=newStringBuffer("ab");

stringReplace(textString);

bufferReplace(textBuffer);

System.out.pIintln(textString+textBuffer);

}

}

當(dāng)編譯并運(yùn)行上面程序時(shí)，輸出結(jié)果是______。

（分?jǐn)?shù)：2.00）

A.編譯并運(yùn)行輸出ab

ab

B.編譯并運(yùn)行輸出abc

abc

C.編譯并運(yùn)行輸出ab

abc

√

D.編譯并運(yùn)行輸出abc

ab解析：String和StringBuffer都是類，在方法調(diào)用的時(shí)候，二者傳遞的都是引用值(可以理解為傳遞的是它們的地址)，對(duì)于String而言，由于String是不可變量，一旦賦值后，它的內(nèi)容就不能被修改了。

從本質(zhì)上來講，引用傳遞是通過值傳遞實(shí)現(xiàn)的(傳遞了引用的值，或者可以理解為傳遞的是對(duì)象地址的值)，對(duì)于本題而言，在調(diào)用stringReplace方法的時(shí)候，首先把實(shí)參textString的值復(fù)制給形參text(textString是字符串“ab”的引用，或者可以理解為是“ab”的地址)，當(dāng)在方法stringReplace內(nèi)執(zhí)行語句text=text+"c"的時(shí)候，相當(dāng)于創(chuàng)建了一個(gè)新的字符串對(duì)象“abc”，然后text指向這個(gè)字符串對(duì)象，這并沒有改變實(shí)參textString的值，因此，在調(diào)用結(jié)束后，textString指向的字符串的值還是“ab”。StringBuffer不是不可變量，在調(diào)用bufferReplace方法的時(shí)候，先把實(shí)參的值textBuffer賦值給形參text(字符串“ab”的引用，或可以理解為地址)，在調(diào)用text.append("c")的時(shí)候，會(huì)直接對(duì)text指向的字符串后面拼接一個(gè)字符串“c”，由于text與textBuffer指向同一個(gè)字符串，因此，這個(gè)對(duì)形參的修改也會(huì)影響到實(shí)參的值，調(diào)用結(jié)束后textBuffer的值為“abc”。所以，選項(xiàng)C正確。7.

有如下代碼：

publicclassTest

{

publicstaticvoidchangeStr(Stringstr)

{

str="world";

}

publicstaticvoidmain(String[]args)

{

Stringstr="hello";

changeStr(str);

System.out.println(str);

}

}

程序的輸出是______。

（分?jǐn)?shù)：2.00）

A.hello

√

B.world

C.helloworld

D.worldhello解析：本題中，方法調(diào)用的執(zhí)行過程如圖所示。

方法調(diào)用執(zhí)行過程

在調(diào)用方法changeStr時(shí)，會(huì)把實(shí)參的值(main方法中的str)賦值給形參(changeStr方法中的str)，這個(gè)賦值可以理解為把字符串“hello”的引用(或地址)賦值給了形參。在方法changeStr中執(zhí)行語句str="world"的結(jié)果是使得changeStr中的臨時(shí)變量str指向了另外一個(gè)新的字符串，但是這個(gè)賦值對(duì)實(shí)參的值是沒有影響的。當(dāng)方法調(diào)用結(jié)束后，changeStr方法中的str變量的作用域?qū)⒔Y(jié)束，因此，也就不存在了，此時(shí)，main方法中的str變量的值沒有改變，因此，輸出的結(jié)果為字符串“hello”。所以，選項(xiàng)A正確。8.

有以下代碼：

Strings="hello";

Stringt="hello";

charc[]={'h','e','1','o'};

下列選項(xiàng)中，返回值為false的語句是______。

（分?jǐn)?shù)：2.00）

A.s.equals(t);

B.t.equals(c);

√

C.t.equals(newString("hello"));

D.s==t;解析：在Java語言中，equals方法是類Object中的方法，因此，對(duì)于所有繼承于Object的類中都會(huì)有該方法。在Object類中，equals方法的作用是比較兩個(gè)對(duì)象的引用是否相等，即是否指向同一個(gè)對(duì)象。它等價(jià)于“==”操作，當(dāng)這兩個(gè)引用指向同一個(gè)對(duì)象的引用時(shí)，返回true，否則，返回false。而String類重寫了equals方法，String類的equals方法用來判斷兩個(gè)引用指向的字符串的內(nèi)容是否相等，如果相等，則返回true，否則，返回false。

對(duì)于選項(xiàng)A，字符串s和字符串t的內(nèi)容相同，都為“hello”，因此，返回值為true。所以，選項(xiàng)A錯(cuò)誤。

對(duì)于選項(xiàng)B，t是String的對(duì)象，而c是字符數(shù)組的引用。equals方法的參數(shù)為String類型，因此，會(huì)默認(rèn)調(diào)用c的toString方法，這個(gè)方法會(huì)返回c對(duì)象的信息，而不是“hello”，故返回值為false。所以，選項(xiàng)B正確。

對(duì)于選項(xiàng)C，t的內(nèi)容與新創(chuàng)建出來的字符串的內(nèi)容都是“hello”，因此，返回值為true。所以，選項(xiàng)C錯(cuò)誤。

對(duì)于選項(xiàng)D，對(duì)于String類的對(duì)象而言，判等符“==”通常用來表示兩個(gè)字符串對(duì)象的引用是否相等。在執(zhí)行語句Strings=”hello”時(shí)，會(huì)首先在常量區(qū)里存儲(chǔ)字符串“hello”，而s指向這個(gè)對(duì)象，在執(zhí)行語句Stringt="hello"時(shí)，由于在常量區(qū)里已經(jīng)存在這個(gè)字符串，因此，t也直接指向這個(gè)字符串，而不會(huì)創(chuàng)建新的字符串，所以，字符串s與字符串t的值相等。s==t的返回值為true，選項(xiàng)D錯(cuò)誤。9.

有如下代碼：

publicclassExample

{

StringStr=newString("good");

char[]ch={'a','b','c'};

publicstaticvoidmain(Stringargs[])

{

Exampleex=newExample();

Ex.change(ex.str,ex.ch);

System.out.print(ex.str+"and");

System.out.print(ex.ch);

}

publicvoidchange(Stringstr,charch[])

{

str="testok";

ch[0]='0';

}

}

程序的運(yùn)行結(jié)果為______。

（分?jǐn)?shù)：2.00）

A.goodandabc

B.goodandgbc

√

C.testokandabc

D.testokandgbc解析：10.

下面的表達(dá)式中，正確的是______。

（分?jǐn)?shù)：2.00）

A.Strings="你好";inti=3;s+=i;

√

B.Strings="你好";inti=3;if(i==s){s+=i};

C.Strings="你好";inti=3;s=i+s;

D.Strings="你好";inti=3;s=i+;

E.Strings="你好";inti=(s!=null)&&(s.length＞0)?s.length():0;解析：11.

以下關(guān)于異常的描述中，正確的是______。

（分?jǐn)?shù)：2.00）

A.如果一個(gè)方法聲明將拋出某個(gè)異常，它就必須真的拋出那個(gè)異常

B.一旦出現(xiàn)異常，程序運(yùn)行就終止了

C.在catch子句中匹配異常是一種精確匹配

D.可能拋出系統(tǒng)異常的方法是不需要聲明異常的

√解析：異常是指程序運(yùn)行時(shí)(非編譯時(shí))所發(fā)生的非正常情況或錯(cuò)誤，當(dāng)程序違反了語義規(guī)則時(shí)，JVM就會(huì)將出現(xiàn)的錯(cuò)誤表示為一個(gè)異常并拋出。這個(gè)異常可以在catch程序塊中進(jìn)行捕獲，然后進(jìn)行處理。而異常處理的目的則是為了提高程序的安全性與健壯性。

Java語言提供了兩種錯(cuò)誤的處理類，分別為Error(錯(cuò)誤)和Exception(異常)，且它們擁有共同的父類：Throwable。

Error表示程序在運(yùn)行期間出現(xiàn)了非常嚴(yán)重的錯(cuò)誤，并且該錯(cuò)誤是不可恢復(fù)的，由于這屬于JVM層次的嚴(yán)重錯(cuò)誤，所以，這種錯(cuò)誤是會(huì)導(dǎo)致程序終止執(zhí)行的。此外，編譯器不會(huì)檢查Error是否被處理，因此，在程序中不推薦去捕獲Error類型的異常，主要原因是運(yùn)行時(shí)異常多是由于邏輯錯(cuò)誤導(dǎo)致的，屬于應(yīng)該解決的錯(cuò)誤，也就是說，一個(gè)正確的程序中是不應(yīng)該存在Error的。OutOfMemoryErTor、ThreadDeath等都屬于錯(cuò)誤。當(dāng)這些異常發(fā)生時(shí)，JVM一般會(huì)選擇將線程終止。

Exception表示可恢復(fù)的異常，是編譯器可以捕捉到的。它包含兩種類型：運(yùn)行時(shí)異常(RuntimeException)和檢查異常(CheckedException)。

1)檢查異常是在程序中最經(jīng)常碰到的異常，所有繼承自Exception并且不是運(yùn)行時(shí)異常的異常都是檢查異常，比如最常見的IO異常和SQL異常。對(duì)于這種異常，都發(fā)生在編譯階段，Java編譯器強(qiáng)制程序去捕獲此類型的異常，即把可能會(huì)出現(xiàn)這些異常的代碼放到try塊中，把對(duì)異常的處理的代碼放到catch塊中。這種異常一般在如下幾種情況中使用：

①異常的發(fā)生并不會(huì)導(dǎo)致程序出錯(cuò)，進(jìn)行處理后可以繼續(xù)執(zhí)行后續(xù)的操作。例如，當(dāng)連接數(shù)據(jù)庫失敗后，可以重新連接后進(jìn)行后續(xù)操作。

②程序依賴于不可靠的外部條件，例如系統(tǒng)IO。

2)對(duì)于運(yùn)行時(shí)異常，編譯器沒有強(qiáng)制對(duì)其進(jìn)行捕獲并處理。如果不對(duì)這種異常進(jìn)行處理，當(dāng)出現(xiàn)這種異常時(shí)，會(huì)由JVM來處理。在Java語言中，最常見的運(yùn)行時(shí)異常有如下幾種：NullPointerException(空指針異常)、ArrayStoreException(數(shù)據(jù)存儲(chǔ)異常)、ClassCastException(類型轉(zhuǎn)換異常)、InexOutOfBoundException(數(shù)組越界異常)、BufferOverflowException(緩沖區(qū)溢出異常)和ArithmeticException(算術(shù)異常)等。

出現(xiàn)運(yùn)行時(shí)異常后，系統(tǒng)會(huì)把異常一直往上層拋出，直到遇到處理代碼為止。如果沒有處理塊，則拋到最上層，如果是多線程就由Thread.run()方法拋出，如果是單線程，就被main()方法拋出。拋出之后，如果是線程，這個(gè)線程也就退出了。如果是主程序拋出的異常，那么整個(gè)程序也就退出了。所以，如果不對(duì)運(yùn)行時(shí)異常進(jìn)行處理，后果是非常嚴(yán)重的，一旦發(fā)生，要么是線程中止，要么是主程序終止。

在使用異常處理時(shí)，還需要注意以下幾個(gè)問題：

1)Java異常處理用到了多態(tài)的概念，如果在異常處理過程中，首先捕獲了基類，然后再捕獲子類，那么捕獲子類的代碼塊將永遠(yuǎn)不會(huì)被執(zhí)行。因此，在進(jìn)行異常捕獲的時(shí)候，正確的寫法是：首先捕獲子類，然后再捕獲基類的異常信息。如下例所示：正確的寫法錯(cuò)誤的寫法try

{

//accessdbcode

}

catch(SQLExceptione1)

{

//dealwiththisexception

}

catch(Exceptioile2){}try

{

//accessdbcode

}

catch(Exceptione1)

{

//dealwitllthisexception

}

catch(SQLExceptione2){}

2)盡早拋出異常，同時(shí)對(duì)捕獲的異常進(jìn)行處理，或者從錯(cuò)誤中恢復(fù)，或者讓程序繼續(xù)執(zhí)行。對(duì)捕獲的異常不進(jìn)行任何處理是一個(gè)非常不好的習(xí)慣，這樣的代碼將非常不利于調(diào)試。當(dāng)然，也不是拋出異常越多越好，對(duì)于有些異常類型，例如運(yùn)行時(shí)異常，實(shí)際上根本不必處理。

3)可以根據(jù)實(shí)際的需求自定義異常類，這些自定義的異常類只要繼承自Exception類即可。

4)異常能處理就處理，不能處理就拋出。對(duì)于一般異常，如果不能進(jìn)行行之有效地處理，最好轉(zhuǎn)換為運(yùn)行時(shí)異常拋出。對(duì)于沒有處理的異常，最終JVM會(huì)進(jìn)行處理。

本題中，對(duì)于選項(xiàng)A，一個(gè)方法聲明了拋出一個(gè)異常只表明這個(gè)方法有可能會(huì)拋出這個(gè)異常，而不是一定會(huì)拋出這個(gè)異常。因此，選項(xiàng)A錯(cuò)誤。

對(duì)于選項(xiàng)B，如果出現(xiàn)的異常被捕獲到，并進(jìn)行相應(yīng)的處理后，程序可以繼續(xù)運(yùn)行，而不會(huì)終止。因此，選項(xiàng)B錯(cuò)誤。

對(duì)于選項(xiàng)C，異常匹配不是一種精確的匹配，使用了多態(tài)的概念。假如異常A是異常B的子類，如果有異常A拋出，在捕獲異常的代碼中，不僅可以匹配異常A，而且也可以匹配異常B。因此，選項(xiàng)C錯(cuò)誤。

對(duì)于選項(xiàng)D，對(duì)于可能拋出的運(yùn)行時(shí)異常，編譯器沒有強(qiáng)制對(duì)其進(jìn)行聲明，只有檢查異常(例如IOException)，編譯器才會(huì)強(qiáng)制要求在方法中聲明。因此，選項(xiàng)D正確。12.

f()方法定義如下所示，try中可以捕獲三種類型的異常，如果在該方法運(yùn)行中產(chǎn)生了一個(gè)IOException，那么，此時(shí)的輸出結(jié)果是______。

publicvoidf(){

try{

//methodthatmaycauseanException

}

catch(java.io.FileNotFoundExceptionex){

System.out.print("FileNotFoundException!");

}

catch(java.io.IOExceptionex){

System.out.print("IOException!");

}

catch(java.lang.Exceptionex){

System.out.print("Exception!");

}

}

（分?jǐn)?shù)：2.00）

A.IOException!

√

B.FileNotFoundException!IOException!

C.IOException!Exception!

D.FileNotFoundException!IOException!Exception!解析：在Java語言中，通常是通過try/catch來處理異常的，當(dāng)try塊中的代碼出現(xiàn)異常后，將會(huì)匹配catch塊中的異常，一旦匹配成功，就會(huì)執(zhí)行catch塊的代碼進(jìn)行異常處理。

通常，可以有多個(gè)catch語句，也就是說，可以用來匹配多個(gè)異常，但是當(dāng)每次執(zhí)行的時(shí)候，最多只會(huì)匹配一個(gè)異常，每當(dāng)匹配到其中一個(gè)異常后，僅會(huì)執(zhí)行catch塊中匹配上的那個(gè)異常，而其他的catch塊將不會(huì)被執(zhí)行。對(duì)于本題而言，如果拋出IOException異常后，F(xiàn)ileNotFoundException不是IOException的父類，接著異常IOException匹配成功，進(jìn)入異常處理塊輸出IOException，然后程序運(yùn)行結(jié)束。所以，選項(xiàng)A正確。13.

下列異常中既是檢查型異常，又需要在編寫程序時(shí)聲明的是______。

（分?jǐn)?shù)：2.00）

A.NullPointerException

B.ClassCastException

C.IOException

√

D.IndexOutOfBoundsException解析：14.

有如下代碼：

publicclassTest

{

publicstaticvoidmain(String[]args)

{

inta[]={0,1,2,3,4};

intsum=0;

try

{

for(inti=0;i＜6;i++)

{

sum+=a[i];

}

System.out.println("sum="+sum);

}

catch(java.lang.ArrayIndexOutOfBoundsExceptione)

{

System.out.println("數(shù)組下標(biāo)越界");

}

finally

{

System.out.println("程序結(jié)束")

}

}

}

以上程序的運(yùn)行結(jié)果為______。

（分?jǐn)?shù)：2.00）

A.10程序結(jié)束

B.10數(shù)組下標(biāo)越界程序結(jié)束

C.數(shù)組下標(biāo)越界程序結(jié)束

√

D.程序結(jié)束解析：本題中，首先定義了長度為5的數(shù)組(數(shù)組下標(biāo)范圍為0～4)，在接下來訪問數(shù)組的時(shí)候，當(dāng)遍歷到下標(biāo)為5的數(shù)組元素時(shí)，會(huì)拋出ArraylndexOutOfBoundsException異常，從而執(zhí)行catch塊的代碼輸出：數(shù)組下標(biāo)越界，接著會(huì)運(yùn)行finally塊的代碼輸出：程序結(jié)束。所以，選項(xiàng)C正確。15.

下面屬于面向字符的輸入流的是______。

（分?jǐn)?shù)：2.00）

A.BufferedWriter

B.ObjectInputStream

C.FileInputStream

D.InputStreamReader

√解析：在Java語言中，輸入和輸出都被稱為抽象的流，流可以看作是一組有序的字節(jié)集合，即數(shù)據(jù)在兩個(gè)設(shè)備之間的傳輸。

流的本質(zhì)是數(shù)據(jù)傳輸，根據(jù)處理數(shù)據(jù)類型的不同，流可以分為兩大類：字節(jié)流和字符流。其中，字節(jié)流以字節(jié)(8bit)為單位，包含兩個(gè)抽象類：InputStream(輸入流)和OutputStream(輸出流)。字符流以字符(16bit)為單位，根據(jù)碼表映射字符，一次可以讀多個(gè)字節(jié)，它包含兩個(gè)抽象類：Reader(輸入流)和Writer(輸出流)。其中，字節(jié)流和字符流最主要的區(qū)別為：字節(jié)流在處理輸入輸出的時(shí)候不會(huì)用到緩存，而字符流用到了緩存。

對(duì)于選項(xiàng)A，Writer代表輸出流。所以，選項(xiàng)A錯(cuò)誤。

對(duì)于選項(xiàng)B和選項(xiàng)C，Stream代表的是字節(jié)流。所以，選項(xiàng)B和選項(xiàng)C錯(cuò)誤。

對(duì)于選項(xiàng)D，InputStreamReader表示的是輸入流。所以，選項(xiàng)D正確。16.

新建一個(gè)流對(duì)象，下面代碼中，描述錯(cuò)誤的是______。

（分?jǐn)?shù)：2.00）

A.newBufferedWriter(newFileWriter("d.txt"));

B.newBufferedReader(newFilelnputStream("d.dat"));

√

C.newObjectInputStream(newFilelnputStream("d.dat"));

D.newGZlPOutputStream(newFileOutputStream("d.zip"));解析：本題中，選項(xiàng)A、選項(xiàng)C、選項(xiàng)D的方法寫法都是正確的，只有選項(xiàng)B的方法寫法不正確。BufferedReader是Reader的一個(gè)子類，具有緩沖的作用，避免了頻繁地從物理設(shè)備中讀取信息。它有以下兩個(gè)構(gòu)造函數(shù)：

1)BufferedReader(Readerin)

2)BufferedReader(Readerin,intsz)//sz是指定緩沖區(qū)的大小

由此可見，BufferedReader類只能用來包裝Reader類或其子類。因此，選項(xiàng)B錯(cuò)誤。17.

要從文件"file.dat"中讀出第10個(gè)字節(jié)到變量c中，下列方法正確的是______。

（分?jǐn)?shù)：2.00）

A.FileInputStreamin=newFilelnputStream("file.dat");in.skip(9);intc=in.read();

√

B.FilelnputStreamin=newFilelnputStream("file.dat");intc=in.read();

C.FileInputStreamin=newFileInputStream("file.dat");in.skip(10);intc=in.read();

D.RandomAccessFilein=newRandomAccessFile("file.dat");in.skip(9);intc=in.readByte();解析：FileInputStream類的skip(longn)方法的功能為從輸入流中跳過并丟棄n個(gè)字節(jié)的數(shù)據(jù)。

對(duì)于選項(xiàng)A，先執(zhí)行in.skip(9)語句，跳過了9個(gè)字節(jié)，接下來讀取到的一定是第10個(gè)字節(jié)。因此，選項(xiàng)A正確。同理，選項(xiàng)B讀取到的是第一個(gè)字節(jié)，選項(xiàng)C讀取到的是第11個(gè)字節(jié)。因此，選項(xiàng)B與選項(xiàng)C錯(cuò)誤。

對(duì)于選項(xiàng)D，RandomAccessFile類并沒有提供只有一個(gè)參數(shù)的構(gòu)造方法，它的構(gòu)造方法的定義為：

RandomAccessFile(Filefile,Stringmode)

RandomAccessFile(Stringname，Stringmode)

因此，選項(xiàng)D錯(cuò)誤。18.

給定一個(gè)Java程序的main方法的代碼片段如下：

try

{

PrintWfiterout=newPrintWriter(newFileOutputStream("d:/a.txt"));

Stringname="chen";

out.print(name);

}

catch(Exceptione)

{

System.out.println("文件沒有發(fā)現(xiàn)!");

}

假如d目錄下不存在a.txt文件，現(xiàn)運(yùn)行該程序，下面的結(jié)果正確的是______。

（分?jǐn)?shù)：2.00）

A.將在控制臺(tái)上打?。骸拔募]有發(fā)現(xiàn)!”

√

B.運(yùn)行后生成abc.txt，該文件內(nèi)容為chen

C.運(yùn)行后生成abc.txt，但該文件中可能無內(nèi)容

D.正常運(yùn)行，但沒有生成文件abc.txt解析：由于文件不存在，因此，在調(diào)用newFileOutputStream("d:/abc.txt")時(shí)，會(huì)拋出FileNotFoundException異常，這個(gè)異常是Exception的子類，能匹配Exception從而執(zhí)行catch塊的代碼輸出“文件沒有發(fā)現(xiàn)!”。所以，選項(xiàng)A正確。19.

在Java語言中，______類提供定位本地文件系統(tǒng)，對(duì)文件或目錄及其屬性進(jìn)行基本操作。

（分?jǐn)?shù)：2.00）

A.FileInputStream

B.FileReader

C.FileWriter

D.File

√解析：FileInputStream用來以二進(jìn)制流的方式讀取文件，F(xiàn)ileReader用來以字符的方式讀取文件，F(xiàn)ileWriter用來以字符的方式寫文件，而File可以用來獲取文件的屬性。顯然，提供定位本地文件系統(tǒng)，并對(duì)文件或目錄及其屬性進(jìn)行基本操作的類為File。所以，選項(xiàng)D正確。20.

以下代碼是SuperClass和Sub兩個(gè)類的定義。在序列化一個(gè)Sub的對(duì)象sub到文件時(shí)，下面會(huì)被保存到文件中的字段是______。

classSuperClass

{

publicStringname;

}

classSubextendsSuperClassimplementsSerializable

{

privatefloatradius;

transientintcolor;

publicstaticStringtype="Sub";

}

（分?jǐn)?shù)：2.00）

A.name

B.radius

√

C.color

D.type解析：在分布式環(huán)境下，當(dāng)進(jìn)行遠(yuǎn)程通信時(shí)，無論是何種類型的數(shù)據(jù)，都會(huì)以二進(jìn)制序列的形式在網(wǎng)絡(luò)上傳送。序列化是一種將對(duì)象轉(zhuǎn)換成字節(jié)序列的過程，用于解決在對(duì)對(duì)象流進(jìn)行讀寫操作時(shí)所引發(fā)的問題。序列化可以將對(duì)象的狀態(tài)寫在流里進(jìn)行網(wǎng)絡(luò)傳輸，或者保存到文件、數(shù)據(jù)庫等系統(tǒng)里，并在需要的時(shí)候把該流讀取出來重新構(gòu)造成一個(gè)相同的對(duì)象。

如何實(shí)現(xiàn)序列化呢?其實(shí)，所有要實(shí)現(xiàn)序列化的類都必須實(shí)現(xiàn)Serializable接口，Serializable接口位于java.lang包中，它里面沒有包含任何方法。使用一個(gè)輸出流(例如FileOutputStream)來構(gòu)造一個(gè)ObjectOutputStream(對(duì)象流)對(duì)象，緊接著，使用該對(duì)象的writeObject(Objectobj)方法就可以將obj對(duì)象寫出(即保存其狀態(tài))，要恢復(fù)的時(shí)候可以使用其對(duì)應(yīng)的輸入流。

具體而言，序列化有如下幾個(gè)特點(diǎn)：

1)如果一個(gè)類能被序列化，那么它的子類也能夠被序列化。

2)由于static(靜態(tài))代表類的成員，transient(Java語言關(guān)鍵字，如果用transient聲明一個(gè)實(shí)例變量，當(dāng)對(duì)象存儲(chǔ)時(shí)，它的值不需要維持)代表對(duì)象的臨時(shí)數(shù)據(jù)，因此，被聲明為這兩種類型的數(shù)據(jù)成員是不能夠被序列化的。

3)子類實(shí)現(xiàn)了Serializable接口，父類沒有，父類中的屬性不能序列化，但是子類中的屬性仍能正確序列化。

通過以上分析可知，只有選項(xiàng)B是正確的。21.

有Shape和Circle兩個(gè)類的定義，在序列化一個(gè)Circle的對(duì)象circle到文件時(shí)，下面會(huì)被保存到文件中的字段是______。

classShape

{

publicStringname;

}

classCircleextendsShapeimplementsSerializable

{

privatefloatradius;

transientintcolor;

publicstaticStringtype="Circle";

}

（分?jǐn)?shù)：2.00）

A.name

B.radius

√

C.color

D.type

E.都不會(huì)解析：22.

將對(duì)象序列化，要實(shí)現(xiàn)的接口是______。

（分?jǐn)?shù)：2.00）

A.Rurmable

B.Cloneable

C.Serializable

√

D.Comparator解析：23.

有以下一個(gè)對(duì)象：

importjava.io.Serializable;

publicclassDataObjectimplementsSerializable

{

privatestaticinti=0;

privateStringword="";

publicvoidsetWord(Stringword)

{

this.word=word;

}

publicvoidsetI(inti)

{

DataObject.i=i;

}

}

創(chuàng)建一個(gè)如下方式的DataObject:

DataObjectobject=newDataObject();

object.setWord("123");

object.setI(2);

將此對(duì)象序列化，并在另一個(gè)JVM中讀取文件，進(jìn)行反序列化，此時(shí)讀出的DataObject對(duì)象中的word和i的值分別是______。

（分?jǐn)?shù)：2.00）

A.“”，2

B.“”，0

C.“123”，2

D.“123”，0

√解析：Java序列化指的是把Java對(duì)象轉(zhuǎn)換為字節(jié)序列的過程，而Java反序列化指的是把字節(jié)序列恢復(fù)為Java對(duì)象的過程。由于Java語言在序列化的時(shí)候不會(huì)序列化static變量，因此，上述代碼只實(shí)例化了變量word，而沒有實(shí)例化變量i。在反序列化的時(shí)候，只能讀取到變量word的值，而變量i的值仍然為默認(rèn)值，該默認(rèn)值為0。所以，word的值為“123”，i的值為0，選項(xiàng)D正確。24.

下列有關(guān)Java語言的描述中，正確的是______。

（分?jǐn)?shù)：2.00）

A.由于Java程序是解釋執(zhí)行的，所以，執(zhí)行前不需要進(jìn)行編譯

B.一個(gè).java源程序編譯后將產(chǎn)生一個(gè).class的字節(jié)碼文件

C.安裝了JDK后，安裝程序會(huì)自動(dòng)配置系統(tǒng)的環(huán)境變量path和classpath

D.Java語言是面向?qū)ο蟮慕忉屝透呒?jí)編程語言

√解析：本題中，對(duì)于選項(xiàng)A，雖然Java語言是解釋執(zhí)行，但是執(zhí)行前需要把代碼編譯成一個(gè)中間代碼，然后解釋器對(duì)中間代碼解釋執(zhí)行。所以，選項(xiàng)A錯(cuò)誤。

對(duì)于選項(xiàng)B，在Java語言中，一個(gè)類編譯后產(chǎn)生一個(gè).class字節(jié)碼文件，如果一個(gè).java源程序中有多個(gè)類，那么編譯后就會(huì)產(chǎn)生多個(gè).class字節(jié)碼文件。所以，選項(xiàng)B錯(cuò)誤。

對(duì)于選項(xiàng)C，JDK安裝后，需要手動(dòng)配置環(huán)境變量path和classpath。所以，選項(xiàng)C錯(cuò)誤。

對(duì)于選項(xiàng)D，Java語言是面向?qū)ο蟮慕忉屝透呒?jí)編程語言。所以，選項(xiàng)D正確。25.

一個(gè)Java程序運(yùn)行從上到下的環(huán)境次序是______。

（分?jǐn)?shù)：2.00）

A.JRE/JVM、操作系統(tǒng)、Java程序、硬件

B.Java程序、JRE/JVM、硬件、操作系統(tǒng)

C.Java程序、JRE/JVM、操作系統(tǒng)、硬件

√

D.Java程序、操作系統(tǒng)、JRE/JVM、硬件解析：Java程序被編譯后并不是生成能在硬件平臺(tái)上可執(zhí)行的代碼，而是生成了一個(gè)中間代碼。不同的硬件平臺(tái)上會(huì)安裝有不同的JVM(JavaVirtualMachine，Java虛擬機(jī))，由JVM來負(fù)責(zé)把中間代碼翻譯成硬件平臺(tái)能執(zhí)行的代碼。由此可以看出，JVM不具有平臺(tái)獨(dú)立性，與硬件平臺(tái)是相關(guān)的。

從以上分析可知，Java程序的下一層環(huán)境為JVM，而JVM是運(yùn)行在操作系統(tǒng)上的，操作系統(tǒng)又運(yùn)行在硬件上。因此，一個(gè)Java程序運(yùn)行從上到下的環(huán)境次序是Java程序、JRE/JVM、操作系統(tǒng)和硬件。所以，選項(xiàng)C正確。二、多項(xiàng)選擇題(總題數(shù)：8，分?jǐn)?shù)：16.00)1.

有如下代碼：

Stringa="Hello";

Stringb="Hello";

Stringc=newString("Hello");

Stringd=newSning("Hello");

以上表達(dá)式中，返回值為真的有______。

（分?jǐn)?shù)：2.00）

A.a==b

√

B.a==c

C.c==d

D.a.equals(b)

√

E.a.equals(c)

√

F.c.equals(d)

√解析：1)判等運(yùn)算符“==”用來比較兩個(gè)變量的值是否相等，也就是用于比較變量所對(duì)應(yīng)內(nèi)存中存儲(chǔ)的數(shù)值是否相同，要比較兩個(gè)基本類型的數(shù)據(jù)或兩個(gè)引用變量是否相等，只能使用判等運(yùn)算符“==”。

具體而言，如果兩個(gè)變量都是基本數(shù)據(jù)類型，可以直接使用判等運(yùn)算符“==”來比較其對(duì)應(yīng)的值是否相等。如果一個(gè)變量指向的數(shù)據(jù)是對(duì)象(引用類型)，那么，此時(shí)涉及兩塊內(nèi)存，對(duì)象本身占用一塊內(nèi)存(堆內(nèi)存)，變量(對(duì)象的引用)也占用一塊內(nèi)存。例如，對(duì)于賦值語句Strings=newString("Hello")，變量s占用一塊存儲(chǔ)空間，而“Hello”則存儲(chǔ)在另外一塊存儲(chǔ)空間里，此時(shí)，變量s所對(duì)應(yīng)的內(nèi)存中存儲(chǔ)的數(shù)值就是對(duì)象“Hello”占用的那塊內(nèi)存的首地址。對(duì)于指向?qū)ο箢愋偷淖兞?，如果要比較兩個(gè)變量是否指向同一個(gè)對(duì)象，即要看這兩個(gè)變量所對(duì)應(yīng)的內(nèi)存中的數(shù)值是否相等(這兩個(gè)對(duì)象是否指向同一塊存儲(chǔ)空間)，這時(shí)候就可以用“==”運(yùn)算符進(jìn)行比較。但是，如果要比較這兩個(gè)對(duì)象的內(nèi)容是否相等，那么使用“==”運(yùn)算符就無法實(shí)現(xiàn)了。

2)equals是Object類提供的方法之一，每一個(gè)Java類都繼承自O(shè)biect類，所以，每一個(gè)對(duì)象都具有equals這個(gè)方法。Object類中定義的equals(Object)方法是直接使用“==”運(yùn)算符比較兩個(gè)對(duì)象，所以，在沒有覆蓋equals(Object)方法的情況下，equals(Obiect)與“==”運(yùn)算符一樣，比較的是引用。

與“==”運(yùn)算符相比，equals(Obiect)方法的特殊之處就在于它可以被覆蓋，所以，可以通過覆蓋的方法讓它不是比較引用而是比較數(shù)據(jù)內(nèi)容。例如String類的equals方法是用于比較兩個(gè)獨(dú)立對(duì)象的內(nèi)容是否相同。例如，對(duì)于下面的代碼：

Strings1=newString("Hello");

Strings2=newString("Hello");

兩條new語句創(chuàng)建了兩個(gè)對(duì)象，然后用s1、s2這兩個(gè)變量分別指向一個(gè)對(duì)象，這是兩個(gè)不同的對(duì)象，它們的首地址是不同的。即字符串a(chǎn)和字符串b中存儲(chǔ)的數(shù)值是不相同的，所以，表達(dá)式a=b將返回false，而這兩個(gè)對(duì)象中的內(nèi)容是相同的，所以，表達(dá)式a.equals(b)將返回缸true。

根據(jù)以上分析可知，選項(xiàng)D、選項(xiàng)E、選項(xiàng)F是正確的，因?yàn)檫@些字符串都有著相同的內(nèi)容。

在Java語言中，字符串起著非常重要的作用，字符串的聲明與初始化主要有如下兩種情況：

1)對(duì)于Strings1=newString("abc")語句與Strings2=newString("abc")語句，存在兩個(gè)引用對(duì)象s1、s2，兩個(gè)內(nèi)容相同的字符串對(duì)象“abc”，它們?cè)趦?nèi)存中的地址是不同的。只要使用到new，總會(huì)生成新的對(duì)象。

2)對(duì)于Strings1="abc"語句與Strings2="abc"語句，在JVM中存在著一個(gè)字符串池，其中保存著很多String對(duì)象，并且這些對(duì)象可以被共享使用，s1、s2引用的是同一個(gè)常量池中的對(duì)象。由于String的實(shí)現(xiàn)采用了Flyweight(享元)的設(shè)計(jì)模式，當(dāng)創(chuàng)建一個(gè)字符串常量的時(shí)候，例如Strings="abc"，會(huì)首先在字符串常量池中查找是否已經(jīng)有相同的字符串被定義，它的判斷依據(jù)是String類equals(Objectobj)方法的返回值。如果已經(jīng)定義，則直接獲取對(duì)其的引用，此時(shí)不需要?jiǎng)?chuàng)建新的對(duì)象，如果沒有定義，則首先創(chuàng)建這個(gè)對(duì)象，然后把它加入到字符串池中，再將它的引用返回。由于Strhag是不可變類，一旦創(chuàng)建好就不能被修改，因此，String對(duì)象可以被共享而且不會(huì)導(dǎo)致程序的混亂。

從以上分析可知，對(duì)于本題而言，字符串a(chǎn)和b都指向常量池的字符串，因此，有著相同的地址，因此，表達(dá)式a=b的返回值為tRUe，字符串c和d分別指向兩個(gè)在堆空間上申請(qǐng)的字符串，顯然，字符串c、d和a有著不同的地址，因此，表達(dá)式a=c和c=d的返回值都為false。

所以，本題的答案為ADEF。2.

下列關(guān)于String和數(shù)組的描述中，正確的是______。

（分?jǐn)?shù)：2.00）

A.String有l(wèi)ength屬性

B.String有l(wèi)ength()方法

√

C.數(shù)組有l(wèi)ength屬性

√

D.數(shù)組有l(wèi)ength()方法解析：String類的lengm()方法可以用來求解字符串的長度，數(shù)組的length屬性用來求解數(shù)組的大小，如下例所示：

publicclassTest

{

publicstaticvoidmain(Stringargv[])

{

inta[]={1};

System.out.println(a.length);

Strings="Hello";

System.out.println(s.length());

}

}

程序的運(yùn)行結(jié)果為：

1

5

因此，選項(xiàng)B與選項(xiàng)C正確。3.

以下能使用throw拋出異常的有______。

（分?jǐn)?shù)：2.00）

A.Throwable

√

B.Event

C.Object

D.Error

√

E.Exception

√

F.RuntimeException

√解析：異常是指程序運(yùn)行時(shí)(非編譯時(shí))所發(fā)生的非正常情況或錯(cuò)誤，當(dāng)程序違反了語義規(guī)則時(shí)，JVM就會(huì)將出現(xiàn)的錯(cuò)誤表示為一個(gè)異常并拋出。這個(gè)異常可以在catch程序塊中進(jìn)行捕獲，然后進(jìn)行處理。而異常處理的目的則是為了提高程序的安全性與健壯性。

Java語言把異常當(dāng)作對(duì)象來處理，并定義了一個(gè)基類(java.lang.Throwable)作為所有異常的超類。在JavaAPI中，已經(jīng)定義了許多異常類，這些異常類分為兩大類，Error(錯(cuò)誤)和Exception(異常)。

違反語義規(guī)則包括以下兩種情況：一種是Java類庫內(nèi)置的語義檢查，例如，當(dāng)數(shù)組下標(biāo)越界時(shí)，會(huì)引發(fā)IndexOutOfBoundsException；當(dāng)訪問null的對(duì)象時(shí)，會(huì)引發(fā)NullPointerException；另一種情況是Java語言允許開發(fā)人員擴(kuò)展這種語義檢查，開發(fā)人員可以創(chuàng)建自己的異常類(所有的異常都是Java.lang.Thowable的子類)，并自由選擇在何時(shí)用throw關(guān)鍵字拋出異常。

對(duì)于本題而言，其中Throwable為異常處理的基類，Error、Exception和RuntimeException都是Throwable的子類，因此，都能使用throw拋出。所以，選項(xiàng)A、選項(xiàng)D、選項(xiàng)E與選項(xiàng)F正確。4.

有如下代碼＜%intt=Integer.parseInt(request.getParemeter("value"))%＞，下面描述正確的有______。

（分?jǐn)?shù)：2.00）

A.不會(huì)有錯(cuò)

B.當(dāng)value與int類型不匹配時(shí)會(huì)報(bào)錯(cuò)

√

C.當(dāng)value=""時(shí)會(huì)報(bào)錯(cuò)

√

D.為了安全起見應(yīng)該將該段代碼放在仃y{}和catch(){}之間

√解析：使用parseInt()方法用于解析參數(shù)中的字符串，并返回對(duì)應(yīng)的整數(shù)，parseXxx()是一個(gè)靜態(tài)方法，可以有一個(gè)或兩個(gè)參數(shù)。lngeger類的parseInt方法會(huì)拋出NumberFormatException異常(當(dāng)傳入的參數(shù)不能夠被轉(zhuǎn)成int時(shí))，因此，一般情況下都會(huì)把對(duì)這個(gè)方法的調(diào)用放到trycatch之間。所以，選項(xiàng)B、選項(xiàng)C與選項(xiàng)D正確。5.

下面對(duì)于異常處理的描述中，正確的是______。

（分?jǐn)?shù)：2.00）

A.捕獲異常是通過try、catch等關(guān)鍵字來實(shí)現(xiàn)，這是一種積極的異常處理方式

√

B.try必須跟catch連用，而finally是可有可無的

C.catch之后的()用于接收異常對(duì)象，因此需要指定異常類型和變量名稱，比如catch(Exceptione)

√

D.對(duì)于finally代碼塊而言，僅當(dāng)執(zhí)行try語句并沒有觸發(fā)異常時(shí)才執(zhí)行，如果發(fā)生異常則進(jìn)入catch代碼塊，不再執(zhí)行finally代碼塊

E.在JDK1.7中，允許在catch中捕獲多個(gè)類型異常，如catch(NullPointerExceptione1|ClassCastExceptione2)解析：在Java語言中，使用try/catch/finally對(duì)異常進(jìn)行處理，Java編譯器只允許如下三種組合方式：

1)try/catch

2)try/finally

3)try/catch/finally

其中，try塊只能有一個(gè)，finally塊是可選的，最多只能有一個(gè)finally塊，catch塊可以有多個(gè)，它們執(zhí)行的順序?yàn)閠ry-＞catch-＞finally，當(dāng)然，如果沒有異常發(fā)生，那么catch塊是不會(huì)執(zhí)行的；當(dāng)有多個(gè)catch塊的時(shí)候，如果try塊中出現(xiàn)異常，異常是按照catch塊的先后順序進(jìn)行匹配的，一旦異常類型被一個(gè)catch塊匹配，則不會(huì)與后面的catch塊進(jìn)行匹配：最后，finally塊在任何情況下都會(huì)執(zhí)行的，無論有沒有發(fā)生異常，它總會(huì)在這個(gè)異常處理結(jié)構(gòu)的最后運(yùn)行。即使在try塊內(nèi)用return返回了，在返回前，finally總是要執(zhí)行，以便能夠在異常處理最后做一些清理工作，例如關(guān)閉數(shù)據(jù)庫連接等。

本題中，對(duì)于選項(xiàng)A，通過try/catch可以捕獲運(yùn)行期間出現(xiàn)的錯(cuò)誤，進(jìn)行處理后可以使程序繼續(xù)運(yùn)行，因此，是一種積極的異常處理方式。所以，選項(xiàng)A正確。

對(duì)于選項(xiàng)B，try后面可以不跟catch，而直接跟finally。所以，選項(xiàng)B錯(cuò)誤。

對(duì)于選項(xiàng)C，由于catch存在的作用是為了匹配異常類型，所以，catch必須指定異常類型和變量名稱。所以，選項(xiàng)C正確。

對(duì)于選項(xiàng)D，finally塊在任何情況下都會(huì)執(zhí)行。所以，選項(xiàng)D錯(cuò)誤。

對(duì)于選項(xiàng)E，當(dāng)需要捕獲多種不同類型的異常的時(shí)候，傳統(tǒng)的寫法為：

catch(IOExceptione1){

}

catch(Exceptione2){

}

為了降低代碼的重復(fù)度，JDK1.7引入了新的寫法：如果用一個(gè)catch塊處理多個(gè)異常，可以用管道符(|)將它們分開，即catch(IOException|Exceptione){}，由此可以看出，“|”前面的異常是不能單獨(dú)制定變量名的。所以，選項(xiàng)E錯(cuò)誤。

所以，本題的答案為AC。6.

以下關(guān)于異常處理機(jī)制的描述中，正確的有______。

（分?jǐn)?shù)：2.00）

A.catch部分捕捉到異常情況時(shí)，才會(huì)執(zhí)行finally部分

B.不論程序是否發(fā)生錯(cuò)誤及捕捉到異常情況，都會(huì)執(zhí)行finally部分

√

C.當(dāng)try區(qū)段的程序發(fā)生異常時(shí)，才會(huì)執(zhí)行catch區(qū)段的程序

√

D.以上都是解析：對(duì)于選項(xiàng)A與選項(xiàng)B，不管有無異常，finally塊都會(huì)執(zhí)行。所以，選項(xiàng)A錯(cuò)誤，選項(xiàng)B正確。

對(duì)于選項(xiàng)C，catch代碼塊的作用是在異常出現(xiàn)時(shí)對(duì)異常情況進(jìn)行處理，因此，只有當(dāng)異常出現(xiàn)的時(shí)候，才會(huì)執(zhí)行catch塊的代碼。所以，選項(xiàng)C正確。

所以，本題的答案為BC。7.

下面關(guān)于java.lang.Exception類的描述中，正確的是______。

（分?jǐn)?shù)：2.00）

A.該類是一個(gè)公共類

√

B.該類實(shí)現(xiàn)了Throwable接口

C.該類是Throwable類的子類

√

D.該類可以序列化

√解析：對(duì)于選項(xiàng)A，在Java語言中，java.lang.Exception類是所有異常的直接或問接父類，即Exception類是所有異常的根類。java.lang.Throwable類是在Java語言中所有錯(cuò)誤和異常的超類。Exception類的定義為publicclassExceptionextendsThrowable，而Throwable的定義為publicclassThrowableextendsObjectimplementsSerializable。由此可見，Exception是公共類(被public修飾)。因此，選項(xiàng)A正確。

對(duì)于選項(xiàng)B與選項(xiàng)C，Exception是Throwable的子類，Throwable是類而不是接口。因此，選項(xiàng)B錯(cuò)誤，選項(xiàng)C正確。

對(duì)于選項(xiàng)D，由于Throwable實(shí)現(xiàn)了Serializable接口，因此，可以被序列化。如果一個(gè)類能被序列化，那么它的子類也能夠被序列化。因此，Exception類也可以被序列化。因此，選項(xiàng)D正確。

所以，本題的答案為ACD。8.

構(gòu)造BufferedlnputStream的合適參數(shù)是______。

（分?jǐn)?shù)：2.00）

A.BufferedlnputStream

√

B.BufferedOutputStream

C.FilelnputStream

√

D.FileOuterStream

E.File解析：三、填空題(總題數(shù)：2，分?jǐn)?shù)：4.00)1.

有如下代碼：

publicclassTest

{

publicstaticvoidmain(String[]args)

{

Stringa="hello";

change(a);

System.out.println(a);

}

publicstaticvoidchange(Stringname)

{name="world";}

}

程序的運(yùn)行結(jié)果是______。

（分?jǐn)?shù)：2.00）填空項(xiàng)1:__________________

（正確答案：“hello”。）解析：本題中，在調(diào)用change方法的時(shí)候，傳遞的是字符串a(chǎn)的引用(或地址)，此時(shí)，name與a指向同一個(gè)字符串，也就是說，對(duì)于字符串a(chǎn)的地址而言，這個(gè)方法調(diào)用是值傳遞。而在方法change內(nèi)部對(duì)這個(gè)傳遞的地址(值)進(jìn)行修改，也就是修改了name的指向，這個(gè)修改對(duì)實(shí)參是沒有影響的，因此，程序的運(yùn)行結(jié)果為“hello”。2.

下面程序的運(yùn)行結(jié)果是______。

publicclassTest

{

publicstaticvoidmain(Stringargs[])

{

Stringstr1="Hello";

Stringstr2="world";

System.out.println(newStr(str1,str2));

System.out.println(str2);

}

}

classStr

{

Strings1;

Strings2;

Str(Stringstr1,Stringstr2)

{

S1=str1;

s2=str2;

str2+=str1;

}

publicStringtoString()

{

returns1+s2;

}

}

（分?jǐn)?shù)：2.00）填空項(xiàng)1:__________________

（正確答案：Helloworld

world）解析：本題中，在調(diào)用newStr(str1,str2)的時(shí)候，初始化了一個(gè)臨時(shí)的Str的實(shí)例(s1="Hello!",s2="world")，當(dāng)調(diào)用System.out.println方法輸出這個(gè)對(duì)象的時(shí)候，會(huì)調(diào)用這個(gè)對(duì)象的toString方法，返回s1+s2，顯然，返回值為Helloworld。在這個(gè)過程中，str2的值被初始化以后就沒有被修改過，因此，接下來輸出str2的值：world。四、論述題(總題數(shù)：15，分?jǐn)?shù)：30.00)1.

switch是否能作用在byte上?是否能作用在long上?是否能作用在String上?

（分?jǐn)?shù)：2.00）__________________________________________________________________________________________

正確答案：(switch能作用在byte上，不能作用在long上，從Java7開始可以作用在String上。

switch語句用于多分支選擇，在使用switch(expr)的時(shí)候，expr只能是一個(gè)枚舉常量(內(nèi)部也是由整型或字符類型實(shí)現(xiàn))或一個(gè)整數(shù)表達(dá)式，其中，整數(shù)表達(dá)式可以是基本數(shù)據(jù)類型int或其對(duì)應(yīng)的包裝類Integer，當(dāng)然也包括不同的長度整型，例如short。由于byte、short和char都能夠被隱式地轉(zhuǎn)換為int類型，因此，這些類型以及它們對(duì)應(yīng)的包裝類型都可以作為switch的表達(dá)式。但是，long、float、double和String類型由于不能夠隱式地轉(zhuǎn)換為int類型，因此，它們不能被用作switch的表達(dá)式。如果一定要使用long、float或double作為switch的參數(shù)，必須將其強(qiáng)制轉(zhuǎn)換為int型才可以。

例如，以下對(duì)switch中參數(shù)的使用就是非法的。

floata=0.123;

switch(a)//錯(cuò)誤!a不是整型或字符類型變量

{

...

}

另外，與switch對(duì)應(yīng)的是case語句，case語句之后可以是直接的常量數(shù)值，例如1、2，也可以是一個(gè)常量計(jì)算式，例如1+2等，還可以是final型的變量(fina1變量必須是編譯時(shí)的常量)，例如fina1inta=0，但不能是變量或帶有變量的表達(dá)式，例如i*2等。當(dāng)然，更不能是浮點(diǎn)型數(shù)，例如1.1，或者1.2/2等。

switch(formWay)

{

case2-1://正確

...

casea-2://錯(cuò)誤

...

case2.0://錯(cuò)誤

...

}

隨著Java語言的發(fā)展，在Java7中，switch開始支持String類型了。)解析：2.

下面程序是否存在問題?如果存在，請(qǐng)指出問題所在，如果不存在，說明輸出結(jié)果。

publicclassTest

{

publicstaticvoidmain(String[]args)

{

Stringstr=newString("good");

char[]ch={'a','b','c'};

Testex=newTest();

ex.change(str,ch);

System.out.print(str+"and");

System.out.print(ch);

}

publicvoidchange(Stringstr,charch[])

{

str="testok";

ch[0]='g';

}

}

（分?jǐn)?shù)：2.00）__________________________________________________________________________________________

正確答案：(不存在問題，輸出結(jié)果為goodandgbc。)解析：在調(diào)用change方法時(shí)，str和cb傳遞的都是引用，在方法中修改了ch指向?qū)ο蟮膬?nèi)容，由于形參與實(shí)參指向相同的對(duì)象，因此，通過形參對(duì)對(duì)象內(nèi)容的修改對(duì)實(shí)參是可見的。對(duì)于str來說，修改的是引用本身，也就是說，修改的是引用的值，而不是修改了引用指向的內(nèi)容。形參引用的值是實(shí)參引用值的一個(gè)拷貝；從這個(gè)角度來講，引用傳遞是通過傳遞引用的值來實(shí)現(xiàn)的，可以理解為值傳遞，對(duì)引用本身的修改對(duì)實(shí)參是不可見的。3.

對(duì)于一些敏感的數(shù)據(jù)(例如密碼)，為什么使用字符數(shù)組存儲(chǔ)比使用String更安全?

（分?jǐn)?shù)：2.00）__________________________________________________________________________________________

正確答案：(在Java語言中，String是不可變類，它被存儲(chǔ)在常量字符串池中，從而實(shí)現(xiàn)了字符串的共享，減少了內(nèi)存的開支。正因?yàn)槿绱?，一旦一個(gè)String類型的字符串被創(chuàng)建出來，這個(gè)字符串就會(huì)存在于常量池中直到被垃圾回收器回收為止。因此，即使這個(gè)字符串(比如密碼)不再被使用，它仍然會(huì)在內(nèi)存中存在一段時(shí)間(只有垃圾回收器才會(huì)回收這塊內(nèi)容，程序員沒有辦法直接回收字符串)。此時(shí)有權(quán)限訪問memorydump(存儲(chǔ)器轉(zhuǎn)儲(chǔ))的程序都可能會(huì)訪問到這個(gè)字符串，從而把敏感的數(shù)據(jù)暴露出去，這是一個(gè)非常大的安全隱患。如果使用字符數(shù)組，一旦程序不再使用這個(gè)數(shù)據(jù)，程序員就可以把字符數(shù)組的內(nèi)容設(shè)置為空，此時(shí)這個(gè)數(shù)據(jù)在內(nèi)存中就不存在了。從以上分析可以看出，與使用String相比，使用字符數(shù)組，程序員對(duì)數(shù)據(jù)的生命周期有更好的控制，從而可以增強(qiáng)安全性。)解析：4.

語句Strings="Helloworld!"聲明了什么?

（分?jǐn)?shù)：2.00）__________________________________________________________________________________________

正確答案：(也許大部分人都會(huì)認(rèn)為這個(gè)語句只是創(chuàng)建了一個(gè)字符串而己，這種回答不是非常準(zhǔn)確。

其實(shí)，對(duì)于Strings="Helloworld!"這條語句，要分以下兩種情況來討論：

(1)在此之前沒有定義過字符串常量“Helloworld!”

對(duì)于這種情況，這行代碼其實(shí)做了兩件事：一是在常量區(qū)創(chuàng)建了字符串“Helloworld!”，二是聲明了一個(gè)字符串對(duì)象的引用s，這個(gè)變量s引用的是常量區(qū)中的字符串常量“Helloworld!”。這行代碼可以等價(jià)為以下兩行代碼：

Strings;

//聲明一個(gè)字符串對(duì)象的引用

s="Helloworld!";

//讓s指向字符串常量“Helloworld!”

(2)在此之前已經(jīng)定義過字符串常量“Helloworld!”

如果在執(zhí)行這行代碼之前，已經(jīng)定義過字符串常量“Helloworld!”，那么這行代碼不會(huì)創(chuàng)建新的字符串，只創(chuàng)建一個(gè)字符串對(duì)象的引用s，讓s指向常量區(qū)中已經(jīng)存在的字符串常量“Helloworld!”。)解析：5.

至少寫出String中的10個(gè)常用方法。

（分?jǐn)?shù)：2.00）__________________________________________________________________________________________

正確答案：(String中的常用方法見下表。String中的常用方法返回值方法名方法描述booleanstartsWith(Stringprefix)判斷此字符串是否以指定的前綴開始Stringsubstring(intbeginlndex)返回一個(gè)新的字符串，它是此字符串的一個(gè)子字符串Stringtrim()返回字符串的副本，忽略前導(dǎo)空白和尾部空白staticStringvalueOf(char[]data)返回char數(shù)組參數(shù)的字符串表示形式charcharAt(intindex)返回字符串在位置index處的字符Stringconcat(Stringstr)將指定字符串連到此字符串的結(jié)尾booleancontains(CharSequences)當(dāng)且僅當(dāng)此字符串包含char值的指定序列時(shí)，才返回truebooleanendsWith(Stringsuffix)判斷此字符串是否以指定的后綴結(jié)束byte[]getBytes()使用平臺(tái)默認(rèn)的字符集將此String解碼為字節(jié)序列，并將結(jié)果存儲(chǔ)到一個(gè)新

的字節(jié)數(shù)組中intindexOf(intch)返回指定字符在此字符串中第一次出現(xiàn)處的索引mtlength()返回此字符串的長度String[]split(Stringregex)根據(jù)給定的正則表達(dá)式的匹配來拆分此字符串)解析：6.

怎樣實(shí)現(xiàn)將GB2312編碼的字符串轉(zhuǎn)換為ISO8859-1編碼?

（分?jǐn)?shù)：2.00）__________________________________________________________________________________________

正確答案：(編碼是一個(gè)非常重要的概念，尤其在網(wǎng)絡(luò)傳輸中。通過網(wǎng)絡(luò)傳輸一個(gè)字符串的流程如下：發(fā)送方把字符串轉(zhuǎn)換成byte序列進(jìn)行傳輸，接收方接收到byte序列后，需要把byte序列轉(zhuǎn)換成字符串。也許有人認(rèn)為這個(gè)工作非常簡單，假如要傳輸字符串strings="中國";，只需要調(diào)用s.getBytes()方法就可以把字符串轉(zhuǎn)換為byte數(shù)組進(jìn)行發(fā)送，接收方接收到這個(gè)byte數(shù)組b后，再調(diào)用newString(b)就可以轉(zhuǎn)換為字符串。getBytes()方法采用系統(tǒng)默認(rèn)的編碼方式把字符串轉(zhuǎn)換為byte數(shù)組，newString(b)采用系統(tǒng)默認(rèn)的編碼方式把byte數(shù)組轉(zhuǎn)換為字符串。采用這種方法，當(dāng)發(fā)送方與接收方所在系統(tǒng)默認(rèn)的編碼方式不同時(shí)，就會(huì)出現(xiàn)亂碼。因此，在這種情況下需要使用另外一套接口來顯式地指定編碼方式，假設(shè)字符串采用utf-8的編碼方式，可以采用下面的寫法保證在任何情況下都能正確運(yùn)行：

發(fā)送方通過調(diào)用s.getBytes("utf-8")方法使用utf-8編碼方式把字符串編碼為字節(jié)流，接收方接收到字節(jié)流后，使用newString(b,"utf-8")方法進(jìn)行解碼，轉(zhuǎn)換為字符串。

當(dāng)然，各個(gè)編碼之間可以相互轉(zhuǎn)換，只不過以A方式編碼的字符串轉(zhuǎn)換為以B方式編碼的內(nèi)容后可能會(huì)有亂碼，如下代碼的功能是把GB2312編碼的字符串轉(zhuǎn)換為ISO8859-1編碼：

publicclassTest

{

publicstaticvoidmain(String[]args)throwsException

{

//這是一個(gè)用GB2312編碼的字符串

Stringgb=newString("中國".gecBytes(),"gb2312");

System.out.println(gb);

//把GB2312編碼的字符串改為用ISO8859-1編碼

//需要先用GB2312解碼，然后用ISO8859-1編碼，采用新的編碼可能會(huì)有亂碼

Stringios=newString(gb.getBytes("gb2312"),"ISO-8859-1");

System.out.println(ios);

//再轉(zhuǎn)換回用GB2312編碼，不會(huì)有亂碼

gb=newString(ios.getBytes("ISO-8859-1"),"gb2312");

System.out.println(gb);

}

}

程序的運(yùn)行結(jié)果為：

中國

???..2

中國)解析：7.

為什么要把String設(shè)計(jì)為不變量?

（分?jǐn)?shù)：2.00）__________________________________________________________________________________________

正確答案：(在Java編程中，String是一個(gè)非常重要的類，幾乎在所有的項(xiàng)目中都會(huì)被用到，因此，String的性能就非常重要。鑒于此，String被設(shè)計(jì)為一個(gè)不可變量。具體而言，String被設(shè)計(jì)為不可變量有如下幾個(gè)重要的原因：

1)節(jié)省空間：在Java語言中，為了提供效率與空間使用率，把字符串常量存儲(chǔ)在Stringpool(池)中，這些字符串可以被共享，為了保證一個(gè)用戶對(duì)字符串的修改不會(huì)影響到其他用戶的使用，String被設(shè)計(jì)為不可變量。

2)提高效率：正是由于String會(huì)被不同的用戶共享，在多線程編程時(shí)，String可能會(huì)被不同的線程共享，如果把String設(shè)計(jì)為不可變量，那么它就是線程安全的，就不需要對(duì)String進(jìn)行同步，可以顯著提高多線程的效率。此外，String會(huì)經(jīng)常被當(dāng)作HashMap的key進(jìn)行存儲(chǔ)，也就需要計(jì)算String的hash值，如果String被設(shè)計(jì)為不可變量，它的hash值也會(huì)保持不變，就可以把它的hash值緩存起來，而不需要每次都計(jì)算hash值，可以顯著地提高效率。

3)安全因素：由于String會(huì)經(jīng)常被用作參數(shù)來使用(例如連接數(shù)據(jù)庫時(shí)使用的用戶名、密碼，讀寫文件時(shí)使用的文件名等)，如果String是可變量，黑客可以通過某種特定的手段對(duì)這些參數(shù)進(jìn)行修改，從而修改文件的內(nèi)容或?qū)傩?，造成安全隱患。為了安全，String被設(shè)計(jì)為不可變量，那么黑客就無法對(duì)字符串參數(shù)的內(nèi)容進(jìn)行修改了。)解析：8.

請(qǐng)給出Java異常類的繼承體系結(jié)構(gòu)，以及Java異常的分類，且為每種類型的異常各舉幾個(gè)例子。

（分?jǐn)?shù)：2.00）__________________________________________________________________________________________

正確答案：(Java語言提供了兩種錯(cuò)誤的處理類，分別為Error和Exception，且它們擁有共同的父類：Throwable。

它們的繼承關(guān)系如圖所示。

Java異常的繼承關(guān)系

由于有很多種檢查異常，這里只畫了IOException作為代表。)解析：9.

如何捕獲一個(gè)線程拋出的異常?

（分?jǐn)?shù)：2.00）__________________________________________________________________________________________

正確答案：(可以通過設(shè)置線程的UncaughtExceptionHandler(異常