Java筆試題庫之選題題篇【1-70題】

1.下面中哪兩個能夠在A的子類中使用：（ ）

　　class A {

　　　　protected int method1 (int a, int b) {

　　　　　　return 0;

　　　　}

　　}

A. public int method 1 (int a, int b) { return 0; }

B. private int method1 (int a, int b) { return 0; }

C. private int method1 (int a, long b) { return 0; }

D. public short method1 (int a, int b) { return 0; }

解答：AC

A，符合子類重寫父類方法的規則

B，子類重寫父類的方法，訪問權限不能下降

C，屬於重載

D，子類重寫父類的方法 返回值類型要相同或是父類方法返回值類型的子類

2.抽象方法能夠被static修飾嘛？

A True

B False

解答：B

抽象方法能夠在子類中被重寫，可是靜態方法不能在子類中被重寫，靜態方法和靜態屬性與對象是無關的，只與類有關，這與abstract是矛盾的，因此abstract是不能被修飾爲static，不然就失去了abstract的意義了

3.如下程序的執行結果是什麼？

　　class Base{

　　　　void test() {

　　　　　　System.out.println(「Base.test()」);

　　　　}

　　}

　　public class Child extends Base {

　　　　void test() {

　　　　　　System.out.println(「Child.test()」);

　　　　}

　　　　public static void main(String[] a) {

　　　　　　Child anObj = new Child();

　　　　　　Base baseObj = (Base)anObj;

　　　　　　baseObj.test();

　　　　}

　　}

A Child.test() Base.test()

B Base.test() Child.test()

C Base.test()

D Child.test()

解答：D

測試代碼至關於：Base baseObj = new Child();父類的引用指向子類的實例，子類又重寫了父類的test方法，所以調用子類的test方法。

4.如下程序的執行結果是什麼

　　class Base{

　　　　static void test() {

　　　　　　System.out.println(「Base.test()」);

　　　　}

　　}

　　public class Child extends Base {

　　　　void test() {

　　　　　　System.out.println(「Child.test()」);

　　　　　　Base.test(); //Call the parent method

　　　　}

　　　　static public void main(String[] a) {

　　　　　　new Child().test();

　　　　}

　　}

A Child.test() Base.test()

B Child.test() Child.test()

C 編譯報錯. 

D 運行報錯. 

解答：C

靜態方法不能在子類中被重寫

5.如下程序的執行結果是什麼

　　public class Base{

　　　　private void test() {

　　　　　　System.out.println(6 + 6 + 「(Result)」+6+6);

　　　　}

　　　　static public void main(String[] a) {

　　　　　　new Base().test();

　　　　}

　　}

A 66(Result)66

B 12(Result)12

C 66(Result)12

D 12(Result)66

解答：D

字符串與基本數據類型連接的問題,若是第一個是字符串那麼後續就都按字符串處理，好比上邊例子要是System.out.println(「(Result)」+6 + 6 );那麼結果就是(Result)66，若是第一個和第二個。。。第n個都是基本數據第n+1是字符串類型，那麼前n個都按加法計算出結果在與字符串鏈接

6.如下程序的執行結果是什麼；’ ?’ 是空格的意思.

　　public class Base{

　　　　private void test() {

　　　　　　String aStr = 「?One?」;

　　　　　　String bStr = aStr;

　　　　　　aStr.toUpperCase();

　　　　　　aStr.trim();

　　　　　　System.out.println(「[" + aStr + "," + bStr + "]「);

　　　　}

　　　　static public void main(String[] a) {

　　　　　　new Base().test();

　　　　}

　　}

A [ONE,?One?]

B [?One?,One]

C [ONE,One]

D [ONE,ONE]

E [?One?,?One?]

解答：E

經過String bStr = aStr;這句代碼使bStr和aStr指向同一個地址空間，因此最後aStr和bStr的結果應該是同樣，而且aStr在調用了方法以後，並無將結果重洗賦值給aStr（即aStr=aStr.toUpperCase();）因此aStr調用了方法以後其本來的值並無被改變

7.下面關於變量及其範圍的陳述哪些是不正確的（ ）：

A．實例變量是類的成員變量

B．實例變量用關鍵字static聲明

C．在方法中定義的局部變量在該方法被執行時建立

D．局部變量在使用前必須被初始化

解答：BC

由static修飾的變量稱爲類變量或是靜態變量；方法加載的時候建立局部變量

8.下列關於修飾符混用的說法，錯誤的是（ ）：

A．abstract不能與final並列修飾同一個類

B．abstract類中能夠有private的成員

C．abstract方法必須在abstract類中

D．static方法中能處理非static的屬性

解答 D

:靜態方法中不能引用非靜態的成員

9.執行完如下代碼int[ ]  x = new int[25]；後，如下哪項說明是正確的（ ）：

