1.如下代码：
public class Test {
public int aMethod() {
static int i = 0; //错误的语法
i++;
return i;
}
public static void main (String args[]) {
Test test = new Test();
test.aMethod();
int j = test.aMethod();
System.out.println(j);
}
}
输出的结果是什么？
A. 0 B. 1 C. 2 D. 编译失败
结果：D
解析：i在方法aMethod中是成员变量，而static的作用域是整个类
正确的语法
public class Test {
static int i = 0;
public int aMethod() {
i++;
return i;
}
public static void main (String args[]) {
Test test = new Test();
test.aMethod();
int j = test.aMethod();
System.out.println(j);
}
}
结果为 2
2. 下列哪种说法是正确的（ D）
A． 实例方法可直接调用超类的实例方法 ` 如果超类没有被重写就可以`
B． 实例方法可直接调用超类的类方法 `有可能是私有方法不可以调用`
C． 实例方法可直接调用其他类的实例方法 `不可以`
D． 实例方法可直接调用本类的类方法
3.如下代码：
public class SuperTest {
public Integer getLenght() { return new Integer(4); }
}
public class Test extends SuperTest{
public Long getLenght() { return new Long(5); } //语法错误
public static void main(String[] args) {
SuperTest sooper = new SuperTest();
Test sub = new Test();
System.out.println(sooper.getLenght().toString() + "," +
sub.getLenght().toString() );
}
}
输出的结果是什么？
A. 4,4
B. 4,5
C. 5,4
D. 5,5
E. 编译失败. 子类重写父类的方法时候返回类型要一致
4. 在Servlet处理请求的方式为: C
A.以进程的方式
B.以程序的方式
C.以线程的方式Servlet容器默认是采用单实例多线程的方式处理多个请求的
D.以响应的方式
5. JDBC中，用于表示数据库连接的对象是: B
A.Statement 连接的实例，执行sql
B.Connection 建立与数据库的连接
C.DriverManager 该方法将建立与数据库的连接
D.PreparedStatement
9. 如下代码
10. public Object m() {
11. Object o = new Float(3.14F);
12. Object [] oa = new Object[1];
13. oa[0] = o;
14. o = null;
15. oa[0] = null;
16. print 'return 0';
17. }
当Float对象在第11行被创建后, 什么时候能够被垃圾回收? C
A. 13行以后.
B. 14行以后.
C. 15行以后.
D. 16行以后.
解析：
public Object m() {
Object o = new Float(3.14F); // o----------> new Float(3.14f)
Object [] oa = new Object[1];
oa[0] = o; // o----------> new Float(3.14f) <--------------- oa[0]
o = null; // o----------> null , oa[0]---------------> new Float(3.14f)
oa[0] = null;// o----------> null , oa[0]---------------> null , new Float(3.14f) 到这一步，这个对象不再有任何引用了，也就是成了垃圾对象了
return 0;
}
10. 在Servlet的生命周期中，容器只调用一次的方法是: C
A.service
B.getServletConfig
C.init
D.destroy 三种情况都会调用destroy tomcat remove servlet 再卸载tomcat stop servlet 修改servlet代码重新编译
11. 以下关于异常的说法正确的是：D
Ａ. 一旦出现异常，程序运行就终止了 非系统异常仍然可以继续运行
Ｂ. 如果一个方法申明将抛出某个异常，它就必须真的抛出那个异常 不一定
Ｃ. 在catch子句中匹配异常是一种精确匹配 exception
Ｄ. 可能抛出系统异常的方法是不需要申明异常的
12. jsp指令中isELIgnored="boolean"的意思是（C ）
A．决定是否实现Servler的单线程模式，
B．决定改页面是否是一个错误处理页面，
C．决定是否支持EL表示，
D．没有具体的含义。
13.下面关于Java的引用，说法正确的是：B
Ａ. 引用实际上就是指针 java中没有指针
Ｂ. 引用本身是Primitive引用本身就是原始数据
Ｃ. 引用就是对象本身 引用存放对象的地址
Ｄ. 一个对象只能被一个引用所指引 可以是多个
14. 对于import java.util包，以下那种说法是错误的？C
Ａ. Vector类属于java.util包
Ｂ. Vector类放在…／java/util/目录下
Ｃ. Vector类放在java.util文件中
Ｄ. Vector类是Sun公司的产品
15. 在一个线程中Sleep（1000）方法，将使得该线程在多少时间后获得对CPU的控制（假设睡眠过程中不会有其他事件唤醒该线程）？C
Ａ. 正好1000毫秒
Ｂ. 1000毫秒不到
Ｃ. =>1000毫秒 1000ms之后，由cpu的时间片控制分配，轮到你这个线程运行，你才能运行；
Ｄ. 不一定
16. 下面关于垃圾收集的说法正确的是：D
Ａ. 一旦一个对象成为垃圾，就立刻被收集掉。不会随时动
Ｂ. 对象空间被收集掉之后，会执行该对象的finalize方法 之前
Ｃ. finalize方法和C++的析构函数是完全一回事情析构可以主动,Finalize是被动的
Ｄ. 一个对象成为垃圾是因为不再有引用指着它，但是线程并非如此。
17. 下面的语句会产生什么样的输出? A
System.out.println(4&7); 0100 &0111=0100=4
A.4
B.5
C.6
D.7
E.0
public static void main(String[] args) {
int i = 14;
boolean flag = true;
do{
i = i >> 1;
if(i < 4){
flag = false;
}
}while(flag);
System.out.println(i);
}
结果为 3
18. 选出所有正确的答案
public class Outer{
public void someOuterMethod() {
// Line 3
}
public class Inner{}
public static void main( String[]argv ) {
Outer o = new Outer();
// Line 8
}
}
Which instantiates an instance of Inner? A
A. new Inner(); // At line 3内部类有点类似成员属性，但也有区别，只有内部成员或者方法才可以访问。主类的实例对象也不可以。
B. new Inner(); // At line 8
C. new o.Inner(); // At line 8
D. new Outer.Inner(); // At line 8
19.如下代码：
public class OuterClass {
private double d1 = 1.0;
//insert code here
}
You need to insert an inner class declaration at line 3. Which two inner class declarations are valid?(Choose two.)
A. class InnerOne{ public static double methoda() {return d1;} }
B. public class InnerOne{ static double methoda() {return d1;} }
C. private class InnerOne{ double methoda() {return d1;} }
D. static class InnerOne{ protected double methoda() {return d1;} }
E. abstract class InnerOne{ public abstract double methoda(); }
解析：
静态内部类可以有静态成员，而非静态内部类不能有静态成员，故A,B错
静态内部类的非静态成员可以访问外部类的静态变量，而不可以访问外部类的非静态变量，故D错
非静态内部类的非静态成员可以访问外部类的非静态变量
内部类的简单理解
public class OutClass{
private String name = "xue";
private static String age = "女";
public void OutClassMethod(){
System.out.println("out:" +name);
System.out.println("out:" +age);
InnerClass inner = new InnerClass(); //内部类只能在本类中实例化
inner.innerAMethod();
Inner1Class.inner1BMethod();
}
public class InnerClass{
public void innerAMethod(){
System.out.println("inner:" + name); //非静态内部类可以访问外部类非静态成员变量
}
public void innerBMethod(){
System.out.println("inner:" + age); //非静态内部类可以访问外部类静态成员变量
}
//非静态内部类不能有静态成员
// public static void innerCMethod(){
// System.out.println("inner" + age);
// }
}
static class Inner1Class{
// public static void inner1AMethod(){
// System.out.println("inner1" + name); //静态内部类不能访问外部类的非静态成员变量
// }
public static void inner1BMethod(){
System.out.println("inner1:" +age); //静态内部类可以访问外部类的静态成员变量
}
}
public static void main(String[] args) {
OutClass test = new OutClass();
test.OutClassMethod();
//InnerClass inner = new InnerClass(); 类外部不能实例化内部类对象
}
}
运行结果：
out:xue
out:女
inner:xue
inner1:女
20. 下列说法正确的有（）
A． class中的constructor不可省略
B． constructor必须与class同名，但方法不能与class同名
C． constructor在一个对象被new时执行
D．一个class只能定义一个constructor
答案：C
解析：这里可能会有误区，其实普通的类方法是可以和类名同名的，和构造方法唯一的区分就是，构造方法没有返回值
21.如下代码：
public static void main(String[] args) throws Exception {
Thread t = new Thread(){
public void run(){
pong();
}
};
t.run(); //只是调用线程的run方法，还在当前线程执行
System.out.println("ping");
}
static void pong(){
System.out.println("pong");
}
的执行结果是：B
A.pingpong B.pongping C.pingpong和pongping都有可能 D 都不输出
- 用
start方法来启动线程，真正实现了多线程运行，这时无需等待run方法体代码执行完毕而直接继续执行下面的代码。通过调用Thread类的 start()方法来启动一个线程，这时此线程处于就绪（可运行）状态，并没有运行，一旦得到cpu时间片，就开始执行run()方法，这里方法 run()称为线程体，它包含了要执行的这个线程的内容，Run方法运行结束，此线程随即终止;run()方法只是类的一个普通方法而已，如果直接调用Run方法，程序中依然只有主线程这一个线程，其程序执行路径还是只有一条，还是要顺序执行，还是要等待run方法体执行完毕后才可继续执行下面的代码，这样就没有达到写线程的目的
调用start方法方可启动线程，而run方法只是thread的一个普通方法调用，还是在主线程里执行。
如下代码：
public static void main(String[] args) throws Exception {
Thread t = new Thread(){
public void run(){
pong();
}
};
t.start(); //启动线程
System.out.println("ping");
}
static void pong(){
System.out.println("pong");
}
执行结果：
ping
pong
如下代码：
public static void main(String[] args) throws Exception {
Thread t = new Thread(){
public void run(){
pong();
}
};
t.start();
t.join();//阻塞当前线程，子线程执行完成后执行当前线程
System.out.println("ping");
}
static void pong(){
System.out.println("pong");
}
执行结果：
pong
ping
join的原理就是依次检验线程池中的线程是否结束，没有结束就阻塞直到线程结束，如果结束则跳转执行下一个线程的join函数;
参数timeout为线程的阻塞时间，如 timeout=2 就是罩着这个线程2s 以后，就不管他了，继续执行下面的代码
21. volatile关键字是否能保证线程安全？（）
答案：不能
解析：volatile关键字用在多线程同步中，可保证读取的可见性，JVM只是保证从主内存加载到线程工作内存的值是最新的读取值，而非cache中。但多个线程对volatile的写操作，无法保证线程安全。例如假如线程1，线程2 在进行read,load 操作中，发现主内存中count的值都是5，那么都会加载这个最新的值，在线程1堆count进行修改之后，会write到主内存中，主内存中的count变量就会变为6；线程2由于已经进行read,load操作，在进行运算之后，也会更新主内存count的变量值为6；导致两个线程及时用volatile关键字修改之后，还是会存在并发的情况。
22.下面哪个流类属于面向字符的输入流(D )
A BufferedWriter B FileInputStream C ObjectInputStream D InputStreamReader
解析：Java的IO操作中有面向字节(Byte)和面向字符(Character)两种方式。
面向字节的操作为以8位为单位对二进制的数据进行操作，对数据不进行转换，这些类都是InputStream和OutputStream的子类。
面向字符的操作为以字符为单位对数据进行操作，在读的时候将二进制数据转为字符，在写的时候将字符转为二进制数据，这些类都是Reader和Writer的子类。
总结：以InputStream（输入）/OutputStream（输出）为后缀的是字节流； 以Reader（输入）/Writer（输出）为后缀的是字符流。
扩展：Java流类图结构
image.png
22.ArrayList list = new ArrayList(20);中的list扩充几次（A）
A 0 B 1 C 2 D 3
解析：这里有点迷惑人，大家都知道
默认ArrayList的长度是10个，所以如果你要往list里添加20个元素肯定要扩充一次（扩充为原来的1.5倍），但是这里显示指明了需要多少空间，所以就一次性为你分配这么多空间，也就是不需要扩充了
23.下面程序能正常运行吗（能）
public static void haha(){
System.out.println("haha");
}
public static void main(String[] args) {
((EncodeDemo)null).haha();
}
解析：输出为haha，因为null值可以强制转换为任何java类类型,(String)null也是合法的。但null强制转换后返回值还是为null，而static方法是无效对象，其的调用是和类名绑定的，不借助对象进行访问所以能正确输出。反过来，没有static修饰就只能用对象进行访问，使用null调用对象肯定会报空指针错了。这里和C++很类似
24.下面程序的运行结果是什么（）
public class HelloA {
public HelloA() {
System.out.println("HelloA");
}
{ System.out.println("I'm A class"); }
static { System.out.println("static A"); }
}
public class HelloB extends HelloA{
public HelloB() {
System.out.println("HelloB");
}
{ System.out.println("I'm B class"); }
static { System.out.println("static B"); }
public static void main(String[] args) {
System.out.println("-------main start-------");
new HelloB();
System.out.println("-------main end-------");
}
}
运行结果：
static A
static B
-------main start-------
I'm A class
HelloA
I'm B class
HelloB
-------main end-------
解析：考查静态语句块、构造语句块（就是只有大括号的那块）以及构造函数的执行顺序
对象的初始化顺序：
- （1）类加载之后，按从上到下（从父类到子类）执行被static修饰的语句；
- （2）当static语句执行完之后,再执行main方法；
- （3）如果有语句new了自身的对象，将从上到下执行构造代码块、构造器（两者可以说绑定在一起）
25.下面的方法，当输入为2的时候返回值是多少?（）
public static void getValue(int i) {
int result = 0;
switch (i) {
case 1:
result = result + i;
case 2:
result = result + i * 2;
case 3:
result = result + i * 3;
}
System.out.println(result);
}
运行结果：
10
没有break跳出函数的话，程序继续向下执行到遇到break,这里case后面没有加break，所以从case 2开始一直往下运行
26.选项中哪一行代码可以替换题目中//add code here而不产生编译错误？（A）
public abstract class MyClass {
public int constInt = 5;
//add code here
public void method() {
}
}
Apublic abstract void method(int a);
B constInt = constInt + 5;
C public int method();
D public abstract void anotherMethod() {}
抽象类遵循的原则：
（1）abstract关键字只能修饰类和方法，不能修饰字段。
（2）抽象类不能被实例化（无法使用new关键字创建对象实例），只能被继承。
（3）抽象类可以包含属性，方法，构造方法，初始化块，内部类，枚举类，和普通类一样，普通方法一定要实现，变量可以初始化或不初始化但不能初始化后在抽象类中重新赋值或操作该变量（只能在子类中改变该变量）。
（4）抽象类中的抽象方法（加了abstract关键字的方法）不能实现。
（5）含有抽象方法的类必须定义成抽象类。
扩展：抽象类和接口的区别，做个总结吧：
（1）接口是公开的，里面不能有私有的方法或变量，是用于让别人使用的，而抽象类是可以有私有方法或私有变量的。
（2）abstract class 在 Java 语言中表示的是一种继承关系，一个类只能使用一次继承关系。但是，一个类却可以实现多个interface，实现多重继承。接口还有标识（里面没有任何方法，如Remote接口）和数据共享（里面的变量全是常量）的作用。
（3）在abstract class 中可以有自己的数据成员，也可以有非abstarct的成员方法，而在interface中，只能够有静态的不能被修改的数据成员（也就是必须是 static final的，不过在 interface中一般不定义数据成员），所有的成员方法默认都是 public abstract 类型的。
（4）abstract class和interface所反映出的设计理念不同。其实abstract class表示的是"is-a"关系，interface表示的是"has-a"关系。
（5）实现接口的一定要实现接口里定义的所有方法，而实现抽象类可以有选择地重写需要用到的方法，一般的应用里，最顶级的是接口，然后是抽象类实现接口，最后才到具体类实现。抽象类中可以有非抽象方法。接口中则不能有实现方法。
（6）接口中定义的变量默认是public static final 型，且必须给其初值，所以实现类中不能重新定义，也不能改变其值。抽象类中的变量默认是 friendly 型，其值可以在子类中重新定义，也可以在子类中重新赋值。
