Sun考試認證題目解析（強力推薦，鞏固基礎）

轉載請註明出處：http://www.ming-yue.cn/java-basic/。

1，給定如下代碼，求j的值。

public class Test {
	public static void main(String[] args) throws Exception {
		int i = 0xFFFFFFF1;
		int j = ~i;
	}
}

A. 0 B. 1 C. 14 D. –15 E. An error at line 3 causes compilation to fail. F. An error at line 4 causes compilation to fail.

答案：C

解析：本題是考察進制，原碼補碼，非操做等知識。首先，0xFFFFFFF1是16進制，F用二進制表示爲1111，因此整個i用二進制表示爲11111111111111111111111111110001，因爲j是~i（即0變1,1變0），表示j是00000000000000000000000000001110，因此變成了j的值是1110，便可求得j=14.此處若再加一個要求，求i的值。則因爲計算機中存儲的都是補碼，第一位是符號位，轉換成原碼的方式是：其他位取反，最後加1，因此求得i的值是100000000000000000000000000001111,1表示負號，因此i=-15.

2，給定如下代碼，選出下面爲true的選項：

Integer i = new Integer (42);
Long 1 = new Long (42);
Double d = new Double (42.0);

A. (i ==1) B. (i == d) C. (d == 1) D. (i.equals (d)) E. (d.equals (i)) F. (i.equals (42))

答案：F

解析：i，l，d因爲類型不一樣，所以ABC沒法經過編譯。DE選項返回false，能經過編譯，可是二者對象類型不一樣，返回false。F選項在java5以後增長了自動裝箱的功能，因此F爲true。題目答案給的是DE，多是版本比較舊。再也不過多琢磨了。

3，求出下面程序的輸出結果：

public class test {
	private static int j = 0;

	private static boolean methodB(int k) {
 		j += k;
		return true;
	}