A、 x[24]爲0

B、 x[24]未定義

C、 x[25]爲0

D、 x[0]爲空

解答：A

x屬於引用類型的int數組，數組定義之後，該引用類型的每個成員是int類型，默認值都爲：0；而且數組是以0爲索引開始算，雖然其長度爲25，但其最大下標只有25-1

10.編譯運行如下程序後，關於輸出結果的說明正確的是 （ ）：

　　public class Conditional{

　　　　public static void main(String args[ ]){

　　　　int x=4;

　　　　System.out.println(「value is 「+ ((x>4) ? 99.9 :9));

　　　　}

　　}

A、 輸出結果爲：value is 99.99

B、 輸出結果爲：value is 9

C、 輸出結果爲：value is 9.0

D、 編譯錯誤

解答：C

三目運算符中：第二個表達式和第三個表達式中若是都爲基本數據類型，整個表達式的運算結果由容量高的決定。99.9是double類型 而9是int類型，double容量高。

11.關於如下application的說明，正確的是（ ）：

1.　　class StaticStuff{

2.　　　　static int x=10；

3.　　　　static { x+=5；}

4.　　　　public static void main（String args[ ]）{

5.　　　　　　System.out.println(「x=」 + x);

6.　　　　}

7.　　　　static { x/=3;}

8. }

A、 3行與7行不能經過編譯，由於缺乏方法名和返回類型

B、 7行不能經過編譯，由於只能有一個靜態初始化器

C、 編譯經過，執行結果爲：x=5

D、編譯經過，執行結果爲：x=3

解答：C

靜態代碼塊是類加載的時候就會被執行到的，靜態代碼塊的執行順序是按照在類中出現的前後順序執行。

12.關於如下程序代碼的說明正確的是（ ）：

1．　　class HasStatic{

2． 　　　　private static int x=100；

3． 　　　　public static void main(String args[ ]){

4． 　　　　　　HasStatic hs1=new HasStatic( );

5． 　　　　　　hs1.x++;

6． 　　　　　　HasStatic hs2=new HasStatic( );

7． 　　　　　　hs2.x++;

8． 　　　　　　hs1=new HasStatic( );

9． 　　　　　　hs1.x++;

10.　　　　　　 HasStatic.x - -;

11． 　　　　　 System.out.println(「x=」+x);

12． 　　　　}

13．　　}

A、5行不能經過編譯，由於引用了私有靜態變量

B、10行不能經過編譯，由於x是私有靜態變量

C、程序經過編譯，輸出結果爲：x=101

D、程序經過編譯，輸出結果爲：x=102

E、程序經過編譯，輸出結果爲：x=103

解答：D

靜態變量是全部對象所共享的，因此上述代碼中的幾個對象操做是同一靜態變量x， 靜態變量能夠經過類名調用。

13.下列說法正確的有（）

A． class中的constructor不可省略

B． constructor必須與class同名，但方法不能與class同名

C． constructor在一個對象被new時執行

D．一個class只能定義一個constructor

解答：C

構造方法的做用是在實例化對象的時候給數據成員進行初始化

A．類中若是沒有顯示的給出構造方法，系統會提供一個無參構造方法

B．構造方法與類同名，類中能夠有和類名相同的方法

D．構造方法能夠重載

14.下列哪一種說法是正確的（）

A．實例方法可直接調用超類的實例方法

B．實例方法可直接調用超類的類方法

C．實例方法可直接調用其餘類的實例方法

D．實例方法可直接調用本類的類方法

解答：D

A. 實例方法不可直接調用超類的私有實例方法

B. 實例方法不可直接調用超類的私有的類方法

C．要看訪問權限

15.下列哪種敘述是正確的（ ）

A． abstract修飾符可修飾字段、方法和類

B． 抽象方法的body（方法實體）部分必須用一對大括號{ }包住

C． 聲明抽象方法，大括號無關緊要

D． 聲明抽象方法不可寫出大括號

解答：D

abstract能夠修飾方法和類，不能修飾屬性。抽象方法沒有方法體，即沒有大括號{}

16.下面代碼的執行結果是？

　　import java.util.*;

　　public class ShortSet{

　　　　public static void main(String args[]){

　　　　　　Set<Short> s=new HashSet<Short>();

　　　　　　for(Short i=0;i<100;i++){

　　　　　　　　s.add(i);

　　　　　　　　s.remove(i-1);

　　　　　　}

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

　　　　}

　　}

A.1

B.100

C.Throws Exception

D.None of the Above

解答：B

i是Short類型， i-1是int類型,其包裝類爲Integer，因此s.remove(i-1)不能移除Set集合中Short類型對象；只有將（i-1）強轉爲Short類型的時候，才能移除Set集合中的對象

