1、在 Java 中，存放字符串常量的對象屬于（ ）類對象。B

A Character B String C StringBuffer D Vector

2、已知如下類定義： 如下哪句可以正確地加入子類中？D

class Base { public Base (){ //... } public Base ( int m ){ //... } public void fun( int n ){ //... } } public class Child extends Base{ // member methods }

A private void fun( int n ){ //...}

B void fun ( int n ){ //... }

C protected void fun ( int n ) { //... }

D public void fun ( int n ) { //... }

重寫

方法名、參數、返回值相同。

子類方法不能縮小父類方法的訪問權限。

子類方法不能拋出比父類方法更多的異常(但子類方法可以不拋出異常)。

存在于父類和子類之間。

方法被定義為final不能被重寫。

重載

參數類型、個數、順序至少有一個不相同。

不能重載只有返回值不同的方法名。

存在于父類和子類、同類中。

3、面向對象基本方法的基本概念有對象、類和實例、消息、繼承與多態性

4、成員變量和局部變量的區別：

成員變量：

成員變量定義在類中，在整個類中都可以被訪問。

成員變量隨著對象的建立而建立，隨著對象的消失而消失，存在于對象所在的堆內存中。

成員變量有默認初始化值。

局部變量：

局部變量只定義在局部范圍內，如：函數內，語句內等，只在所屬的區域有效。

局部變量存在于棧內存中，作用的范圍結束，變量空間會自動釋放。

局部變量沒有默認初始化值?

成員變量和類變量的區別：

1.兩個變量的生命周期不同

? ??? 成員變量隨著對象的創建而存在，隨著對象的回收而釋放。

? ? ? 靜態變量隨著類的加載而存在，隨著類的消失而消失。

2.調用方式不同

? ? ? 成員變量只能被對象調用。

? ? ? 靜態變量可以被對象調用，還可以被類名調用。

3.別名不同

? ??? 成員變量也稱為實例變量。

? ? ? 靜態變量也稱為類變量。

4.數據存儲位置不同

? ? ? 成員變量存儲在堆內存的對象中，所以也叫對象的特有數據。

? ? ? 靜態變量數據存儲在方法區（共享數據區）的靜態區，所以也叫對象的共享數據。

成員變量和靜態變量的區別：

?? 1.成員變量所屬于對象。所以也稱為實例變量。

????? 靜態變量所屬于類。所以也稱為類變量。

?? 2.成員變量存在于堆內存中。

????? 靜態變量存在于方法區中。

?? 3.成員變量隨著對象創建而存在。隨著對象被回收而消失。

????? 靜態變量隨著類的加載而存在。隨著類的消失而消失。

?? 4.成員變量只能被對象所調用?。

????? 靜態變量可以被對象調用，也可以被類名調用。

5、Java提供了4種訪問控制符，主要用于控制其他類是否可以訪問某一類中的屬性或方法，從而實現數據封裝。

四種訪問控制符的權限大小(由大到小)為public(公共)、protected(保護)、default(默認)、 private(私有)。

private(私有)：當類中屬性或方法被private修飾時，表示此成員或方法只能被自己類中的方法使用，而不能被外部類或對象直接使用。

default(默認)：具有包訪問權限，如果類中屬性或方法不使用public,protected,privete修飾符修飾時，則說明其具有包訪問權限，具有包訪問權限的屬性或方法既可以被自己類中的方法使用也可以被同一包下的其他類使用，但不能被其他包中的類使用。

protected(保護)：具有子類訪問權限。如果類中屬性或方法被protected修飾符修飾，則此類中屬性或方法可以被同一包下的類使用，也可以被不同包下的子類使用，但不能被不同包下的其他類使用。

public(公共)：具有公共訪問權限。如果類中的屬性或方法被public修飾，則此類中的屬性或方法可以被任何類調用。

6、假設 A 類有如下定義，設 a 是 A 類的一個實例，下列語句調用哪個是錯誤的？（）C

public class A {public int i;static String s;void method1(){}static void method2(){} }

A System.out.println(a.i); B a.method1(); C A.method1(); D A.method2();

static關鍵詞修飾的變量或方法可以通過類名直接調用，而非靜態的變量或方法無法通過類名直接調用。?

?7、下面代碼將輸出什么內容：（）B

public class SystemUtil{public static boolean isAdmin(String userId){return userId.toLowerCase()=="admin";}public static void main(String[] args){System.out.println(isAdmin("Admin"));} }

A true B false C 1 D 編譯錯誤

對于兩個引用變量，只有他們指向同一個引用時，==才會返回true。題目中"admin"指向堆內存字符串常量池里admin的地址，而String類 的方法都是通過創建新的對象也就是new String()的方式返回的，因此userId.toLowerCase()指向的是這個字符串對象在堆內存中的地址。如果題目中isAdmin方 法返回值更改為`return userId.toLowerCase().equals("admin");`，輸出結果將變為true。?

8、在子類構造方法中使用super（）顯示調用父類的構造方法，super（）必須寫在子類構造方法的第一行，否則編譯不通過

9、如下代碼的 結果是什么 ?? ? ? ? B

class Base {Base() {System.out.print("Base");} } public class Alpha extends Base {public static void main( String[] args ) {new Alpha();//調用父類無參的構造方法new Base();} }

A Base B BaseBase C 編譯失敗 D 代碼運行但沒有輸出 E 運行時拋出異常?

10、下列哪一種敘述是正確的（）D

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

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

C 聲明抽象方法，大括號可有可無

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

A：abstract只能修飾方法和類，變成抽象方法和抽象類，不能修飾字段。
B：既然是抽象方法，也就是沒有具體的實現方法，所以根本沒有body部分。
C：不能有大括號，有大括號就相當于有了具體的實現方法，有了實現方法就不能說是抽象類了。
D：抽象方法不能寫出大括號。

11、以下代碼運行輸出的是??C

public class Person{private String name = "Person";int age=0; } public class Child extends Person{public String grade;public static void main(String[] args){Person p = new Child();System.out.println(p.name);} }

A 輸出：Person B 沒有輸出 C 編譯出錯 D 運行出錯?

父類private的成員變量，根據權限修飾符的訪問控制范圍，只有在類內部才能被訪問，就算是他的子類，也不能訪問。這里如果將Person p = new Child();改成 Person p = new Person();代碼依然無法通過編譯，因為子類作用域中訪問不到父類的私有變量，無法為其生成正確的字節碼。另外，一個Java文件中不能有兩 個public類。?

12、以下程序的輸出結果為 D

class Base{public Base(String s){System.out.print("B");} } public class Derived extends Base{public Derived (String s) {System.out.print("D");}public static void main(String[] args){new Derived("C");} }

A.BD B.DB C.C D.編譯錯誤?

在調用子類構造器之前，會先調用父類構造器，當子類構造器中沒有使用"super(參數或無參數)"指定調用父類構造器時，是默認調用父類的無參構造器，如果父類中包含有參構造器，卻沒有無參構造器，則在子類構造器中一定要使用“super(參數)”指定調用父類的有參構造器，不然就會報錯。?

13、下列描述中，錯誤的是 C

A SQL語言又稱為結構化查詢語言

B java中”static”關鍵字表明一個成員變量或者是成員方法可以在沒有所屬的類的實例變量的情況下被訪問

C 面向對象開發中，引用傳遞意味著傳遞的并不是實際的對象，而是對象的引用，因此，外部對引用對象所做的改變不會反映到所引用的對象上

D java是強類型語言，javascript是弱類型語言 E 面向對象的三大特性包括：封裝，繼承，多態?

外部對引用對象所做的改變會反映到所引用的對象上

14、程序讀入用戶輸入的一個值，要求創建一個自定義的異常，如果輸入值大于 10 ，使用 throw 語句顯式地引發異常，異常輸出信息為 ”something’swrong!” ， 語句為（）A

A if(i>10)throw new Exception("something’swrong!");

B if(i>10)throw Exception e("something’swrong!");

C if(i>10) throw new Exception e("something’swrong!");

D if(i>10)throw Exception( "something’swrong!");

15、?類所實現的接口以及修飾不可以是（）。D

A void B public C abstract D final

16、?以下代碼結果是什么？C

public class foo {public static void main(String sgf[]) {StringBuffer a=new StringBuffer("A");StringBuffer b=new StringBuffer("B");operate(a,b);System.out.println(a+"."+b);}static void operate(StringBuffer x,StringBuffer y) {x.append(y);y=x;} }

A 代碼可以編譯運行，輸出“AB.AB”。

B 代碼可以編譯運行，輸出“A.A”。

C 代碼可以編譯運行，輸出“AB.B”。

D 代碼可以編譯運行，輸出“A.B”。

關于值傳遞和引用傳遞的解釋如下：

值傳遞：是指在調用函數時將實際參數復制一份傳遞到函數中，這樣在函數中如果對參數進行修改，將不會影響到實際參數。 引用傳遞：是指在調用函數時將實際參數的地址直接傳遞到函數中，那么在函數中對參數所進行的修改，將影響到實際參數。 這道題中a、b（是引用的副本，Java中沒有引用傳遞）傳入operate()函數中，但最后a指向的對象的值發生了變化，而b指向的對象的值沒有發生變化，這是因 為x.append(y);改變了a指向的對象的值，而y=x;并沒有改變b指向對象的值，指向將y指向了x所指向的對象（之前y和b指向同一個對象）。?

?17、下列有關JAVA異常處理的敘述中正確的是（）A B D

A finally是為確保一段代碼不管是否捕獲異常都會被執行的一段代碼

B throws是用來聲明一個成員方法可能拋出的各種非運行異常情況

C final用于可以聲明屬性和方法，分別表示屬性的不可變及方法的不可繼承

D throw是用來明確地拋出一個異常情況

final用于可以聲明屬性和方法，分別表示屬性的不可變及方法的不能被重寫

18、?關于抽象類與最終類，下列說法錯誤的是？D

A 抽象類能被繼承，最終類只能被實例化。

B 抽象類和最終類都可以被聲明使用

C 抽象類中可以沒有抽象方法，最終類中可以沒有最終方法

D 抽象類和最終類被繼承時，方法可以被子類覆蓋

final修飾的類不能被繼承?

19、閱讀下列程序，選擇哪一個是正確的輸出結果 C

class HelloA{public HelloA(){System.out.println("I’m A class ");}static{System.out.println("static A");} } public class HelloB extends HelloA{public HelloB(){System.out.println("I’m B class");}static{System.out.println("static B");}public static void main (String[] args){new HelloB();} }

A static A I’m A class static B I’m B class

B I’m A class I’m B class static A static B

C static A static B I’m A class I’m B class

D I’m A class static A I’m B class static B

Java類初始化順序：父類靜態變量---> 父類靜態代碼塊---> 子類靜態代碼塊---> 父類非靜態代碼塊 --->父類構造函數 --->子類非靜態代變量 --->子類非靜態代碼塊---> 子類構造器

20、?下列代碼的輸出結果是_____ B

boolean b=true ? false : true==true?false:true; System.out.println(b)

A true B false C null D 空字符串

21、?在Java中下面Class的聲明哪些是錯誤的？A B C

A public abstract final class Test { abstract void method(); }

B public abstract class Test { abstract final void method(); }

C public abstract class Test { abstract void method() { } }?

D public class Test { final void method() { } }

1、抽象類不能被實例化，實例化的工作應該交由它的子類來完成，它只需要有一個引用即可。

2、抽象方法必須由子類來進行重寫。

3、只要包含一個抽象方法的類，該類必須要定義成抽象類，不管是否還包含有其他方法。

4、抽象類中可以包含具體的方法，當然也可以不包含抽象方法。

5、abstract不能與final并列修飾同一個類。

6、abstract 不能與private、static、final或native并列修飾同一個方法。

22、關于以下程序代碼的說明正確的 D

class HasStatic{private static int x = 100;public static void main(String args[ ]){HasStatic hs1 = new HasStatic();hs1.x++;HasStatic hs2 = new HasStatic();hs2.x++;hs1=new HasStatic();hs1.x++;HasStatic.x--;System.out.println( "x=" +x);} }

A 5行不能通過編譯，因為引用了私有靜態變量

B 10行不能通過編譯，因為x是私有靜態變量

C 程序通過編譯，輸出結果為：x=103

D 程序通過編譯，輸出結果為：x=102?

當static作用于某個字段時，肯定會改變數據創建的方式（因為一個static字段對每個類來說都只有一份儲存空間，而非static字段則是對每個對象有一個儲存空間）；
所以無論是HasStatic類的對象hs1,hs2，或是直接通過類名修改static作用的字段，都是一個，因此選擇D?

23、java 語言使用的字符碼集是 D

A.ASCII B.BCD C.DCB D.Unicode

24、?Test.main() 函數執行后的輸出是（）D

public class Test {public static void main(String [] args){System.out.println(new B().getValue());}static class A{protected int value;public A(int v) {setValue(v);}public void setValue(int value){this.value = value;}public int getValue(){try{value++;return value;} catch(Exception e){System.out.println(e.toString());} finally {this.setValue(value);System.out.println(value);}return value;}}static class B extends A{public B() {super(5);setValue(getValue() - 3);}public void setValue(int value){super.setValue(2 * value);}} }

?A 11 17 34

B 22 74 74

C 6 7 7

D 22 34 17

首先，super()函數指的是調用父類的構造方法

1.new B()

執行B的構造函數，第一行是super(5);

此時執行的是A的構造函數，A的構造函數調用的是setValue()方法，由于B重寫了A的這個方法，

所以，執行的是B的 setValue()方法。即傳入的參數是2*5=10

此時，因為super，所以調用的是父類的 setValue()方法，即value=10

第一行執行完畢。

第二行是 setValue(getValue()-3);

B沒有getValue()方法，故執行父類的此方法，

try返回的是value=10+1=11，保存在臨時棧中

finally中調用this的方法，這個this指的是B的對象，又重寫，故就是B的 setValue()方法

value=2*11=22，第一個打印到屏幕上的數字

接下來參數 getValue()-3=11-3=8

傳入B的 setValue()方法

此時value=2*8=16

至此，new B()執行結束

2.new B(). getValue()

B沒有 getValue()，故執行A的 getValue()

try返回16+1=17，保存到臨時棧中

finally調用B的 setValue()方法，value=17*2=34，第二個打印到屏幕上面的數字

最后主函數打印返回值，也就是try保存到臨時棧的17

25、JAVA語言的下面幾種數組復制方法中，哪個效率最高？B

A for循環逐一復制 B System.arraycopy C Arrays.copyOf D 使用clone方法

效率：System.arraycopy > clone > Arrays.copyOf > for循環?

26、?有關下述Java代碼描述正確的選項是____。F

public class TestClass {private static void testMethod(){System.out.println("testMethod");}public static void main(String[] args) {((TestClass)null).testMethod();} }

A 編譯不通過

B 編譯通過，運行異常，報NullPointerException

C 編譯通過，運行異常，報IllegalArgumentException

D 編譯通過，運行異常，報NoSuchMethodException

E 編譯通過，運行異常，報Exception

F 運行正常，輸出testMethod

雖然我們能用對象來調用靜態方法，但是對于java來說，即使我們用對象去調用，java自己也會在將源文件編譯成class文件時將其轉化為用類名去調用靜態方法。由于空指針異常是運行時異常，所以eclipse編譯檢查也不會報錯，而實際運行的是class文件，java已經將class文件里的調用修改為類名去調用了，所以也就不會在運行時出現空指針異常。?

27、?下面代碼運行結果是（）C

public class Test{public int add(int a,int b){try {return a+b;}catch (Exception e) {System.out.println("catch語句塊");}finally{System.out.println("finally語句塊");}return 0;}public static void main(String argv[]){Test test =new Test();System.out.println("和是："+test.add(9, 34));} }

A catch語句塊 和是：43

B 編譯異常

C finally語句塊 和是：43

D 和是：43 finally語句塊

1、不管有木有出現異常，finally塊中代碼都會執行；
2、當try和catch中有return時，finally仍然會執行；
3、finally是在return后面的表達式運算后執行的（此時并沒有返回運算后的值，而是先把要返回的值保存起來，管finally中的代碼怎么樣，返回的值都不會改變，任然是之前保存的值），所以函數返回值是在finally執行前確定的；
4、finally中最好不要包含return，否則程序會提前退出，返回值不是try或catch中保存的返回值?

28、?下列Java代碼中的變量a、b、c分別在內存的____存儲區存放。C

class A {private String a = “aa”;public boolean methodB() {String b = “bb”;final String c = “cc”;} }

A 堆區、堆區、堆區

B 堆區、棧區、堆區

C 堆區、棧區、棧區

D 堆區、堆區、棧區

E 靜態區、棧區、堆區

F 靜態區、棧區、棧區

常量池：未經 new 的常量

堆區：成員變量的引用，new 出來的變量

棧區：局部變量的引用

成員變量的引用在堆區，是因為成員變量的所屬對象在堆區，所以它也在堆區。

局部變量的引用在棧區，是因為局部變量不屬于某一個對象，在被調用時才被加載，所以在棧區。

29、下面代碼的輸出結果是什么？D

public class ZeroTest {public static void main(String[] args) {try{int i = 100 / 0;System.out.print(i);}catch(Exception e){System.out.print(1);throw new RuntimeException();}finally{System.out.print(2);}System.out.print(3);} }

A.3 B.123 C.1 D.12

try catch是直接處理，處理完成之后程序繼續往下執行，throw則是將異常拋給它的上一級處理，程序便不往下執行了。本題的catch語句塊里面，打印完1之后，又拋出了一個RuntimeException，程序并沒有處理它，而是直接拋出，因此執行完finally語句塊之后，程序終止了?

30、?代碼片段： 關于上面代碼片段敘述正確的是（）C

byte b1=1,b2=2,b3,b6; final byte b4=4,b5=6; b6=b4+b5; b3=(b1+b2); System.out.println(b3+b6);

A 輸出結果：13

B 語句：b6=b4+b5編譯出錯

C 語句：b3=b1+b2編譯出錯

D 運行期拋出異常

被final修飾的變量是常量，這里的b6=b4+b5可以看成是b6=10；在編譯時就已經變為b6=10了

而b1和b2是byte類型，java中進行計算時候將他們提升為int類型，再進行計算，b1+b2計算后已經是int類型，賦值給b3，b3是byte類型，類型不匹配，編譯不會通過，需要進行強制轉換。

Java中的byte，short，char進行計算時都會提升為int類型。

?

總結

以上是生活随笔為你收集整理的JavaseSE笔试选择题（知识点总结）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。