 	public static void methodA(int i) {
		boolean b:
		b = i < 10 | methodB (4);
		b = i < 10 || methodB (8);
	}

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

A. The program prints 「0」 B. The program prints 「4」 C. The program prints 「8」 D. The program prints 「12」 E. The code does not complete.

答案：B

解析：本題考察的是與或非以及邏輯運算符的使用。首先要明確，&和|以及~是位運算符，而||和&&是邏輯運算符。位運算符所有參與計算，而邏輯運算符存在短路的狀況。下面引用一段解釋：因爲&& 要求它的參與操做的兩個操做數都是布爾值真，才得真，因此只要得出其中一個爲假，那麼另外一部分的表達式就不會被求值。 同理因爲||要求它的參與操做的兩個操做數只要其中之一爲真，就得真，因此只要得出其中一個爲真，那麼另外一部分也不會被求值（在上面的例子中是methodB (8)不會被調用）。這就是邏輯操做符所謂的「短路求值」。

位操做沒有這一特性，因此無論那邊的值是如何，任何參與運算的表達式都會被執行求值，因此methodB(4)執行。

4，求出下面的輸出結果：

public class test {
	public static void main (String args[]) {
		System.out.println (6 ^ 3);
 	}
}

答案：5

解析：考察^操做符。^指的是按位異或操做。即兩個二進制數按位進行異或，相同的值爲0，不一樣的值爲1。因此6的二進制爲0110,3的二進制爲0011，因此異或以後爲0101，值爲5。

5，下面程序的輸出結果是：

public class Foo {
	public static void main (String [] args) {
		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. The code compiles and prints 「A,B」. B. The code compiles and prints 「A,A」. C. The code compiles and prints 「B,B」. D. The code compiles and prints 「AB,B」. E. The code compiles and prints 「AB,AB」. F. The code does not compile because 「+」 cannot be overloaded for StringBuffer

答案：D

解析：本題考察StringBuffer以及函數傳遞參數等問題，下面談一下個人理解，不敢保證所有正確。首先，a，b分別指向A和B的地址，其對應的內容是A和B，調用operate函數時，將a，b的引用傳遞給x，y，也就是說x，y分別複製了a，b的引用，如今ｘ，ｙ分別指向Ａ和Ｂ。當x執行append操做時，因爲StringBuffer的特性，這裏的內容變成了ＡＢ，也就是說這個時候x和a所指向內存的內容都是AB，而ｙ＝＝ｘ表示的是讓ｙ一樣指向ｘ指向的內容，即如今ｙ指向的也是ＡＢ，可是ｂ並無改變，因此ｂ的值仍是Ｂ。還有困惑的能夠參考這裏：http://blog.csdn.net/xia7139/article/details/8783066。

６，下面的程序輸出什麼？

public class Test {
	public static void main(String[] args) {
		StringBuffer aBuffer = new StringBuffer("java");
		String bString = new String("java");
		stringReplace(bString);
		bufferReplace(aBuffer);
		System.out.println(bString+aBuffer);
		
	}
	public static void stringReplace(String string){
		string = string.replace("j", "i");
	}
	public static void bufferReplace(StringBuffer buffer){
		buffer = buffer.append("C");
	}
}

答案：javajavaC

解析：本題考察String和StringBuffer的用法。定義一個String對象的時候會有個「池」的概念，也就是說String a = "abc"；String b = "abc"；這裏表示，a和b指向的是一塊地址，定義b後發現string池中已有如今的對象，因此直接用，若是這時候用equal和==比較，兩者都是true。可是若是是String c = new String（"abc"）；則a，b和c用equal是true，用==是false。由於c指向了不一樣的地址，可是內容相同。

而StringBuffer不一樣。StringBuffer指向的始終不變，經過append操做改變內容，不會產生新的對象，因此StringBuffer比String快。

因此上題很好解釋了，bString指向的是一塊地址B，而stringReplace函數只是改變了新的引用string的內容，對bString沒有改變。而aBuffer經過append改變了本身指向的內容，因此其內容也會跟着變化。

7，如下哪一個輸出結果是正確的？

public class Test {
	public static void main(String[] args) {
		Integer n = new Integer(0);
		add3(n);
		System.out.println(n);
		
	}
	public static void add3(Integer i){
		int a = i.intValue();
		a = a+3;
		i = new Integer(a);
	}
}

A. Compilation will fail. B. The program prints 「0」. C. The program prints 「3」. D. Compilation will succeed but an exception will be thrown at line 3.

答案：B

解析：Integer是對象，int是實數，因此當add3函數改變i引用指向的內容時，原始的n並無改變，其內容依然是0。

8，選出正確的重載構造函數

public class ConstOver {
	public ConstOver (int x, int y, int z) {
	}
}

A. ConstOver ( ) { }

B. Protected int ConstOver ( ) { }

C. Private ConstOver (int z, int y, byte x) { }

D. Public Object ConstOver (int x, int y, int z) { }

E. Public void ConstOver (byte x, byte y, byte z) { }

答案：AC

解析：構造函數：能夠用public，private，protected修飾，但不能有返回類型，或者void修飾。重載表示函數名相同，可是參數或類型必定不一樣。

9，選出正確的重載函數：

public class MethodOver {
	public void setVar (int a, int b, float c) {
	}
}

A. Private void setVar (int a, float c, int b) { }

B. Protected void setVar (int a, int b, float c) { }

C. Public int setVar (int a, float c, int b) (return a;)

D. Public int setVar (int a, int b, float c) (return a;)

E. Protected float setVar (int a, int b, float c) (return c;)

答案：AC

解析：謹記重載的含義，函數名必定相同，參數或者類型不一樣。

10，選出下面覆蓋getVar（）的方法：

class BaseClass {
	private float x = 1.0f ;
	protected float getVar ( ) { return x;}
}
class Subclass extends BaseClass {
	private float x = 2.0f;
	//insert code here
}

A. Float getVar ( ) { return x;}

B. Public float getVar ( ) { return x;}

C. Float double getVar ( ) { return x;}

D. Public float getVar ( ) { return x;}

E. Public float getVar (float f ) { return f;}

答案：BD

解析：覆蓋（overriding）指的是函數名和參數要和原方法相同，只是具體的實現細節不一樣。

——————————————————2015.5.13————————————————

11，待續。