17.鏈表具備的特色是：

A、沒必要事先估計存儲空間

B、可隨機訪問任一元素

C、插入刪除不須要移動元素

D、所需空間與線性表長度成正比

解答：ACD

A.採用動態存儲分配，不會形成內存浪費和溢出。

B. 不能隨機訪問，查找時要從頭指針開始遍歷

C. 插入、刪除時，只要找到對應前驅結點，修改指針便可，無需移動元素

D. 須要用額外空間存儲線性表的關係，存儲密度小

18.Java語言中，String類的IndexOf()方法返回的類型是？

A、Int16 B、Integer C、int D、long

解答：C

indexOf方法的聲明爲：public int indexOf(int ch)在此對象表示的字符序列中第一次出現該字符的索引；若是未出現該字符，則返回 -1。

19.如下關於面向對象概念的描述中，不正確的一項是（）。

A.在現實生活中，對象是指客觀世界的實體

B.程序中的對象就是現實生活中的對象

C.在程序中，對象是經過一種抽象數據類型來描述的，這種抽象數據類型稱爲類（class）

D.在程序中，對象是一組變量和相關方法的集合

解答：B

面向過程強調的是每個功能的具體實現步驟，面向對象強調的是對象調用功能

20..執行下列代碼後,哪一個結論是正確的

　　String[] s=new String[10];

A． s[9] 爲 null;

B． s[10] 爲 「」;

C． s[0] 爲 未定義

D． s.length 爲10

解答：AD

s是引用類型，s中的每個成員都是引用類型，即String類型，String類型默認的值爲null

21.屬性的可見性有。(不定項選擇)

A.公有的

B.私有的

C.私有保護的

D.保護的

E.默認的

解答：ABDE

屬性的可見性有四種：公有的（public） 保護的（protected） 默認的 私有的（private）

22..在字符串前面加上_____符號，則字符串中的轉義字符將不被處理。

A @

B \

C #

D %

解答：B

在java中「\」表示轉譯符，改變了後面字符的原本意思；\r：回車；\n：換行（new line）；\t：至關於tab鍵（叫製表符太生澀）；\\：表示\；\'：表示'；\"：表示"

23.下列代碼哪行會出錯: 

1) 　　public void modify() {

2) 　　　　int I, j, k;

3) 　　　　I = 100;

4) 　　　　while ( I > 0 ) {

5) 　　　　　　j = I * 2;

6) 　　　　　　System.out.println (」 The value of j is 」 + j );

7) 　　　　　　k = k + 1;

8) 　　　　　　I - -;

9) 　　　　}

10) 　　}

A. 4

B. 6

C. 7

D. 8

解答：C

k沒有初始化就使用了

24.對記錄序列{314，298，508，123，486，145}按從小到大的順序進行插入排序，通過兩趟排序後的結果爲：

A {314，298，508，123，145，486}

B {298，314，508，123，486，145}

C {298，123，314，508，486，145}

D {12三、298，314，508，486，145}

解答：B

插入排序算法：（）

　　public static void injectionSort(int[] number) {

　　// 第一個元素做爲一部分，對後面的部分進行循環

　　for (int j = 1; j < number.length; j++) {

　　　　int tmp = number[ j ];

　　　　int i = j – 1;

　　　　while (tmp < number[ i ]) {

　　　　　　number[i + 1] = number[ i ];

　　　　　　i - -;

　　　　　　if (i == -1)

　　　　　　　　break;

　　　　}

　　　　number[i + 1] = tmp;

　　}

　　}

25.棧是一種。

A 存取受限的線性結構

B 存取不受限的線性結構

C 存取受限的非線性結構

D 存取不受限的非線性結構

解答：A

棧（stack）在計算機科學中是限定僅在表尾進行插入或刪除操做的線性表。

26.下列哪些語句關於內存回收的說明是正確的。

A 程序員必須建立一個線程來釋放內存

B 內存回收程序負責釋放無用內存

C 內存回收程序容許程序員直接釋放內存

D 內存回收程序能夠在指定的時間釋放內存對象

解答：B

垃圾收集器在一個Java程序中的執行是自動的，不能強制執行，即便程序員能明確地判斷出有一塊內存已經無用了，是應該回收的，程序員也不能強制垃圾收集器回收該內存塊。程序員惟一能作的就是經過調用System. gc 方法來」建議」執行垃圾收集器，但其是否能夠執行，何時執行卻都是不可知的。

27.要實現java.long.Runnable接口，必須實現下列哪一個方法？

A. void run()

B. public void run()

C. public void start()

D. void run(int priority)

E. public void run(int priority)

F. public void start(int priority)

解答：B

實現Runnable接口，接口中有一個抽象方法run，實現類中實現該方法。

28 下列程序的結果是什麼？

