關於以下application,說法正確是什麼？
public class Test {

static int x=10;
static {x+=5;}
public static void main(String[] args) //4
    {
    System.out.println("x="+x);
}
static{x/=3;};

}//9
正確答案: B 你的答案: D (錯誤)
4行與9行不能通過編譯，因為缺少方法名和返回型別
編譯通過，執行結果是：x=5
編譯通過，執行結果是：x=3
9行不能通過編譯，因為只能有一個靜態初始化器

注：一個靜態程式碼塊在整個程式執行的過程中只執行一次，但一個class可以有多個靜態程式碼塊，且都會被執行。所以此題static{x/=3;};也會執行。

class A{

static {
    System.out.print("--父類靜態程式碼塊--");
}
public A(){
    System.out.print("--父類構造方法--");
}
{
    System.out.print("--父類初始化塊--");
}

}
public class demo8 extends A{

static{
    System.out.print("--子類靜態程式碼塊--");
}
public demo8(){
    System.out.print("--子類構造方法--");
}
{
    System.out.print("--子類初始化塊--");
}
public static void main(String[] args){
    new demo8();
}
 

}
//–父類靜態程式碼塊----子類靜態程式碼塊----父類初始化塊----父類構造方法----子類初始化塊----子類構造方法–
//靜態程式碼塊 優先於 main 優先於 構造程式碼塊 優先於 構造方法

ResultSet中記錄行的第一列索引為？
正確答案: C 你的答案: B (錯誤)
A.-1
B.0
C.1
D.以上都不是
注：**結果集(ResultSet)**是資料中查詢結果返回的一種物件，可以說結果集是一個儲存查詢結果的物件，但是結果集並不僅僅具有儲存的功能，他同時還具有操縱資料的功能，可能完成對資料的更新等。 ResultSet跟普通的陣列不同，索引從1開始而不是從0開始。

假設如下程式碼中，若t1執行緒在t2執行緒啟動之前已經完成啟動。程式碼的輸出是（）
public static void main(String[]args)throws Exception {

final Object obj = new Object();
Thread t1 = new Thread() {
    public void run() {
        synchronized (obj) {
            try {
                obj.wait();
                System.out.println("Thread 1 wake up.");
            } catch (InterruptedException e) {
            }
        }
    }
};
t1.start();
Thread.sleep(1000);//We assume thread 1 must start up within 1 sec.
Thread t2 = new Thread() {
    public void run() {
        synchronized (obj) {
            obj.notifyAll();
            System.out.println("Thread 2 sent notify.");
        }
    }
};
t2.start();

}

正確答案: B 你的答案: C (錯誤)
A.Thread 1 wake up
Thread 2 sent notify.
B.Thread 2 sent notify.
Thread 1 wake up
C.A、B皆有可能
D.程式無輸出卡死
注：**notify()**就是對物件鎖的喚醒操作。但有一點需要注意的是notify()呼叫後，並不是馬上就釋放物件鎖的，而是在相應的synchronized(){}語句塊執行結束，自動釋放鎖後，JVM會在wait()物件鎖的執行緒中隨機選取一執行緒，賦予其物件鎖，喚醒執行緒，繼續執行。這樣就提供了線上程間同步、喚醒的操作。

下列說法正確的是（）
正確答案: A B 你的答案: A D (錯誤)
A.JAVA程式的main方法必須寫在類裡面
B.JAVA程式中可以有多個名字為main方法
C.JAVA程式中類名必須與檔名一樣
D.JAVA程式的main方法中，如果只有一條語句，可以不用{}（大括號）括起來
注：java中可以有多個過載的main方法，只有public static void main(String[] args){}是函式入口。函式都必須用{}括起來，不管是一條語句還是多條語句

Java語言中，如果"xyz"沒有被建立過，String s =new String(“xyz”);建立了幾個string object？
正確答案: B 你的答案: A (錯誤)
A.1
B.2
C.3
D.4
注：字串常量的儲存位置：常量區。可以認為字串的常量區是堆區中一塊特殊的區域。字串常量的特點：同一個名字的字串常量在記憶體中只允許存在一個。（只佔用一塊記憶體）。字串可以看作是一個“物件”（例如String s1 = “1000phone”;格式），該題"xyz"沒有被建立過，所以會新建一個“xyz”物件，所以共建立了兩個String物件。

以下程式輸出結果是什麼？

class A
{
    public static int X;
    static { X = B.Y + 1;}
}
public class B
{
    public static int Y = A.X + 1;
    static {}
    public static void main(String[] args) {
        System.out.println("X = "+A.X+", Y = "+B.Y);
    }
}

