标签：
转载请注明出处：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用二进制表示为11111111111111111111111111111000，由于j是~i（即0变1,1变0），表示j是00000000000000000000000000000111，所以变成了j的值是0111，即可求得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，待续。
标签：
原文地址：http://my.oschina.net/u/181485/blog/414333