1　　public static void main(String[] args) {

2　　　　Object obj = new Object() {

3　　　　　　public int hashCode() {

4　　　　　　　　return 42;

5　　　　　　}

6　　　　};

7　　　　System.out.println(obj.hashCode());

8　　}

A. 42

B.在運行時拋出異常

C. 編譯失敗，緣由是第2行出現錯誤

D. 編譯失敗，緣由是第3出現錯誤

E. 編譯失敗，緣由是第7行出現錯誤.

解答：A

匿名內部類重寫了hashCode方法。

29 java中的兩個保留字是什麼

A. const

B. import

C. doto

D. implements

解答：AC

const用於修改字段或局部變量的聲明。它指定字段或局部變量的值是常數，不能被修改

goto指定跳轉到標籤，找到標籤後，程序將處理從下一行開始的命令

30. 在一個類中重寫了hashCode和equals兩個方法，那麼對於同一個類的兩個實例，下列說法正確的是？

A. 若是hashCode值相同，equsal不一樣，則這兩個對象相同

B. 若是hashCode值相同，equals相同，則這兩個對象相同

C. 若是hashCode不一樣，equals相同，則這兩個對象相同

D. 若是hashCode值相同，則這兩個對象有可能相同

解答：BD

先經過 hashcode來判斷某個對象是否存放某個桶裏，但這個桶裏可能有不少對象，那麼咱們就須要再經過 equals 來在這個桶裏找到咱們要的對象。

31. java中char的取值範圍是多少?

A. 0 ~32767

B. 0 ~65535

C. –65535~65535

D. –128 ~127

解答：B

在Java中，char是一個無符號16位類型，取值範圍爲0到65535。

32. 下列程序運行結果是什麼？

　　public class Test {

　　　　private static float[] f = new float[2];

　　　　public static void main(String args[]) {

　　　　　　System.out.println(「f[0] = 「 + f[0]);

　　　　}

　　}

A. f[0] = 0

B. f[0] = 0.0

C. 編譯時報錯

D. 運行時報錯

解答：B

f屬於引用類型的float數組，數組定義之後，該引用類型的每個成員是float類型，默認值都爲：0.0

33. 下列程序的運行結果是什麼？

　　public class Test {

　　　　public static void main(String[] args) {

　　　　　　String str = NULL;

　　　　　　System.out.println(str);

　　　　}

　　}

A. NULL

B. 編譯時報錯

C. ""

D.運行時報錯

解答：B

null應該小寫

3四、下列程序執行結果是什麼？

　　public class Text{

　　　　public static void main(String[] args){

　　　　　　int a=10,b=4,c=20,d=6;

　　　　　　System.out.println(a++*b+c*--d);

　　　　}

　　}

A、144

B、164

C、140

D、160

解答：C

在java中執行加減乘除基本運算時，已就遵循先乘除後加減的原則，而++a與a++的區別在於，++a是先自增後在參與運算，a++是先參與運算以後在自增，因此最終答案是10*4+20*5=140

3五、下列哪兩個選項不能直接致使線程中止？

A. 跳出同步代碼塊

B. 調用wait方法

 C. 調用notify方法

 D. 調用讀取流的方法

 E. 設置線程的優先權

 解答：AC

stop方法.這個方法將終止全部未結束的方法，包括run方法。當一個線程中止時候，他會當即釋放 全部他鎖住對象上的鎖。這會致使對象處於不一致的狀態。 當線程想終止另外一個線程的時候，它沒法知道什麼時候調用stop是安全的，什麼時候會致使對象被破壞。因此這個方法被棄用了。你應該中斷一個線程而不是中止他。被中斷的線程會在安全的時候中止。

A、若是一個線程想進入一個已經被另一個線程佔用得同步代碼塊，這個線程會中止，可是這裏說的是跳出

B、他能使當前線程中止，等待別人調用notify方法

C、放另一個調用了wait方法得線程繼續執行，本身也能夠繼續執行

D、這是典型的阻塞方法，線程等待知道確實有東西可讀得時候纔會去讀

E、由於優先級改變了，JVM要從新選擇優先級高得先執行，因此會短暫中止

3六、 關於默認構造函數的建立，下列說法那些正確

A. 默認構造函數能夠初始化方法變量

B. 構造方法默認調用超類的無參構造方法

C. 默認構造方法會去初始化成員變量

D. 若是沒有無參構造函數，但有其餘構造函數，程序會自動建立默認的構造函數

E. 只有在該類沒有其餘構造函數的時候，程序纔會自動建立默認的構造函數

解答：BCE

構造方法的做用是實例化對象的時候給數據成員初始化，若是類中沒有顯示的提供構造方法，系統會提供默認的無參構造方法，若是有了其它構造方法，默認的構造方法再也不提供。