注：這個程式能正確執行，類的執行過程如下：首先載入主類B，初始化靜態成員Y，發現需要類A的資訊，於是載入類A，初始化靜態成員X，也用到B類資訊，由於此時B類的Y還未成功載入因此這裡是預設值0，從而得到A類的X為1，然後返回到B類，得到Y為2。

多行註釋中可以巢狀//單行註釋，也能巢狀/**/多行註釋。
正確答案: B 你的答案: A (錯誤)
A.正確
B.錯誤
注：多行註釋中只能包含單行註釋。

Java 的螢幕座標是以畫素為單位，容器的左下角被確定為座標的起點。
正確答案: B 你的答案: A (錯誤)
A.正確
B.錯誤
注：容器的左上角被確定為座標的起點。

如下的Java程式

public class Test { 
     public static void main(String[] args) { 
     System.out.println(args[0]); 
     } 
} 

若採用命令列“java Test one two three”呼叫，則程式輸出的結果為：
正確答案: B 你的答案: D (錯誤)
A.Test
B.one
C.two
D.java
注：採用命令列“ java Test one two three ”呼叫，其中Test為呼叫的方法，而one two three則為Test方法裡面main函式的引數；System.out.println(args[0]);表示輸出第一個元素，故為one。

下列哪個說法是正確的（）
正確答案: D 你的答案: C (錯誤)
A.ConcurrentHashMap使用synchronized關鍵字保證執行緒安全
B.HashMap實現了Collction介面
C.Array.asList方法返回java.util.ArrayList物件
D.SimpleDateFormat是執行緒不安全的
注：選D。

A選項中，ConcurrentHashMap 使用segment來分段和管理鎖，segment繼承自ReentrantLock，因此ConcurrentHashMap使用ReentrantLock來保證執行緒安全。

B中，HashMap定義規則如下：
public class HashMap<K,V>
extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable

C中，應該是Arrays.asList()，其將一個數組轉化為一個List物件，這個方法會返回一個ArrayList型別的物件， 這個ArrayList類並非java.util.ArrayList類，而是Arrays類的私有內部類（java.util.Arrays.ArrayList ）：

下面哪個語句是建立陣列的正確語句？( )
正確答案: A B D E 你的答案: D E (錯誤)
float f[][] = new float[6][6];
float []f[] = new float[6][6];
float f[][] = new float[][6];
float [][]f = new float[6][6];
float [][]f = new float[6][];
注：陣列命名時名稱與[]可以隨意排列，但宣告的二維陣列中第一個中括號中必須要有值，它代表的是在該二維陣列中有多少個一維陣列。

下列程式碼的執行結果是：（ ）

public class Test3{
 public static void main(String args[]){
    System.out.println(100%3);
    System.out.println(100%3.0);
 }
}

正確答案: B 你的答案: B (正確)
A.1和1
B.1和1.0
C.1.0和1
D.1.0和1.0
注：多種混合計算時，自動將所有資料型別轉換為容量最大的一種資料型別。

我們在程式中經常使用“System.out.println()”來輸出資訊，語句中的System是包名，out是類名，println是方法名。（）
正確答案: B 你的答案: A (錯誤)
A.正確
B.錯誤
注：System是java.lang包下的一個類，out為System的final靜態成員（PrintStream型別），println()是PrintStream類的例項方法。java規範中包名一般是小寫的，類名一般是大寫的。

以下程式碼執行後輸出結果為（ ）

public class Test
{
    public static Test t1 = new Test();
    {
         System.out.println("blockA");
    }
    static
    {
        System.out.println("blockB");
    }
    public static void main(String[] args)
    {
        Test t2 = new Test();
    }
 }

正確答案: A 你的答案: C (錯誤)
A. blockAblockBblockA
B. blockAblockAblockB
C. blockBblockBblockA
D. blockBblockAblockB
注：1.首先，需要明白類的載入順序。
(1) 父類靜態物件和靜態程式碼塊
(2) 子類靜態物件和靜態程式碼塊
(3) 父類非靜態物件和非靜態程式碼塊
(4) 父類建構函式
(5) 子類 非靜態物件和非靜態程式碼塊
(6) 子類建構函式
其中：類中靜態塊按照宣告順序執行，並且(1)和(2)不需要呼叫new類例項的時候就執行了(意思就是在類載入到方法區的時候執行的)
2.因而，整體的執行順序為
public static Test t1 = new Test(); //(1)
static
{
System.out.println(“blockB”); //(2)
}
Test t2 =new Test(); //(3)
在執行(1)時建立了一個Test物件，在這個過程中會執行非靜態程式碼塊和預設的無參建構函式，在執行非靜態程式碼塊時就輸出了blockA；然後執行(2)輸出blockB；執行(3)的過程同樣會執行非靜態程式碼塊和預設的無參建構函式，在執行非靜態程式碼塊時輸出blockA。因此，最終的結果為ABA。

