1. 下面的程序 编译运行后，在屏幕上显示的结果是（A）

public class test {
public static void main(String args[]) {
int x,y;
x=5>>2;
y=x>>>2;
System.out.println(y);
}
}

A、 0
B 、2
C 、5
D 、80

解析：
Java中的位运算符： **> >**表示右移，如果该数为正，则高位补0，若为负数，则高位补1。
**>>>**表示无符号右移，也叫逻辑右移，即若该数为正，则高位补0，而若该数为负数，则右移后高位同样补0。

2. 以下代码结果是什么？（C）

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

A 代码可以编译运行，输出“AB.AB”。
B 代码可以编译运行，输出“A.A”。
C 代码可以编译运行，输出“AB.B”。
D 代码可以编译运行，输出“A.B”。

解析：
引用a指向对象A
引用b指向对象B
引用x指向对象A
引用y指向对象B
在operate方法中，引用x指向的对象A被连接了B，对象A也就被改变为AB
然后又把引用y指向了x所指向的对象地址，也就是此时引用a,x,y指向同一个对象AB
而引用b没有发生任何变化，依旧指向对象B。

3. 在JAVA中，假设A有构造方法A(int a)，则在类A的其他构造方法中调用该构造方法和语句格式应该为（B）
   A、 this.A(x)
   B 、this(x)
   C 、super(x)
   D 、A(x)

解析：
this的作用其中一个就是在一个构造方法中调用另一个构造方法，格式为this(参数)；
super是调用父类的方法；
A(a)这种形式是在new一个类时使用

4. 下面代码的运行结果是（C）

public static void main(String[] args){
String s;
System.out.println("s="+s);
}

A 代码编程成功，并输出”s=”
B 代码编译成功，并输出”s=null”
C 由于String s没有初始化，代码不能编译通过。
D 代码编译成功，但捕获到NullPointException异常

解析
局部变量没有默认值

5. 装箱、拆箱操作发生在: ©
   A 、类与对象之间
   B 、对象与对象之间
   C 、引用类型与值类型之间
   D 、引用类型与引用类型之间

解析:
基本数据类型和包装类之间的转换。如： int 类型和 Integer 类的转换
基本数据类型转化成包装类是装箱 (如： int --> Integer)。
包装类转化成基本数据类型就是拆箱 (如：Integer --> int)。
包装类就是引用类型，基本数据类型就是值类型。

6. 一个以”.java”为后缀的源文件©
   A 、只能包含一个类，类名必须与文件名相同
   B 、只能包含与文件名相同的类以及其中的内部类
   C 、只能有一个与文件名相同的public类，可以包含其他类
   D 、可以包含任意类

解析：
.java文件可以包含多个类，唯一的限制就是：一个文件中只能有一个public类， 并且此public类必须与文件名相同。而且这些类和写在多个文件中没有区别。

7. 下列哪个说法是正确的（D）
   A 、ConcurrentHashMap使用synchronized关键字保证线程安全
   B 、HashMap实现了Collction接口
   C 、Array.asList方法返回java.util.ArrayList对象
   D 、SimpleDateFormat是线程不安全的

解析：
A，ConcurrentHashMap，JDK1.7的时候，是利用Segment这个数据结构，锁分段技术保证的。JDK1.8之后用的是synchronized+CAS。Segment这个数据结构也废了，和HashMap一样了，数据+链表+红黑树。
B，Map和Collcetion没关系
C，Arrays.asList返回的是Arrays中一个内部类，也叫ArrayList，也实现了List接口。一旦对这个List做出结构性的改变，会出现异常。
D，DateFormat中的子类中线程都是不安全的

8. 以下说法错误的是（D）
   A 虚拟机中没有泛型，只有普通类和普通方法
   B 所有泛型类的类型参数在编译时都会被擦除
   C 创建泛型对象时请指明类型，让编译器尽早的做参数检查
   D 泛型的类型擦除机制意味着不能在运行时动态获取List中T的实际类型

解析：
1、创建泛型对象的时候，一定要指出类型变量T的具体类型。争取让编译器检查出错误，而不是留给JVM运行的时候抛出类不匹配的异常。 2、JVM如何理解泛型概念 —— 类型擦除。事实上，JVM并不知道泛型，所有的泛型在编译阶段就已经被处理成了普通类和方法。 处理方法很简单，我们叫做类型变量T的擦除(erased) 。 总结：泛型代码与JVM ① 虚拟机中没有泛型，只有普通类和方法。 ② 在编译阶段，所有泛型类的类型参数都会被Object或者它们的限定边界来替换。(类型擦除) ③ 在继承泛型类型的时候，桥方法的合成是为了避免类型变量擦除所带来的多态灾难。 无论我们如何定义一个泛型类型，相应的都会有一个原始类型被自动提供。原始类型的名字就是擦除类型参数的泛型类型的名字。

9. 下列代码执行结果为（A）

public static void main(String args[])throws InterruptedException{
Thread t=new Thread(new Runnable() {
public void run() {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.print("2");
}
});
t.start();
t.join();
System.out.print("1");
}

A 21
B 12
C 可能为12，也可能为21
D 以上答案都不对

解析：
join()的作用是：“等待该线程终止”，这里需要理解的就是该线程是指的主线程等待子线程的终止。也就是在子线程调用了join()方法后面的代码，只有等到子线程结束了才能执行。

10. 指出以下程序运行的结果是（B）

public class Example{
String str=new String("good");
char[]ch={'a','b','c'};
public static void main(String args[]){
Example ex=new Example();
ex.change(ex.str,ex.ch);
System.out.print(ex.str+" and ");
System.out.print(ex.ch);
}
public void change(String str,char ch[]){
//引用类型变量，传递的是地址，属于引用传递。
str="test ok";
ch[0]='g';
}
}

A、good and abc
B、good and gbc
C、test ok and abc
D、test ok and gbc

解析：
char数组和String都是引用类型，所以调用change(String str,char ch[])方法时传入的是引用，该方法中str原来指向的是的“good”串的地址，str="test ok"语句让str生成了“test ok”串并指向了“test ok”串的地址，而原来的“good”串是原地不动的；ch是字符数组的首地址，ch[0]='g’语句把这个字符数组的第0个位置改为g。因此当change方法返回后，ex.str 打印出来的依旧是“good”串，因为对象 ex的str指向的地址并未改变；对象ex的ch指向的地址也没改变，但是它指向的地址中保存的内容已经发生了改变。