3七、 在下列程序中聲明一個內部內，如下選擇中，哪些最合適？

　　public class OuterClass {

　　　　private double d1 = 1.0;

　　　　//在這裏聲明

　　}

A. static class InnerOne { public double methoda() {return d1;} }

B. static class InnerOne { static double methoda() {return d1;} }

C. private class InnerOne { public double methoda() {return d1;} }

D. protected class InnerOne { static double methoda() {return d1;} }

E. public abstract class InnerOne { public abstract double methoda(); }

解答：CE

AB.內部類能夠聲明爲static的，但此時就不能再使用外層封裝類的非static的成員變量；

D.非static的內部類中的成員不能聲明爲static的，只有在頂層類或static的內部類中才可聲明static成員

3八、 下列方法中，哪些方法在子類中不能重寫? 

A. final void methoda() {}

B. void methoda() {}

C. static void methoda() {}

D. static final void methoda() {}

解答：ACD

final修飾方法，在子類中不能被重寫。被static修飾的方法在子父類中不算是重寫，其底層是把父類的同名方法隱藏了

3九、下列程序的運行結果是什麼:

　　public class Test {

　　　　public static void main (String args[]) {

　　　　　　class Foo {

　　　　　　　　public int i = 3;

　　　　　　}

　　　　　　Object o = (Object) new Foo();

　　　　　　Foo foo = (Foo)o;

　　　　　　System.out.println(foo.i);

　　　　}

　　}

A. 編譯失敗

B. 編譯成功，而且會輸出打印「3」

C. 編譯成功，但會在第6行拋出ClassCastException異常

D. 編譯成功，但會在第7行拋出ClassCastException異常

解答：B

局部內部類的使用

40、 下列程序的運行結果是什麼:

　　public class Test {

　　　　public static void main (String [] args) {

　　　　　　String foo = 「blue」;

　　　　　　String bar = foo;

　　　　　　foo = 「green」;

　　　　　　System.out.println(bar);

　　　　}

　　}

A. 運行時異常

B. 編譯時異常

C. 輸出結果爲「null」

D. 輸出結果爲 「blue」

E. 輸出結果爲 「green」

解答：D

採用String foo = 「blue」定義方式定義的字符串放在字符串池中，經過String bar = foo;他們指向了同一地址空間，就是同一個池子，當執行foo = 「green」; foo指向新的地址空間。

4一、下面哪一個選項中整型變量foo的值最接近可是不大於double型變量bar的值？

A. int foo = (int) Math.max(bar);

B. int foo = (int) Math.min(bar);

C. int foo = (int) Math.abs(bar);

D. int foo = (int) Math.ceil(bar);

E. int foo = (int) Math.floor(bar);

F. int foo = (int) Math.round(bar);

解答：E

max方法是取最大值

min方法是取最小值

abs方法是取bar的絕對值，

ceil方法返回最小的（最接近負無窮大）double 值，該值大於等於參數，並等於某個整數。

floor方法返回最大的（最接近正無窮大）double 值，該值小於等於參數，並等於某個整數。

round方法 返回最接近參數的 long。

4二、 下列程序的運行結果是什麼:

1. 　 　package foo;

2.　 　 import java.util.Vector;

3. 　　 private class MyVector extends Vector {

4. 　　 　　int i = 1;

5. 　　 　　public MyVector() {

6. 　　 　　　　i = 2;

7.  　　 　　}

8. 　 　}

9. 　　 public class MyNewVector extends MyVector {

10.　　　　public MyNewVector () {

11.　　　　　　i = 4;

12.　　　　}

13.　　　　public static void main (String args []) {

14.　　　　　　MyVector v = new MyNewVector();

15. 　　　　}

16.　　}

A. 編譯成果

B. 在第3行編譯失敗

C. 在第6行編譯失敗

D. 在第9行編譯失敗

E. 在第14行編譯失敗

解答：B

類MyVector不能是私有的

4三、下列程序執行結果是什麼？

　　public class Text{

　　　　public static void main(String[] args){
　　　　　　int i=12;

　　　　　　System.out.println(i+=i-=i*=i);

　　　　}

　　}

A、程序沒法編譯

B、100

C、0

D、-120

解答：D

在java中執行加減乘除基本運算時，已就遵循先乘除後加減的原則，而i+=i至關於i=i+i；

本題咱們先將i+=i-+i*=i編號 => i1+=i2-=i3*=i4;在計算以前先明白i1=i2=i3=i4=i=12;先計算i3=i*i=144,;再計算i1+=i2即爲i1=i1+i2=24，此時i1=i2=24;最後計算i2-=i3即爲i2=i2-i3=-120;

4四、 下列選項中，哪些選項與第2行相等:

1. 　　public interface Foo{

2.　　 　　int k = 4;

3.　　 }

