選擇題

1.在使用super和this關鍵字時，在子類構造方法中使用super()顯示呼叫父類的構造方法，super()必須寫在子類構造方法的第一行，否則編譯不通過.
解析：1）呼叫super()必須寫在子類構造方法的第一行，否則編譯不通過。每個子類構造方法的第一條語句，都是隱含地呼叫super()，如果父類沒有這種形式的建構函式，那麼在編譯的時候就會報錯。
2）super()和this()類似,區別是，super從子類中呼叫父類的構造方法，this()在同一類內呼叫其它方法。
3）super()和this()均需放在構造方法內第一行。
4）儘管可以用this呼叫一個構造器，但卻不能呼叫兩個。
5）this和super不能同時出現在一個建構函式裡面，因為this必然會呼叫其它的建構函式，其它的建構函式必然也會有super語句的存在，所以在同一個建構函式裡面有相同的語句，就失去了語句的意義，編譯器也不會通過。
6）this()和super()都指的是物件，所以，均不可以在static環境中使用。包括：static變數,static方法，static語句塊。
7）從本質上講，this是一個指向本物件的指標, 然而super是一個Java關鍵字。
2.已知如下類定義：

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

如下哪句可以正確地加入子類中？（D）
A。private void fun( int n ){ //…}
B。void fun ( int n ){ //… }
C。protected void fun ( int n ) { //… }
D。public void fun ( int n ) { //… }
解析

：方法的重寫（override）兩同兩小一大原則：
方法名相同，引數型別相同
子類返回型別小於等於父類方法返回型別，
子類丟擲異常小於等於父類方法丟擲異常，
子類訪問許可權大於等於父類方法訪問許可權。
3./…/中可以巢狀//註釋，也能巢狀/…/註釋。（錯）
4.假設有以下程式碼String s = “hello”；String t = “hello”；char c [ ] = {‘h’,‘e’,‘l’,‘l’,‘o’}；下列選項中返回false的語句是？（B）
A。s.equals (t)；
B。t.equals ©；
C。s== t；
D。t.equals (new String (“hello”))；
解析：首先 == 與equals是有明顯區別的。
== 強調棧中的比較，可以理解為地址比較
equals強調物件的內容比較
String s=“hello”；會在棧中生成hello字串，並存入字串常量池中。
String t=“hello” ；建立時，會在字串常量池中尋找，當找到需要的hello時，不進行字串的建立，引用已有的。 所以，s== t返回true，s.equals(t)也是true。
char c[]={‘h’,‘e’,‘l’,‘l’,‘o’}; c==s這個是不存在的，==兩邊型別不同
t.equals©這個語句在anObject instanceof String這步判斷不會通過，也就是cha[] 壓根不能與String相比較，型別不是相同的。返回false
5.閱讀下列程式，選擇哪一個是正確的輸出結果（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
解析： 類的初始化順序是： 1、初始化父類中的靜態成員變數和靜態程式碼塊。 2、初始化子類中的靜態成員變數和靜態程式碼塊。 3、初始化父類中的普通成員變數和程式碼塊，在執行父類中的構造方法。 4、初始化子類中的普通成員變數和程式碼塊，在執行子類中的構造方法。
6.關於以下程式程式碼的說明正確的是?

1.   public 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。程式通過編譯，輸出結果為：x=103
B。10行不能通過編譯，因為x是私有靜態變數
C。5行不能通過編譯，因為引用了私有靜態變數
D。程式通過編譯，輸出結果為：x=102
解析：main是HasStatic的靜態方法，在其內部可直接訪問靜態變數，不存在因為私有變數不能通過編譯的問題；如果在其他類中，包括HasStatic的派生類中，均不能訪問其私有靜態變數
7.列舉（enum）屬於原始資料型別（primitive type）。（錯×）
解析：在Java中，變數有兩種型別，一種是原始型別，一種是引用型別。

原始型別一共有8種，它們分別是char,boolean,byte,short,int,long,float,double。在Java API中，有它們對應的包裝類，分別是(首字母大寫)Character,Boolean,Byte,Short,Integer,Long,Float,Double(char,int的變化稍微大點)。

JAVA JVM對於不同的原始型別會分配不同的儲存空間，具體分配如下：

byte : 1個位元組 8位
最大值: 127 (有符號)

short : 2個位元組 16位 32767

int : 4個位元組 32位 2147483647

long: 8個位元組 64位 9223372036854775807

float: 4個位元組 32位 3.4028235E38

double:8個位元組 64位 1.7976931348623157E308

列舉（enum）型別是Java 5新增的特性，它是一種新的型別，允許用常量來表示特定的資料片斷，而且全部都以型別安全的形式來表示，是特殊的類，可以擁有成員變數和方法。
8.下列關於異常處理的描述中，錯誤的是( D )。
A。程式執行時異常由Java虛擬機器自動進行處理
B。使用try-catch-finally語句捕獲異常
C。可使用throw語句丟擲異常
D。捕獲到的異常只能在當前方法中處理，不能在其他方法中處理
解析：執行時異常java虛擬機器會自行處理，只有當是檢查時異常java會強制性丟擲異常，對異常進行處理。

1. 執行型異常由JVM自行處理，程式設計師不需要管。
   檢查型異常由編譯器檢查，需要程式設計師手動捕獲處理。

2. 捕獲到的異常可以選擇在當前方法中處理，也可以在呼叫它的上一級方法中丟擲。

3. 編譯時異常必須顯示處理，執行時異常交給虛擬機器。
   執行時異常可以不處理。當出現這樣的異常時，總是由虛擬機器接管。比如我們從來沒有人去處理過Null Pointer Exception異常，它就是執行時異常，並且這種異常還是最常見的異常之一。出現執行時異常後，系統會把異常一直往上層拋，一直遇到處理程式碼。如果沒有處理塊，到最上層，如果是多執行緒就由Thread.run()丟擲，如果是單執行緒就被main()丟擲。丟擲之後，如果是執行緒，這個執行緒也就退出了。如果是主程式丟擲的異常，整個程式也就退出了。執行時異常是Exception的子類，也有一般異常的特點，是可以被Catch塊處理的。只不過往往不對它處理罷了。也就是說，如果不對執行時異常進行處理，那麼出現執行時異常之後，要麼是執行緒中止，要麼是主程式終止。
   9.以下程式碼執行的結果顯示是多少（ ）？

   public class Demo { class Super{ int flag=1;
   Super(){
   test();
   } void test(){
   System.out.println(“Super.test() flag=”+flag);
   }
   } class Sub extends Super{
   Sub(int i){ flag=i;
   System.out.println(“Sub.Sub()flag=”+flag);
   } void test(){
   System.out.println(“Sub.test()flag=”+flag);
   }
   } public static void main(String[] args) { new Demo().new Sub(5);
   }
   }
   A。 Sub.test() flag=1
   Sub.Sub() flag=5
   B。 Sub.Sub() flag=5
   Sub.test() flag=5
   C。 Sub.test() flag=0
   Sub.Sub() flag=5
   D。 Super.test() flag=1
   Sub.Sub() flag=5
   解析：在繼承中程式碼的執行順序為：1.父類靜態物件，父類靜態程式碼塊
   2.子類靜態物件，子類靜態程式碼塊
   3.父類非靜態物件，父類非靜態程式碼塊
   4.父類建構函式
   5.子類非靜態物件，子類非靜態程式碼塊
   6.子類建構函式
   對於本題來說：在只想new Sub(5)的時候，父類先初始化了 int flag = 1，然後執行父類的建構函式Super（），父類建構函式中執行的test（）方法，因子類是重寫了test（）方法的，因此父類建構函式中的test（）方法實際執行的是子類的test（）方法，所以輸出為Sub.test() flag=1，接著執行子類建構函式Sub(5) 將flag賦值為5，因此輸出結果Sub.Sub() flag=5。最終選擇了A。

10.容器panel預設使用的佈局編輯策略是( B)
A。Border Layout
B。Flow Layout
C。GridLayout
D。Card Layout
解析：系統預設的是流試的FlowLayout的佈局管理器