通過SUN任何一門專業認證後，考生將收到SunMicrosystems總公司寄發的資格證書及徽章，並有權將通過Sun認證的標記印在個人名片上，作為個人技術能力的肯定。那麼你準備好考sun認證了嗎?下面跟yjbys小編一起來看看吧!
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. (ls (d)) E. (ls (i)) F. (ls (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);
tln(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[]) {
tln (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);
tln{a + “,” +b};
}
static void operate (StringBuffer x, StringBuffer y) {
nd {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，y分別指向A和B。當x執行append操作時，由於StringBuffer的特性，這裡的內容變成了AB，也就是說這個時候x和a所指向記憶體的內容都是AB，而y==x表示的是讓y同樣指向x指向的內容，即現在y指向的也是AB，但是b並沒有改變，所以b的值還是B。還有困惑的可以參考這裡：。
6，下面的程式輸出什麼?
public class Test {
public static void main(String[] args) {
StringBuffer aBuffer = new StringBuffer("java");
String bString = new String("java");
stringReplace(bString);
bufferReplace(aBuffer);
tln(bString+aBuffer);
}
public static void stringReplace(String string){
string = ace("j", "i");
}
public static void bufferReplace(StringBuffer buffer){
buffer = nd("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);
tln(n);
}
public static void add3(Integer i){
int a = alue();
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)指的是函式名和引數要和原方法相同，只是具體的實現細節不同。