A. final int k = 4;

B. Public int k = 4;

C. static int k = 4;

D. Private int k = 4;

E. Abstract int k = 4;

F. Volatile int k = 4;

G. Transient int k = 4;

H. protected int k = 4;

解答：AB

static：修飾的靜態變量

final 修飾的是常量

abstract不能修飾變量

Volatile修飾的成員變量在每次被線程訪問時，都強迫從共享內存中重讀該成員變量的值。並且，當成員變量發生變化時，強迫線程將變化值回寫到共享內存。這樣在任什麼時候刻，兩個不一樣的線程老是看到某個成員變量的同一個值。

Transient：對不需序列化的類的域使用transient關鍵字,以減小序列化的數據量。

int k=4至關於public static final int k=4; 在接口中能夠不寫static final

4五、 下列代碼的執行結果是什麼:

　　public class foo {

　　　　static String s;

　　　　public static void main (String[]args) {

　　　　System.out.println (「s=」 + s);

　　　　}

　　}

A. 代碼編譯成功並輸出「s=」

B. 代碼編譯成功並輸出「s=null」

C. 由於變量s沒有初始化，因此代碼編譯失敗

D. 代碼編譯成功，但在調用toString的時候拋出NullPointerException異常

解答：B

String爲引用數據類型，引用類型數據成員的默認值爲null

4六、下列建立數組實例正確的是? 

A. int[] ia = new int [15];

B. float fa = new float [20];

C. char[] ca = 「Some String」;

D. Object oa = new float[20];

E. Int ia [][] = (4, 5, 6) (1, 2, 3)

解答：AD

任何類的父類都是Object，數組也數據引用類型，Object oa = new float[20];這種寫法至關於父類的用指向之類的實例。

4七、下列代碼中，在第四行 /X/ 能夠插入那些選項進行編譯？

　　public class ExceptionTest {

　　　　class TestException extends Exception {}

　　　　　　public void runTest () throws TestException {}

　　　　　　public void test () /X/ {

　　　　　　runTest ();

　　　　}

　　}

A. throws Exception

B. Catch (Exception e).

C. Throws RuntimeException.

D. Catch (TestException e).

E. No code is necessary.

解答：A

方法上使用throws拋出異常，Exception是異常類的超類。

4八、下列代碼的執行結果是什麼:

　　public class SwitchTest {

　　　　public static void main (String []args) {

　　　　　　System.out.println (「value =」 +switchIt(4));

　　　　}

　　　　public static int switchIt(int x) {

　　　　　　int j = 1;

　　　　　　switch (x) {

　　　　　　　　case 1:j++;

　　　　　　　　case 2: j++;

　　　　　　　　case 3: j++;

　　　　　　　　case 4: j++;

　　　　　　　　case 5: j++;

　　　　　　　　default:j++;

　　　　　　}

　　　　　　return j + x;

　　　　}

　　}

A. Value =3

B. Value =4

C. Value =5

D. Value =6

E. Value =7

F. Value =8

解答：F

因爲case塊沒有break語句，那麼從case 4：向下的代碼都會執行。

4九、下列選項中，那些是能夠被throw拋出的?

A. Error

B. Event

C. Object

D. Exception

E. Throwable

F. RuntimeException

解答：ADEF

可以拋出的對象類型要是Throwable 或是Throwable的子類

50．在下面程序的第6行補充上下列哪一個方法,會致使在編譯過程當中發生錯誤?

1)  　　class Super{

2) 　　 　　public float getNum(){

3) 　　 　　　　return 3.0f;

4)  　　　　}

　　　  }

5) 　　 pubhc class Sub extends Super{

6)

7) 　　 }

A,public float getNum(){retun 4.0f;}

B.public void getNum(){}

C.public void getNum(double d){}

D.public double getNum(float d){ retun 4.0f ;}

解答：B

方法重寫的問題。子類中有和父類的方法名相同，可是參數不一樣，不會出編譯錯誤，認爲是子類的特有的方法，可是若是子類中方法和父類的方法名，參數，訪問權限，異常都相同，只有返回值類型不一樣會編譯不經過。

51.下面關於import, class和package的聲明順序哪一個正確？( )

A. package, import, class

B. class, import, package

C. import, package, class

D. package, class, import

解答：A

在java代碼中，一個類從第一行到結尾，通常順序是 本類地址（在哪一個包下） 導了什麼包 class聲明

52.下面哪一個是正確的？( )

A. String temp [] = new String {「a」 「b」 「c」};

B. String temp [] = {「a」 「b」 「c」}

C. String temp = {「a」, 「b」, 「c」}

D. String temp [] = {「a」, 「b」, 「c」}

解答：D

53.關於java.lang.String類，如下描述正確的一項是（ ）

A. String類是final類故不能夠繼承；

