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 {123、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應該小寫
34、下列程序執行結果是什么？
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
35、下列哪兩個選項不能直接導致線程停止？
A. 跳出同步代碼塊
B. 調用wait方法
C. 調用notify方法
D. 調用讀取流的方法
E. 設置線程的優先權
解答：AC
stop方法.這個方法將終止所有未結束的方法，包括run方法。當一個線程停止時候，他會立即釋放 所有他鎖住對象上的鎖。這會導致對象處於不一致的狀態。 當線程想終止另一個線程的時候，它無法知道何時調用stop是安全的，何時會導致對象被破壞。所以這個方法被棄用了。你應該中斷一個線程而不是停止他。被中斷的線程會在安全的時候停止。
A、如果一個線程想進入一個已經被另外一個線程占用得同步代碼塊，這個線程會停止，但是這里說的是跳出
B、他能使當前線程停止，等待別人調用notify方法
C、放另外一個調用了wait方法得線程繼續執行，自己也可以繼續執行
D、這是典型的阻塞方法，線程等待知道確實有東西可讀得時候才會去讀
E、因為優先級改變了，JVM要重新選擇優先級高得先執行，所以會短暫停止
36、 關於默認構造函數的創建，下列說法那些正確
A. 默認構造函數可以初始化方法變量
B. 構造方法默認調用超類的無參構造方法
C. 默認構造方法會去初始化成員變量
D. 如果沒有無參構造函數，但有其他構造函數，程序會自動創建默認的構造函數
E. 只有在該類沒有其他構造函數的時候，程序才會自動創建默認的構造函數
解答：BCE
構造方法的作用是實例化對象的時候給數據成員初始化，如果類中沒有顯示的提供構造方法，系統會提供默認的無參構造方法，如果有了其它構造方法，默認的構造方法不再提供。
37、 在下列程序中聲明一個內部內，以下選擇中，哪些最合適？
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成員
38、 下列方法中，哪些方法在子類中不能重寫?
A. final void methoda() {}
B. void methoda() {}
C. static void methoda() {}
D. static final void methoda() {}
解答：ACD
final修飾方法，在子類中不能被重寫。被static修飾的方法在子父類中不算是重寫，其底層是把父類的同名方法隱藏了
39、下列程序的運行結果是什么:
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指向新的地址空間。
41、下面哪個選項中整型變量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。
42、 下列程序的運行結果是什么:
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不能是私有的
43、下列程序執行結果是什么？
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;
44、 下列選項中，哪些選項與第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
45、 下列代碼的執行結果是什么:
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
46、下列創建數組實例正確的是?
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];這種寫法相當於父類的用指向之類的實例。
47、下列代碼中，在第四行 /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是異常類的超類。
48、下列代碼的執行結果是什么:
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：向下的代碼都會執行。
49、下列選項中，那些是可以被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．在類方法中可以通過實例化對象調用類中的實例成員。