每天10个面试题（day06）

1.下列哪种异常是检查型异常，需要在编写程序时声明？

A. NullPointerException

B. ClassCastException

C. FileNotFoundException

D. IndexOutOfBoundsException

解：C，classNotFoundException是受检异常。其他的都是运行时异常，程序员不能控制。



绿色的是非受检异常，红色是受检异常。

2.Which lines of the following will produce an error?

byte a1 = 2, a2 = 4, a3;
short s = 16;
a2 = s; // 大类型不能转化为小类型
a3 = a1 * a2; // 自动转化为int 出错

A. Line 3 and Line 4

B. Line 1 only

C. Line 3 only

D. Line 4 only

解：A。byte型是8位，short型是16位。不能将大类型转化为小类型数据

3.在java中重写方法应遵循规则的包括（）

A. 访问修饰符的限制一定要大于被重写方法的访问修饰符

B. 可以有不同的访问修饰符

C. 参数列表必须完全与被重写的方法相同

D. 必须具有不同的参数列表

解：BC

访问修饰符的限制大于等于被重写的方法

override的规则：

方法名相同，参数类型相同

子类返回类型小于等于父类方法返回类型，

子类抛出异常小于等于父类方法抛出异常，

子类访问权限大于等于父类方法访问权限。

4.下列Java代码中的变量a、b、c分别在内存的__存储区存放。

class A {
private String a = “aa”;
public boolean methodB() {
String b = “bb”;
final String c = “cc”;
}
}

A. 堆区、堆区、堆区

B. 堆区、栈区、堆区

C. 堆区、栈区、栈区

D. 堆区、堆区、栈区

解：C，这里的题目意思的变量指变量实际的值而不是指它变量的引用。java所有变量对象的引用和方法中的成员变量存放在栈中，new出来的对象是存放在堆中，String类型的变量（指这里的 String a = “aa”这种形式）存放在常量池中，常量池位于堆中。



5.以下多线程对int型变量x的操作,哪个不需要进行同步()

A. ++x

B. x=y

C. x++

D. x=0

解析：前三个都至少需要先读取，再操作，非原子操作。而D的话，直接赋值。

6.以下集合对象中哪几个是线程安全的？( )

A. ArrayList

B. Vector

C. Hashtable

D. Stack

解析：BCD，

在集合框架中，有些类是线程安全的，这些都是jdk1.1中的出现的。在jdk1.2之后，就出现许许多多非线程安全的类。 下面是这些线程安全的同步的类：

vector：就比arraylist多了个同步化机制（线程安全），因为效率较低，现在已经不太建议使用。在web应用中，特别是前台页面，往往效率（页面响应速度）是优先考虑的。

statck：堆栈类，先进后出 继承vector

hashtable：就比hashmap多了个线程安全

enumeration：枚举，相当于迭代器

除了这些之外，其他的都是非线程安全的类和接口。

7.从以下哪一个选项中可以获得Servlet的初始化参数?

A. Servlet

B. ServletContext

C. ServletConfig

D. GenericServlet

解析：C，通过ServletConfig接口的getInitParameter(java.lang.String name)方法

ServletContext对象：servlet容器在启动时会加载web应用，并为每个web应用创建唯一的servlet context对象，可以把ServletContext看成是一个Web应用的服务器端组件的共享内存，在ServletContext中可以存放共享数据。ServletContext对象是真正的一个全局对象，凡是web容器中的Servlet都可以访问。

整个web应用只有唯一的一个ServletContext对象

servletConfig对象：用于封装servlet的配置信息。从一个servlet被实例化后，对任何客户端在任何时候访问有效，但仅对servlet自身有效，一个servlet的ServletConfig对象不能被另一个servlet访问。

8.关于以下程序,说法正确是什么？

public class Test {
static int x=10;
static {x+=5;}
public static void main(String[] args) //4
{
System.out.println("x="+x);
}
static{x/=3;};
}//9

A. 4行与9行不能通过编译，因为缺少方法名和返回类型

B. 编译通过，执行结果是：x=5

C. 编译通过，执行结果是：x=3

D. 9行不能通过编译，因为只能有一个静态初始化器

解：B

这道题主要考察类记载时候的初始化问题，执行这个类的 main方法，会导致类进行加载，而类加载的属性如下

1、虚拟机在首次加载Java类时，会对静态初始化块、静态成员变量、静态方法进行一次初始化。我们不要去纠结这里的顺序，一般来说我们只需要知道，静态方法一般在最后。

2、只有在调用new方法时才会创建类的实例

3、类实例创建过程：按照父子继承关系进行初始化，首先执行父类的初始化块部分，然后是父类的构造方法；再执行本类继承的子类的初始化块，最后是子类的构造方法

4、类实例销毁时候，首先销毁子类部分，再销毁父类部分

9.HttpSession session = request.getSession(false) 与HttpSession session = request.getSession(true)的区别？

A.没有区别

B.如果当前reqeust中的HttpSession 为null，当传入参数为空时，就创建一个新的Session，否则返回null

C.如果当前reqeust中的HttpSession 为null，当传入参数为true时，就创建一个新的Session，否则返回null

1、request.getSession() 等价于 request.getSession(true)

这两个方法的作用是相同的，查找请求中是否有关联的session id，如果有则返回这个号码所对应的session对象，如果没有则生成一个新的session对象。所以说，通过此方法是一定可以获得一个session对象。

2、request.getSession(false) 查找请求中是否有关联的session id，如果有则返回这个号码所对应的session对象，如果没有则返回一个null。

10.class A {}

class B extends A {}

class C extends A {}

class D extends B {}

Which four statements are true ?

A.The type List<A> is assignable to List.
B.The type List<B> is assignable to List<A>.
C.The type List<Object> is assignable to List<?>.
D.The type List<D> is assignable to List<?extends B>.
E.The type List<?extends A> is assignable to List<A>.
F.The type List<Object>is assignable to any List reference.
G.The type List<?extends B> is assignable to List<?extends A>.

解析：ACDG

1. 只看尖括号里边的！！明确点和范围两个概念

2. 如果尖括号里的是一个类，那么尖括号里的就是一个点，比如

List<A>,List<B>,List<Object>

3. 如果尖括号里面带有问号，那么代表一个范围，

<? extends A>

代表小于等于A的范围，

<? super A>

代表大于等于A的范围，

<?>

代表全部范围

4. 尖括号里的所有点之间互相赋值都是错，除非是俩相同的点

5. 尖括号小范围赋值给大范围，对，大范围赋值给小范围，错。如果某点包含在某个范围里，那么可以赋值，否则，不能赋值

6.

List<?>

和

List

是相等的，都代表最大范围

7. 补充：

List

既是点也是范围，当表示范围时，表示最大范围

代码：

public static void main(String[] args) {
List<A> a;
List list;
list = a;   //A对，因为List就是List<?>，代表最大的范围，A只是其中的一个点，肯定被包含在内
List<B> b;
a = b;      //B错，点之间不能相互赋值
List<?> qm;
List<Object> o;
qm = o;     //C对，List<?>代表最大的范围，List<Object>只是一个点，肯定被包含在内
List<D> d;
List<? extends B> downB;
downB = d;  //D对，List<? extends B>代表小于等于B的范围，List<D>是一个点，在其中
List<?extends A> downA;
a = downA;  //E错，范围不能赋值给点
a = o;      //F错，List<Object>只是一个点
downA = downB;  //G对，小于等于A的范围包含小于等于B的范围，因为B本来就比A小，B时A的子类嘛
}