B. String類是final類故能夠繼承；

C. String類不是final類故不能夠繼承；

D. String類不是final類故能夠繼承；

解答：A

String類是自讀字符串，被final修飾，在java中final修飾類的不能被繼承

54.關於實例方法和類方法，如下描述正確的是：( )

A. 實例方法只能訪問實例變量

B. 類方法既能夠訪問類變量，也能夠訪問實例變量

C. 類方法只能經過類名來調用

D. 實例方法只能經過對象來調用

解答：D

A  實例方法能夠訪問類變量

B  類方法只能訪問類變量

C  類方法能夠經過對象調用

55.接口是Java面向對象的實現機制之一，如下說法正確的是：( )

A. Java支持多繼承，一個類能夠實現多個接口；

B. Java只支持單繼承，一個類能夠實現多個接口；

C. Java只支持單繼承，一個類只能夠實現一個接口；

D. Java支持多繼承，但一個類只能夠實現一個接口。

解答：B

Java支持單重繼承，一個類只能繼承自另外的一個類，可是一個類能夠實現多個接口。可是java能夠多層繼承

56.下列關於interface（接口）的說法正確的是：( )

A. interface中能夠有private方法

B. interface中能夠有final方法

C. interface中能夠有function實現

D. interface能夠繼承其餘interface

解答：D

A．接口中不能夠有private的方法,接口不能被私有化

B．接口中不能夠有final的方法 接口中的方法默認是 public abstract的

C．接口中的方法不能夠有實現

57.已知A類被打包在packageA , B類被打包在packageB ，且B類被聲明爲public ，且有一個成員變量x被聲明爲protected控制方式 。C類也位於packageA包，且繼承了B類 。則如下說話正確的是（ ）

A. A類的實例不能訪問到B類的實例

B. A類的實例可以訪問到B類一個實例的x成員

C. C類的實例能夠訪問到B類一個實例的x成員

D. C類的實例不能訪問到B類的實例

解答：C

A、B包是public的，其餘包能訪問到

B、B包中的成員變量X被聲明成protected的，只能本包內實例才能訪問

C D、不一樣包子類的關係， 能夠訪問到父類B的protected成員

58.如下程序正確的輸出是（ ）

　　package test;

　　public class FatherClass {

　　　　public FatherClass() {

　　　　　　System.out.println(「FatherClass Create」);

　　　　}

　　}

　　package test;

　　import test.FatherClass;

　　public class ChildClass extends FatherClass {

　　　　public ChildClass() {

　　　　　　System.out.println(「ChildClass Create」);

　　　　}

　　　　public static void main(String[] args) {

　　　　　　FatherClass fc = new FatherClass();

　　　　　　ChildClass cc = new ChildClass();

　　　　}

　　}

A.

FatherClass Create

FatherClass Create

ChildClass Create

B.

FatherClass Create

ChildClass Create

FatherClass Create

C.

ChildClass Create

ChildClass Create

FatherClass Create

D.

ChildClass Create

FatherClass Create

FatherClass Create

解答：A

實例化一個類的時候，就會去調用它的構造方法；在子類構造方法執行時，默認狀況下第一句是super();來調用父類的構造方法

59.給定以下代碼，下面哪一個能夠做爲該類的構造函數 ( )

　　public class Test {

　　}

A. public void Test() {?}

B. public Test() {?}

C. public static Test() {?}

D. public static void Test() {?}

解答：B

構造方法：與類同名沒有放回類型

60.題目:

1. 　　public class test (

2. 　　　　public static void main (String args[]) {

3. 　　　　　　int i = 0xFFFFFFF1;

4. 　　　　　　int j = ~i;

5.

6. 　　　　}

7. 　　}

程序運行到第5行時,j的值爲多少?( )

A. –15

B. 0

C. 1

D. 14

E. 在第三行的錯誤致使編譯失敗

解答：D

int i = 0xFFFFFFF1;至關於 int i=-15  「~」表示取反再減1；結果就爲15-1=14

61.關於sleep()和wait()，如下描述錯誤的一項是（ ）

A. sleep是線程類（Thread）的靜態方法，wait是Object類的方法；

B. sleep不釋放對象鎖，wait放棄對象鎖；

C. sleep暫停線程、但監控狀態仍然保持，結束後會自動恢復；

D. wait後進入等待鎖定池，只有針對此對象發出notify方法後得到對象鎖進入運行狀態。

解答：D

sleep是線程類（Thread）的靜態方法，致使此線程暫停執行指定時間，給執行機會給其餘線程，可是監控狀態依然保持，到時後會自動恢復。調用sleep不會釋放對象鎖。