下面有關java object預設的基本方法，說法錯誤的是？
正確答案: B 你的答案: D (錯誤)
A.equals(Object obj) 指示某個其他物件是否與此物件“相等”
B.copy() 建立並返回此物件的一個副本
C.wait() 導致當前的執行緒等待，直到其他執行緒呼叫此物件的 notify() 方法或 notifyAll() 方法
D.toString() 返回該物件的字串表示
注：java object預設的基本方法中沒有copy()，含有如下方法：
getClass(), hashCode(), equals(), clone(), toString(), notify(), notifyAll(), wait(), finalize()。
toString雖然預設返回的是物件的包名+類名[email protected]+雜湊碼值的十六進位制，但也是該物件的一種字串形式，原始碼解釋Returns a string representation of the object.

以下程式碼結果是什麼？

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;
	}
}

正確答案: C 你的答案: A (錯誤)
A.程式碼可以編譯執行，輸出“AB.AB”。
B.程式碼可以編譯執行，輸出“A.A”。
C.程式碼可以編譯執行，輸出“AB.B”。
D.程式碼可以編譯執行，輸出“A.B”。
注：
對於append函式而言，修改的是x引用所指向的物件本身，所以無論是a還是x，其引用沒有變化，但指向的值都變成了AB。然而對於y而言，其修改的是引用的值，也就是y這個形參（區域性變數）的引用指向了AB，但對於實參b而言，其指向和指向物件的值都沒有變動，所以仍然是B。

3.Java程式的最小程式單元是( )。
A.類
B.變數
C.物件
D.函式
注：A.類。因為java是面向物件的，所以java的程式必須在類中才能執行，不像C 只有方法就可以。

5.關於異常，下列說法正確的是（C，D）
A.Java中處理異常的方式有捕獲和丟擲兩種
B.一個數除以0，會出現NumberFormatException的異常
C.catch語句的排列，子類在前，父類在後
D.在Java類庫中所有異常都是Throwable的子類。
注：
A錯。可以選擇三種方法來進行異常處理
1對程式碼塊用try…catch進行異常捕獲處理；
2在 該程式碼的方法體外用throws進行丟擲宣告，告知此方法的呼叫者這段程式碼可能會出現這些異常，你需要謹慎處理。此時有兩種情況：
　　　　如果宣告丟擲的異常是非執行時異常，此方法的呼叫者必須顯示地用try…catch塊進行捕獲或者繼續向上層丟擲異常。
　　　　如果宣告丟擲的異常是執行時異常，此方法的呼叫者可以選擇地進行異常捕獲處理。
3在程式碼塊用throw手動丟擲一個異常物件，此時也有兩種情況，跟2）中的類似。
B錯， java.lang.ArithmeticException: / by zero
D正確，

2.(F)能作為類的訪問許可權修飾符的只有public和default。
注：內部類可以用protected, private。

如果一個介面Cup有個方法use()，有個類SmallCup實現介面Cup，則在類SmallCup中正確的是？ ( )
正確答案: C 你的答案: D (錯誤)
A.void use() { …}
B.protected void use() { …}
C.public void use() { …}
D.以上語句都可以用在類SmallCup中
注：然是實現介面，就要實現介面的所以方法，相當於重寫方法，方法的重寫需要滿足：三同一大一小（方法名、返回值型別、形參相同；訪問許可權>=重寫前；丟擲異常<=重寫前）。介面中每一個方法也是隱式抽象的,介面中的方法會被隱式的指定為 public abstract。所以重寫介面中的方法，訪問許可權一定是public。

What is the result of compiling and executing the following fragment of code:

Boolean flag = false;
if (flag = true)
{
    System.out.println(“true”);
}
else
{
    System.out.println(“false”);
}

正確答案: C 你的答案: D (錯誤)
A.The code fails to compile at the “if” statement.
B.An exception is thrown at run-time at the “if” statement.
C.The text“true” is displayed.
D.The text“false”is displayed.
E.Nothing is displayed.
注：賦值語句會有返回值，返回值為你所賦的值，flag = true運算後的返回值為true，所以此題中 if (flag = true)相當於if(true)。