int i=5; int s=(i++)+(++i)+(i–)+(–i); s=( )//s 的值是什么？
A 28 B 25 C 21 D 26 E 24 F 23
正确答案： E
5+7+7+5 = 24
++ 或者 --在后先不变化数值 ++ -- 在前先变化再运算
以下哪项不属于java类加载过程？
A 生成java.lang.Class对象
B int类型对象成员变量赋予默认值
C 执行static块代码
D 类方法解析
他的回答： B (正确)
正确答案： B
类加载过程：
1， JVM会先去方法区中找有没有相应类的.class存在。如果有，就直接使用；如果没有，则把相关类的.class加载到方法区
2， 在.class加载到方法区时，会分为两部分加载：先加载非静态内容，再加载静态内容
3， 加载非静态内容：把.class中的所有非静态内容加载到方法区下的非静态区域内
4， 加载静态内容：
4.1、把.class中的所有静态内容加载到方法区下的静态区域内
4.2、静态内容加载完成之后，对所有的静态变量进行默认初始化
4.3、所有的静态变量默认初始化完成之后，再进行显式初始化
4.4、当静态区域下的所有静态变量显式初始化完后，执行静态代码块
5，当静态区域下的静态代码块，执行完之后，整个类的加载就完成了。
9、如果一个方法或变量是"private"访问级别，那么它的访问范围是:
A 在当前类，或者子类中
B 在当前类或者它的父类中
C 在当前类，或者它所有的父类中
D 在当前类中
正确答案： D
参考答案：
Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。
default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
public : 对所有类可见。使用对象：类、接口、变量、方法
protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。
我们可以通过以下表来说明访问权限：
10、java中下面哪个能创建并启动线程（）
public class MyRunnable implements Runnable {
public void run() {
//some code here
}
}
A new Runnable(MyRunnable).start()
B new Thread(MyRunnable).run()
C new Thread(new MyRunnable()).start()
D new MyRunnable().start()
正确答案： C
参考答案：
创建并启动线程的过程为：定义线程->实例化线程->启动线程。
定义线程有两种方式，一种是继承java.lang.Thread类，一种是实现java.lang.Runnable接口。这两种方式实例化线程区别在于，如果是继承了Thread类，直接new一个对象就可以了，如果是实现了Runnable接口的类，则需要用Thread的构造方法：
Thread(Runnable target)
Thread(Runnable target, String name) Thread(ThreadGroup group, Runnable target)
Thread(ThreadGroup group, Runnabletarget, String name)
Thread(ThreadGroup group, Runnable target, String name, long stackSize)
因此A、D两个选项实例化线程存在错误。B选项中new Runnable(MyRunnable)中的MyRunnable还没有实例化，会导致编译不通过，该选项无论后面是调用run()还是start()都是错误的。
在Java中，以下关于方法重载和方法重写描述正确的是？
A 方法重载和方法的重写实现的功能相同
B 方法重载出现在父子关系中，方法重写是在同一类中
C 方法重载的返回值类型必须一致，参数项必须不同
D 方法重写的返回值类型必须相同或相容。
答案：D
解析：重载是发生在同一个类中，方法名相同，参数列表不同的方法，为的是在处理不同的数据类型时，为调用者提供了一个同意的入口。重载遵循编译期绑定。
重写是指，子类中的方法与父类的方法方法签名相同。从而覆盖父类中的方法的现象。重写是多态的基础，通过重写，子类可以表现出与父类不同的行为。重写时要，遵循“两同两小一大”的原则，即：方法名相同，参数列表相同，返回值类型要小于或等于父类，抛出的异常要小于或等于父类，访问权限要大于等于父类。
下列那个说法是正确的（D）
A ConcurrentHashMap使用synchronized关键字保证线程安全
B HashMap实现了Collction接口
C Array.asList方法返回java.util.ArrayList对象
D SimpleDateFormat是线程不安全的
解答：
A：HashMap线程不安全，而ConcurrentHashMap就线程安全
ConcurrentHashMap运用各类CAS操作，将扩容操作的并发性能实现最大化，在扩容过程中，就算有线程调用get查询方法，也可以安全的查询数据，若有线程进行put操作，还会协助扩容，利用sizeCtl标记位和各种volatile变量进行CAS操作达到多线程之间的通信、协助，在迁移过程中只锁一个Node节点，即保证了线程安全，又提高了并发性能。
B:
C:Arrays的asList方法使用的ArrayList类是一个内部定义的类，而不是java.util.ArrayList类。
public static <T> List<T> asList(T... a) {
return new ArrayList<T>(a);
}
8、(单选题)给定代码： public class SwitchTest{//1
public static void main(String[] args) {//2
System.out.println("value="+switchit(4));//3
}//4 public static int switchit(int x) {
int j=1; switch (x) {
case 1:j++;
case 2:j++;
case 3:j++;
case 4:j++;
case 5:j++;
default:j++;
} return j+x; } } 第三行将输出什么？（）
A.value=6
B.value=8
C.value=3
D.value=5
【正确答案】B
【答案解析】没有break，从case 4（2）开始case 5（3）一直执行到最后default（4），j自加3次变成了4,结果返回8
下面有关JVM内存，说法错误的是？
A、程序计数器是一个比较小的内存区域，用于指示当前线程所执行的字节码执行到了第几行，是线程隔离的
B、Java方法执行内存模型，用于存储局部变量，操作数栈，动态链接，方法出口等信息，是线程隔离的
C、方法区用于存储JVM加载的类信息、常量、静态变量、即使编译器编译后的代码等数据，是线程隔离的
D、原则上讲，所有的对象都在堆区上分配内存，是线程之间共享的
参考答案：C
答案解析：方法区在JVM中也是一个非常重要的区域，它与堆一样，是被 线程共享 的区域。 在方法区中，存储了每个类的信息（包括类的名称、方法信息、字段信息）、静态变量、常量以及编译器编译后的代码等。
以下程序的输出结果是（A）
public class Print{
static boolean out(char c){
System.out.print(c);
return true;
}
public static void main(String[] argv){
int i = 0;
for(out('A');out('B') && (i<2);out('C')){
i++;
out('D');
}
}
}
A: ABDCBDCB
B: BCDABCD
C: 编译错误
D: 运行错误
答案解析：A
第一轮循环，out(‘A’)输出 A；out(‘B’)输出 B；i=0 满足进入循环的条件，输出D
所以第一轮循环输出ABD
第二轮循环，先判断out(‘C’)输出 C；只想表达式out(‘B’) && (i<2)，输出B，此时i=1; out(‘D’)输出D 所以第二轮循环输出CBD
第三轮循环输出CB 所以最终输出的是ABDCBDCB
下面程序的运行结果：( )
public static void main(String args[]) {
Thread t = new Thread(){
public void run(){
dianping();
}
};
t.run();
System.out.print("dazhong");
}
static void dianping(){
System.out.print("dianping");
}
A. a和b都有可能
B. dianpingdazhong
C. dazhongdianping
D. dianping循环输出，dazhong夹杂在中间
答案：B。 如果调用run(),选用B；如果调用start()，选C。
因为在main()方法中，没有创建一个新的线程，仅仅是调用了run()方法，程序就只能顺序执行；开启线程是调用start()方法，这样才能并发执行。
有以下类定义：
abstract class Animal{
abstract void say();
}
public class Cat extends Animal{
public Cat(){
System.out.printf("I am a cat");
}
public static void main(String[] args) {
Cat cat=new Cat();
}
}
A. Animal不能编译，Cat能编译
B. Animal能编译，Cat不能编译
C. I am a cat
D. 编译能通过，但是没有输出结果
答案：B。 一个实体类继承一个抽象类，必须实现抽象类中的抽象方法。