wait是Object類的方法，必須和synchronized關鍵字一塊兒使用。對此對象調用wait方法致使本線程進入阻塞狀態，，只有針對此對象發出notify方法（或notifyAll）後本線程纔會解除阻塞，但只有從新佔用互斥鎖以後，本線程纔會進入運行狀態。

62.下面能讓線程中止執行的有（多選）( )

A. sleep();

B. stop();

C. notify();

D. synchronized();

E. yield();

F. wait();

G. notifyAll();

解答：ABDEF

sleep：致使此線程暫停執行指定時間

stop: 這個方法將終止全部未結束的方法，包括run方法。

synchronized():對象鎖

yield：當前正在被服務的線程可能以爲cpu的服務質量不夠好，因而提早退出，這就是yield。

wait：當前正在被服務的線程須要睡一會，醒來後繼續被服務

63.下面哪一個能夠改變容器的佈局？( )

A. setLayout(aLayoutManager);

B. addLayout(aLayoutManager);

C. layout(aLayoutManager);

D. setLayoutManager(aLayoutManager);

解答：A

Java設置佈局管理器setLayout()

64.在使用super和this關鍵字時，如下描述正確的是（）

A、super（）和this（）不必定要放在構造方法第一行

B、this（）和super（）能夠同時出如今一個構造函數中

C、this（）和super（）能夠在static環境中使用，包括static方法和static代碼塊

D、在子類構造方法中，使用super（）顯示調用父類的構造方法，super（）必須寫在子類構造方法的第一行，不然編譯失敗

解答：D

super（）是調用父類方法，this（）是調用子類方法，子類方法中，只能放在方法的第一行，而且，他們兩不能同時出如今一個構造函數中，也不能調用被static修飾的方法和代碼塊

65.提供Java存取數據庫能力的包是（）

A．java.sql

B．java.awt

C．java.lang

D．java.swing

解答：A

java.sql是JDBC的編程接口

java.awt和java.swing是作圖像界面的類庫

java.lang: Java 編程語言進行程序設計的基礎類

66.不能用來修飾interface的有（）

A．private

B．public

C．protected

D．static

解答：ACD

修飾接口能夠是public和默認

67.下列說法錯誤的有（）

A． 在類方法中可用this來調用本類的構造方法

B． 在類方法中調用本類的類方法時可直接調用

C． 在類方法中只能調用本類中的類方法

D． 在類方法中絕對不能調用實例方法

解答：ACD

A.   在類方法中，被static修飾的方法裏不能用this，在其餘沒有被static修飾的類中可使用this，但不能調本類的構造方法

C．在類方法中能夠調用其它類中的靜態類方法

D．在類方法中能夠經過實例化對象調用實例方法

68.從下面四段（A，B，C，D）代碼中選擇出正確的代碼段（）

A．　abstract class Name {

　　　　private String name;

　　　　public abstract boolean isStupidName(String name) {}

　　  }

B．　public class Something {

　　　　void doSomething () {

　　　　　　private String s ="";

　　　　　　int l = s.length();

　　　　}

　　  }

C．　public class Something {

　　　　public static void main(String[] args) {

　　　　　　Other o = new Other();

　　　　　　new Something().addOne(o);

　　　　}

　　　　public void addOne(final Other o) {

　　　　　　o.i++;

　　　　}

　　  }

　　 class Other {

　　　　public int i;

　　 }

D．　public class Something {

　　　　public int addOne(final int x) {

　　　　　　return ++x; }

　　  }

解答：C

A..抽象方法不能有方法體

B．方法中定義的是局部變量，不能用類成員變量修飾符private

D．final修飾爲常量，常量的值不能被改變，因此不能做爲參數變量

69.選擇下面代碼的運行結果：（）。

　　public class Test{

　　　　public void method(){

　　　　　　for(int i = 0; i < 3; i++){

　　　　　　　　System.out.print(i);

　　　　　　}

　　　　　　System.out.print(i);

　　　　}

　　}

A．122

B．123

C．編譯錯誤

D．沒有任何輸出

解答：C

i變量的做用範圍是整個for循環，第二次輸出語句的i並無被定義

70.請看以下代碼

　　class Person {

　　　　private int a;

　　　　public int change(int m){

　　　　　　return m;

　　　　}

　　}

　　public class Teacher extends Person{

　　　　public int b;

　　　　public static void main(String arg[]){

　　　　　　Person p = new Person();

　　　　　　Teacher t = new Teacher();

　　　　　　int i;

　　　　　　 // point x

　　　　}

　　}

下面哪些放在// point x?行是正確的？

A， i = m;

B， i = b;

C， i = p.a;

D， i = p.change(3);

E， i = t.b;

解答：DE

A.不一樣的做用域

B．靜態方法中不能直接使用非靜態成員變量

C．類外不能訪問其它類私有的成員

D，E．在類方法中能夠經過實例化對象調用類中的實例成員。