匿名网友
面试题1：关于equals()和==的选择题
【考题题干】根据下面的程序代码，哪些选项的值返回true ？
public class Square {
long width;
public Square(long l) {
width = l;
}
public static void main(String arg[]) {
Square a, b, c;
a = new Square(42L);
b = new Square(42L);
c = b;
long s = 42L;
}
}
A ．a == b;
B ．s == a;
C ．b == c;
D ．a.equals(s)
【试题分析】
equals()是Object 类的一个方法，指示某个其他对象是否与此对象“相等” 。由于类 Object 是类层次
结构的根类。所以它是每个类的超类。所示每个类都可以重写 equals()方法，如 String 类。如果没有重
写（override ）新类的equals() ，则该方法和 == 操作符一样在两个变量指向同一对象时返回真，但是Java
推荐的是使用equals()方法来判断两个对象的内容是否一样。考察“== ”及方法“equals() ”的用法。注
意以下几点区别。
?8?0 引用类型比较引用；基本类型比较值。
?8?0 equals()方法只能比较引用类型，“== ”可比较引用及基本类型。
?8?0 用equals()方法进行比较时，对类File 、String、Date 及封装类（Wrapper Class ）来说，是比较
类型及内容。
?8?0 用“== ”进行比较时，符号两边的数据类型必须一致（可相互转换的基本类型除外），否则编
译出错。
在此题中，因为a，b ，c 是三个对象面，但是c=b 这条语句，将c 的内存地址指向了b ，所以c 和b
指向了同一个地址，相当于 c 和b 是同一个对象，由于== 操作符只有当两个变量指向同一对象时返回
真，故C 是正确的。
【参考答案】C
面试题2 ：int 和Integer 有什么区别
Java 提供两种不同的类型：引用类型和原始类型（或内置类型）。Int 是Java 的原始数据类型，Integer
是Java 为int 提供的封装类。Java 为每个原始类型提供了封装类。原始类型封装类，例如：Boolean 是
boolean 的封装类；Characte 是char 的封装类；Byte 是byte 的封装类；Short 是short 的封装类；Integer
是int 的封装类；Long 是long 的封装类；Float 是float 的封装类；Double 是double 的封装类。引用类型
和原始类型的行为完全不同，并且它们具有不同的语义。引用类型和原始类型具有不同的特征和用法，
它们包括：大小和速度问题，这种类型以哪种类型的数据结构存储，当引用类型和原始类型用作某个类
的实例数据时所指定的默认值。对象引用实例变量的默认值为null ，而原始类型实例变量的默认值与它
们的类型有关。
面试题3 ：int 的取值范围是哪个
【考题题干】下面的选项中属于int 的取值范围是哪个？
7 7
A ．-2 ～2 – 1
32
B ．0～2 – 1
15 15
C ．-2 ～2 – 1
31 31
D ．-2 ～2 -1
【参考答案】D
面试题4 ：char 的取值范围是多少
【考题题干】char 型数据的取值范围是多少?
A ．– 128 ～ 127
B ．0 ～ 32767
C ．由平台决定
D ．0 ～ 65535
【参考答案】D
面试题5 ：在char 中能存储汉字吗
【考题题干】char 型变量中能不能存贮一个中文汉字?为什么?
【参考答案】是能够定义成为一个中文的，因为Java 中以unicode 编码，一个char 占16 个字节，
所以放一个中文是没问题的
面试题6 ：基本数据类型与String 之间的转换
【考题题干】表达式10.4+”4.2″的结果是什么？
A ．返回double 类型 14.6
B ．返回String 类型”14.6″
C ．返回long 类型 14
D ．返回String 类型”10.44.2″
【试题分析】该面试题中，当+运算符两侧的操作数的类型不一致时，需要统一类型，这时就会发
生类型转换。当一个操作数为原始数据类型，另外一个为字符串时，则基本类型的操作数要转换为等价
的字符串，这时“+ ”不再是加运算符而是连接符，所以表达式10.4+”4.2″返回的结果是”10.44.2″。
【参考答案】D
面试题7 ：关于final 的参数传递
【考题题干】在下面程序标明的位置处插入哪条语句会导致编译错误？
public class FinalUse {
public static void main(String[] args) {
int x = 0;
final int y = 1;
int[] z = { 2 };
final int[] n = { 3 };
Use(x, y, z, n);
}
static void Use(final int x, int y, final int[] z, int[] n) {
// 插入内容
}
}
请选择两个正确的答案：
A ．x++
B ．y++
C ．y=x
D ．z[0]++
E ．n[0]++
F ．z=n
【试题分析】声明形参的时候可以在方法调用的参数调用之前加上关键字final 。final 参数也可以叫
做空白最终变量，也可以当作常量。即在对其赋值之前（例如方法调用之前），该变量为空（为初始化），
赋值之后，在该变量的生存周期内只能调用再也不能改变变量的值。final 变量只可以被赋值一次。在方
法调用时，final 形式参数被赋予实际参数的值。在方法内部，不能对 final 参数进行重新赋值或者是修
改。
在Use 方法中，x 是final 类型的，因此A 选项中x++表示是可以改变x 的值的，所以A 会导致编
译错误。y ，n[0]是int 变量，所以y, n[0]值是可以变化的，因此插入B 和E 选项都会编译通过的。C 选
项是把x 的值赋给y，改变是y 的内容，不会改变x 的值，所以插入C 选项会编译通过的。在D 选项中，
由于z 是个int 型数组，它是属于复合类型，在进行值传递的时候，传给形参的是地址值，而不是内容，
因此final int[] z 就表示z 数组不能在指向其他的数组对象，但是z 数组中的内容是可以改变的，因此z
[0]++表示的是内容上的改变，所以是没有错误的，可以编译通过的。F 选项正好与D 选项相反，同理，
F 就是错误的。
【参考答案】AF
面试题8 ：关于默认初始化的叙述哪些选项是正确
【考题题干】关于数组元素默认初始化，下面哪4 个选项是正确的?
A ．int -> – 1
B ．String -> “”
C ．Person -> null
D ．char -> ?6?7u0000?6?8
E ．float -> 0.0
F ．boolean -> true
【试题分析】请看下面的各数据类型的元素初始化值，如表1 所示。
表 1 数组元素初始化值
元素类型 初始化值
byte 0
short 0
int 0
long 0
char ?6?7U0000?6?8
float 0.0f
double 0.0d
boolean false
Object Reference null
注意：原始数据类型的初始化都是0，char 类型的数组元素初始化默认是Unicode zero ，即‘U0000 ’，
为空字符。
表1 是各数据类型的初始值在缺省的情况下，系统为其设置的默认初始值。对比上面的表格就可以
很明显的看出答案喽！在这里我就不必在讲解为什么了。
【参考答案】CD
面试题9 ：编程题（求最大数）
【考题题干】求一个长度为10 的整型数组中最大元素，釆用随机的赋值方式并将各元素的值输出。
【试题分析】要求数组中的最大元素，也需要遍历整个数组。它的基本思路是：先假定第一个元素
最大，然后将这个元素存储在一个临时变量中，将这个变量依次与后面的元素比较，如果有比这个临时
变量大的，则存储在这个变量中。当所有元素比较完成后，这个临时变量中存储的就是最大元素。这一
方法，也可以用来求最小元素。
【参考答案】
public class MaxArray {
public static void main(String args[]) {
int arry[] = new int[10];
setValue(arry);
showValue(arry);
System.out.println(“n 最大值为：” + getMaxValue(arry));
}
// 返回数组中的最大值
public static int getMaxValue(int a[]) {
int max = a[0]; // 假定第一个元素最大；
for (int i = 1; i < a.length; i++) // 依次与后面的元素进行比较
if (a > max)
max = a; // 如果有比max 大的，记录下来
return max;
}
// 为数组元素赋随机值
public static void setValue(int a[]) {
for (int i = 0; i < a.length; i++)
a = (int) (Math.random() * 100);
}
// 显示数组中所有元素
public static void showValue(int a[]) {
System.out.println(“数组元素值为：”);
for (int i = 0; i < a.length; i++) {
System.out.print(” ” + a);
if ((i + 1) % 5 == 0)
System.out.println(); // 每5 个元素换一行
}
}
}
运行结果如下：（仅供参考）
数组序列为：
22 23 17 38 64
30 65 48 42 49
最大值为：65
面试题10：如何获得数组大小
【考题题干】给出下面声明，假设已经初始化了该数组，则下面哪个表达式会返回数组的大小。
int[][] array = new int[5][];
请选出一个正确的答案。
A ．array[].length();
B ．array.length();
C ．array[2].length;
D ．array[0][0].length;
E ．array[3].size();
F ．array.size();
【试题分析】每个数组都是对象，并有一个length 字段，来表示该数组的长度。Java 中的数组总是
知道它们的大小，这表现在length 字段。
在本题中A 和B 选项是格式错误，数组有length 字段，而不是length （）方法。习惯了使用类似与
String 类型的length()方法来获得字符串长度的面试者一定要注意这点。所以A 和B 是错误的。
D 选项也是错误的，因为array 是个二维数组，array[0]是一维数组而array[0][0]指的就是int 类型的
数据了，基本数据类型没有length 这个属性，所以，在语义上就是错误的。
E 和 F 这两个选项是将数组和集合混淆了，只有集合如 List 要求返回列表中的元素个数是才会用
size()方法，所以E 和F 也是错误的。那么现在就只剩下 C 选项了，array[2]表示的是一维数组，length
是数组返回长度的属性，所以C 是正确选项。
【参考答案】C
面试题11：String 和StringBuffer 的区别
【考题题干】请说出String 与StringBuffer 的区别？
【参考答案】String 的长度是不可变的，StringBuffer 的长度是可变的。如果你对字符串中的内容经
常进行操作，特别是内容要修改时，那么使用StringBuffer，如果最后需要String，那么使用StringBuffer
的toString()方法。
面试题12 ：setLength 方法的作用是什么
【考题题干】下面程序能编译通过吗？如果不能请说明为什么，能运行结果是什么？
public class aa {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer(“good_bye”);
sb.setLength(4);
System.out.println(sb);
}
}
请选择一个正确的答案：
A ．将会打印good 。
B ．将会打印good_ 。
C ．将会打印good_bye 。
D ．在运行时会抛出 1 个异常。
E ．不能编译，因为StringBuffer 类中没有setLength 方法。
【试题分析】setLength 方法的作用是设置字符序列的长度。序列将被更改为一个新的字符序列，新
序列的长度由参数指定。所以在本题中就将sb 字符串的长度由原来的8 截短到了4，所以将会打印出A
【参考答案】A
面试题13：switch 语句的使用范围
【考题题干】swtich 是否能作用在byte 上，是否能作用在long 上，是否能作用在String 上?
【试题分析】这道题目主要考察expr1 的值类型，如果不能明确的掌握该知识点，将会成做题的过
程中的绊脚石。
【参考答案】switch （expr1 ）中，expr1 是一个整数表达式。因此传递给switch 和case 语句的参数
应该是int、short、char 或者byte 、long、string 都不能作用于swtich。
面试题14 ：选出do-while 语句的正确结果
【考题题干】根据给出的代码 （如下所示），输出结果将会是什么？
class DoWhileTest {
void getValueOfN(int n) {
do {
System.out.println(“n= ” + n);
} while (–n > 15);
}
public static void main(String arg[]) {
int i = 18;
DoWhileTest dw = new DoWhileTest();
dw.getValueOfN(i);
}
}
结果将会是什么呢?
A ．19
B ．18
C ．17
D ．16
E ．15
【试题分析】
此题考察的是do-while 循环和 — 操作符的知识，在执行do-while 的时候，循环体至少被执行一次，
在执行完do 后面的循环体中的内容，再判断while 中的条件是否为true 。如果为true 的话就再重复执行
循环体中的内容，然后再进行判断，重复操作以上动作直到while 的判断为false 时退出循环。而自减运
算符（–）在变量左边，属于前置运算符则是先将变量的值减一再运算。
【参考答案】B 、C、D
面试题15 ：关于break 和continue 描述哪些是对的？
【考题题干】请从下面选项中选择2 个正确的答案。
A ．{{}}是有效的代码块。
B ．{continue}是有效的代码块。
C ．out:{break out;}是有效的代码块。
D ．inner:{continue inner;}是有效的代码块。
E ．break 语句只能用在循环语句（while 、do-while 或者for ）或者switch 语句中。
F ．在使用了break 语句的代码块中，是不允许在使用continue 语句的。
【试题分析】选项A{} 是一个合法的符合语句；选项 B{continue;}块本身是无效的；选项 C 中
out:{break out;}是无效的代码，没有起到终止循环体的作有，选项D 的错误原因也是如此。选项F 在同
一个代码块中是可以即使用break 又使用continue ，它们的作用不相同所以不会相互冲突的。
【参考答案】AC
面试题16 ：请选择可以返回最大值的是哪个方法？
【考题题干】根据下面代码中给出的方法，只有一个方法能正确返回最大值，请找出是哪个方法？
int max(int a,int b){
return (if(a>b){a;}else{b;});
}
int max1(int a,int b){
return (if(a>b){return a;}else{return b;});
}
int max2(int a, int b) {
switch (a < b) {
case true:
return b;
default:
return a;
}
;
}
int max3(int a, int b) {
if (a > b)
return a;
return b;
}
请选择一个正确的答案：
A ．max
B ．max 1
C ．max2
D ．max3
【试题分析】此题目主要考察对return 语句的使用。return 必须是使用在方法中的。在max 和max1
这两个方法中if 并不能返回任何值所以是错误的。在max2 中switch 语句的判断条件必须是一个int 型
值，也可以是byte 、short、char 型的值，不能是boolean 类型的，所以是错误的。因此只为D 选项是正
确的。
【参考答案】D
面试题17：运行时异常与一般异常有何异同
异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能遇到的
异常，是一种常见运行错误。Java 编译器要求方法必须声明抛出可能发生的非运行时异常，但是并不要
求必须声明抛出未被捕获的运行时异常。
面试题18：哪个类是所有异常的基础类？
【考题题干】哪个类是所有异常的基础类？
A ．String
B ．Error
C ．Throwable
D ．RuntimeException
【参考答案】C
面试题19：哪些是对try-catch-finally 正确的叙述
【考题题干】下面选项是关于捕获异常的语法try-catch-finally 的描述，请选择正确的答案。
A ．try 可以单独使用
B ．try-catch 必须配对使用
C ．try-finally 可以配对使用
D ．catch-finally 可以配对使用
E ．在try-catch 后如果定义了finally,则finally 肯定会执行
【参考答案】CE
面试题20 ：怎样使用throws 处理异常？
【考题题干】如果要让下面的程序能够正常编译，需在子类ThrowDemo 中的重写方法 myThow()
做怎样的处理？请选择正确的答案。
public class ThrowDemo extends Throw {
void myThow()/* throws 表达式 */{
try {
myThow_1(7, 0);
} catch (ArithmeticException e) {
System.out.println();
}
throw new RuntimeException(“运行时异常”);
}
public static void main(String[] args) {
new ThrowDemo().myThow();
}
}
class Throw {
void myThow() throws ArithmeticException, InterruptedException {
myThow_1(3, 6);
}
int myThow_1(int x, int y) throws ArithmeticException {
return x / y;
}
}
请选择一个正确的答案。
A ．在myThow()后面需要声明ArithmeticException 。
B ．在myThow()后面需要声明ArithmeticException 。
C ．在myThow()后面需要声明RuntimeException 。
D ．在myThow()后面需要既要声明ArithmeticException ，又要声明InterruptedException 。
E ．在myThow()后面不需要声明任何异常并将throw new RuntimeException(“运行时异常”);这条语句
去掉。
【试题分析】
父类中的重写方法可以指定所有的已检查异常或者指定已检查异常的一部分，这些已检查异常是重
载方法在其throws 子句中声明的。子类在重写该方法时不需要指定重写方法throws 子句的任何已检查
异常。所以在本题中myThow()方法不用做任何的声明，ArithmeticException 和InterruptedException 都属
于RuntimeException ，并且在myThow()方法中有捕获处理异常，所以不应该再抛出异常，因此 E 答案
是正确的。
【参考答案】E
面试题21：什么是垃圾回收？
【考题题干】下面哪一种说法是正确的，请选择一个正确的答案。
A ．利用关键词delete 可以明确地销毁对象。
B ．对象变得不可达后马上被垃圾收集掉。
C ．如果对象obja 对于对象objb 而言是可达的，对象objb 对于对象obja 而言也是可达的，则obja
和objb 都不适用于垃圾收集。
D ．对象一旦变得适用于垃圾收集，则在被销毁之前它会保持着这种适用性。
E ．对于对象obja 可以访问适用于垃圾收集的对象objb，在obja 同样适用于垃圾收集。
【试题分析】
在本面试题中，如果所有声名的对象引用都是来自其他也适合进行垃圾收集的对象，这个对象就是
最适合进行垃圾收集的。所以，如果对象objb 适合进行垃圾收集，而且对象obja 包含执行objb 的引用，
那么对象obja 也必须进行垃圾收集。Java 没有delete 关键词。对象在变得不可达之后不必马上作为垃圾
被收集，该对象只是适合垃圾收集。
只要对象可以被任何存活线程访问，就不适合进行垃圾收集，一个已经成为垃圾收集目标的对象还
可以消除这种适合性。当对象的finalize()方法创建了一个指向该对象的可达引用时，就可以出现这种情
况。
【参考答案】E
面试题22 ：什么地方该对象变得适用于垃圾收集？
【考题题干】对于最初由gc4 所引用的对象，该对象在如下程序中的什么地方变得适用于垃圾收集？
1 public class GcDemo {
2 public static void main(String[] args) {
3 String gc1;
4 String gc2 = “This name was called with gc2 “;
5 String gc3 = ” This name was called with gc3″;
6 String gc4 = new String((args.length > 0) ? “” + args[0] + “‘”
7 : “< no argument>”);
8 gc1 = gc4;
9 gc4 = null;
10 gc1 = gc2 + gc1 + gc3;
11 gc2 = null;
12 System.out.println(gc1);
13 gc1 = null;
14 gc3 = null;
15 args = null;
16 }
17 }
请选择正确的 1 个答案：
A ．从标签为9 的那一行以后。
B ．从标签为10 的那一行以后。
C ．从标签为11 的那一行以后。
D ．从标签为 13 的那一行以后。
E ．从标签为14 的那一行以后。
F ．从标签为 15 的那一行以后。
【试题分析】如果一个对象赋值为null 或者重新定向了该对象的引用者，则该对象被认定为变得适
用于垃圾收集。在9 行之前，最初被gc4 引用的String 对象由gc1 和gc4 来表示。在9 行之后，该String
对象就只由gc1 来表示。在 10 行之后，引用gc1 被赋予一个null 值，即不在指向该对象的引用。而 10
行之后，该对象已经没有引用了。
【参考答案】B
面试题23 ：关于finalize()描述正确的是选项是什么？
【考题题干】下面的有关Java 垃圾收集的说法，哪一个是正确的？请选择一个正确的答案：
A ．所有的对象都有一个finalize()方法。
B ．可以通过明确调用finalize()方法而销毁对象。
C ．finalize()方法声明时可以带有任何可访问性修饰符。
D ．对于适用于垃圾收集的对象而言，如果它的finalize()方法在执行期间抛出了异常，则Java 会忽
略该异常并销毁该对象。
E ．如果代码中所定义的覆盖 finalize()方法并没有明确调用父类中的被覆盖 finalize()方法，则编译
器将无法编译。
【试题分析】Object 对象有一个finalize()方法，由于所有的类都是从Object 类继承来的，因此，所
有的对象都有一个finalize()方法，所以A 选项是正确的。
类可以覆盖finalize()方法，而且和普通的方法覆盖规则一样，不能降低finalize()方法的可访问性。
调用finalize()方法本身不会破坏该对象。所以B 选项和C 选项是错误的。
当JVM 的拦截收集器调用一个合适对象的finalize()方法是，它会忽略任何由 finalize()方法抛出的
异常。其他情况下，finalize()方法中的异常处理，并没有特殊的规定，同普通方法处理异常是一样的，
所以D 选项是错误的。子类继承父类，则自动拥有父类的全部的public 的属性和方法，所以E 选项的
说法显然也是错误的。
【参考答案】A
面试题24 ：什么是垃圾收集
【考题题干】关于垃圾收集的哪些叙述是对的？
A ．垃圾收集将检查并释放不再使用的内存。
B ．垃圾收集允许程序开发者明确指定并立即释放该内存。
C ．程序开发者必须自己创建一个线程进行内存释放的工作。
D ．垃圾收集能够在期望的时间释放被Java 对象使用的内存。
【试题分析】Java 语言将内存分配和释放的工组交给了自己，程序员不必做这些工作，它提供一个
系统级的线程跟踪每个内存的分配，在 JVM 的空闲处理中，垃圾收集线程将检查和释放不再使用的内
存（即可以被释放的内存）。垃圾收集的过程在Java 程序的生存期中是自动的，不需要分配和释放内存，
也避免了内存泄漏。可以调用 System.gc()方法建议JVM 执行垃圾收集以使得可被释放的内存能立即被
使用，当此方法返回的时候，JVM 已经做了最大的努力从被丢弃的对象上回收内存空间。程序员不能指
定收集哪些内存，一般而言也不用关心这个问题，除非是程序的内存消耗很大，特别是有很多临时对象
时可以“建议“进行垃圾收集以提高可用内存。需要指出的是调用 System.gc()方法不能保证JVM 立即
进行垃圾收集，而只能是建议, 因为垃圾收集线程的优先级很低（通常是最低的）。
JVM 垃圾收集器收集一个对象之前，一般要求程序调用适当的方法释放资源，但在没有明确释放资
源的情况下，Java 提供了缺省机制来终止化该对象心释放资源，这个方法就是 finalize( ) 。因此选项A
是正确的。
垃圾收集器不可以被强制执行，但程序员可以通过调用System. gc 方法来建议执行垃圾收集器。因
此选项B 是错误的。
Java 的垃圾回收机制是为所有Java 应用进程服务的，而不是为某个特定的进程服务的。因此，任何
一个进程都没有权利去命令垃圾回收机制做什么、怎么做或做多少。因此选项C 是错误的。
Java 运行时系统只在需要的时候才使用垃圾收集。因此用户无法知道垃圾回收发生的精确时间。同
样没有办法预知在一组均符合垃圾收集器收集标准的对象中，哪一个会被首先收集。因此选项D 是错误
的。
【参考答案】A
面试题25 ：哪个是FileInputStream 类的构造方法的参数。
【考题题干】下面选项中，哪个选项的内容可以作为FileInputStream 类的构造方法的参数？
A ．File
B ．String
C ．InputStream
D ．FileOutputStream
【试题分析】主要参考FileInputStream 的构造方法，FileInputStream 类的构造方法有3 个，可接受
的参数分别是：File 、FileDescriptor、String 类的一个对象。
【参考答案】AB
面试题26 ：如何建立文件“file.txt”。
【考题题干】下面选项中，哪个选项可以正确的建立文件file.txt ？
A ．File f = new File( ＂D:text ＂, ＂file.txt ＂);
B ．File f = new File( ＂D:\text ＂, ＂file.txt ＂);
C ．File f = new File( ＂file.txt ＂, ＂D:/text ＂);
D ．File f = new File( ＂D:/text ＂, ＂file.txt ＂);
【试题分析】主在参考File 的构造方法，值得说明一下的是B 选项中的 ＂D:\text ＂其是＂\ ＂是＂
/ ＂的转义字符，故B 选项也是正确的。
【参考答案】BD
面试题27 ：什么是System.out
【考题题干】下面选项中，关于System.out 说法，哪个是正确的？
A ．System.out 是 1 个PrintStream 。
B ．System.out 是 1 个OutputStream 。
C ．System.out 是 1 个FilterOutputStream 。
D ．System.out 是 1 个OutputStreamWriter 。
E ．System.out 在异常时，将抛出IOException 。
【试题分析】本面试题中，通过JDK API 可以看出，out 是FilterOutputStream 类内的封装的一个过
滤的基础输出流的字段。然而FilterOutputStream 类又是OutputStream 类的直接子类，并且out 的返回值
类型也是OutputStream，所以BC 两个选项都是正确的。PrintStream 类是FilterOutputStream 类的直接子
类，所以它可以从FilterOutputStream 类中继承的out 字段，所以A 选项也是正确的。但是PrintStream
与其他输出流不同，PrintStream 不会抛出 IOException ；而是，异常情况仅设置可通过checkError 方法
测试的内部标志。所以E 选项是错误的。out 是针对字节流的输出，而不是字符流所以D 选项是错误的。
【参考答案】ABC
面试题28 ：如何创建一个 InputStreamReader 的实例？
【考题题干】下面哪个语句能够正确地创建一个InputStreamReader 的实例？
A ．new InputStreamReader(new FileInputStream( ＂data ＂));
B ．new InputStreamReader(new FileReader( ＂data ＂));
C ．new InputStreamReader(new BufferedReader( ＂data ＂));
D ．new InputStreamReader( ＂data ＂);
E ．new InputStreamReader(System.in);
【参考答案】AE
面试题29 ：根据类的描述选择正确答案
【考题题干】下面的程序中，关于类的描述哪一个是正确的
1. public class Barbell {
2. public int getWeight() {
3. return weight;
4. }
5. public void setWeight(int w) {
6. weight = w;
7. }
8. public int weight;
9. }
选择一个正确答案：
A ．Class Barbell 是严密封装的
B ．第2 行与类的封装相冲突
C ．第5 行与类的封装相冲突
D ．第8 行与类的封装相冲突
E ．第5 行和第8 行与类的封装相冲突
F ．第2 ，5 行和第8 行与类的封装相冲突
【参考答案】D
面试题30 ：关于多态的问答题
【考题题干】Java 中实现多态的机制是什么？
【参考答案】方法的重写Overriding 和重载Overloading 是Java 多态性的不同表现。重写Overriding
是父类与子类之间多态性的一种表现，重载Overloading 是一个类中多态性的一种表现。
面试题31 ：关于内部类的问答题
【考题题干】静态内部类(Static Nested Class) 和内部类（ Inner Class ）有什么不同？
【参考答案】
Static Nested Class 是被声明为静态（static ）的内部类，它可以不依赖于外部类实例被实例化。而通
常的内部类需要在外部类实例化后才能实例化。
面试题32 ：关于抽象方法的问题
【考题题干】抽象方法是否可同时是static，是否可同时是native ，是否可同时是synchronized?
【试题分析】首先static 的方法只能被子类里static 的方法所覆盖，不能表现出多态，因为多态性是
通过引用来达到的，所以 abstract 和static 不可以同时使用。native 的方法是通过引入c/c++或其他本地
语言来实现的，而引入实现的库在static 块或方法里，无法引入不同的实现，所以也不能同时使用abstract
和native 。synchronized 和abstract 也不能混合使用，因为synchronize 同步的是同一对象，而不是不同实
现的不同对象。
【参考答案】都不能。
面试题33 ：关于抽象类和接口的问答题
【考题题干】abstract class （抽象类）和interface （接口）有什么区别?
【试题分析】抽象类的特征如下：
?8?0 抽象类和抽象方法都必须用abstract 关键字来修饰。
?8?0 抽象类不能被实例化，也就是不能用new 关键字去产生对象。
?8?0 抽象方法只需声明，而不需实现。
?8?0 抽象方法必须定义在抽象类中，抽象类的子类必须实现父类中的抽象方法，否则这个子类还
是个抽象类。
接口的特征如下：
?8?0 接口没有构造方法。
?8?0 接口中声明变量均为终极（final ）的、静态（static）的和公共（public ）的。
?8?0 接口是定义的方法均为抽象的和公共的。
?8?0 接口里的数据成员必须初始化，且数据成员均为常量。
【参考答案】声明方法的存在而不去实现它的类被叫做抽象类（abstract class ），它用于要创建一个
体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。不能创建abstract 类的
实例。然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。不能有抽象构
造函数或抽象静态方法。Abstract 类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象
类为。取而代之，在子类中实现该方法。知道其行为的其它类可以在类中实现这些方法。
接口（interface ）是抽象类的变体。在接口中，所有方法都是抽象的。多继承性可通过实现这样的
接口而获得。接口中的所有方法都是抽象的，没有一个有程序体。接口只可以定义static final 成员变量。
接口的实现与子类相似，除了该实现类不能从接口定义中继承行为。当类实现特殊接口时，它定义（即
将程序体给予）所有这种接口的方法。然后，它可以在实现了该接口的类的任何对象上调用接口的方法。
由于有抽象类，它允许使用接口名作为引用变量的类型。通常的动态联编将生效。
面试题34 ：重写和重载的区别
方法的重写和重载是Java 多态性的不同表现。重写是父类与子类之间多态性的一种表现，重载是一
个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重
写。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被＂屏蔽＂了。
如果在一个类中定义了多个同名的方法，它们有不同的参数个数、参数类型和参数顺序，则称为方法的
重载。重载的方法是可以改变返回值的类型。
面试题35 ：哪些方法可以加入类Man 中
【考题题干】仔细分析下列代码，选择正确的答案。
public class Person{
public int add (int i, int j ) {
int x;
x = i + j ;
return x;
}
}
class Man extends Person {
}
请选择正确的答案：
A ．public int add ( int i ){}
B ．public int add( int i， int j )throws MyException {}
C ．int add( int i， int j ){}
D ．public void add (){}
【试题分析】此题涉及方法重载（overload ），方法重写（override ）以及类派生时方法重写的规则。
方法重载的规则是：方法名必须相同，参数列表（参数的个数和参数类型）必须不同，参数的须序可以
不同返回值类型可以不同方法重写发生在类继承时，子类可以覆盖一个父类中已有的方法，但必须在返
回类和参数列表一样时才能说是重写，否则就是重载。
Java 中方法重写的一个重要而且容易被忽略的规则是被子类重写的方法的访问权限大于被重写方
法的是访问权限，重写的另一个规则是重写的方法不能比被重写方法抛(throws)更多种类的异常，其抛
弃的异常只能少，或者是其子类，当然了不能以抛弃异常的个数来判断种类，而应该是异常类层次结果
上的种类。
此题中答案C 的错误就是重写的访问权限比被重写的方法的低，而A，D 都属于重载，B 的错误在
于比被重写的方法抛弃了更多种类的异常。
【参考答案】AD
面试题36 ：针对this()方法的找错题
【考题题干】下列代码在编译的过程中有错误，请找出错误的位置。
1 class Woman {
2 String name, address;
3 int age;
4 public Woman(String n) {
5 name = n;
6 }
7 public Woman(String n, int a) {
8 name = n;
9 age = a;
10 }
11 public Woman(String n, String ar, int a) {
12 this(name,age);
13 address = ar;
14 }
15 }
【试题分析】在同一个类的不同构造方法中调用该类的其它构造方法需要使用this( ?6?7) 的形式，而
且必须是在构造方法的第一行调用，第 12 行的错误在于把成员变量作为参数被构造函数引用。构造方
法是一个类对象实例化的起点，实例化的目的就是为了给类成员初始化，所以引用的参数值应该是常量
而不能是变量因此在构造方法中不能将成员作为参数引用。
【参考答案】第12 行有错误。
面试题37 ：简要回答创建线程的两种方式及区别
有两种实现方法，分别是继承Thread 类与实现Runnable 接口。
实现Runnable 接口除了拥有和继承Thread 类一样的功能以外，实现Runnable 接口还具有以下功能。
?8?0 适合多个相同程序代码的线程去处理同一资源的情况，可以把线程同程序中的数据有效的分离，
较好地体现了面向对象的设计思想。
?8?0 可以避免由于Java 的单继承特性带来的局限。例如，class Student 已经继承了class Person，如
果要把Student 类放入多线程中去，那么就不能使用继承Thread 类的方式。因为在Java 中规定
了一个类只能有一个父类，不能同时有两个父类。所以就只能使用实现Runnable 接口的方式了。
?8?0 增强了代码的健壮性，代码能够被多个线程共同访问，代码与数据是独立的。多个线程可以操
作相同的数据，与它们的代码无关。当线程被构造时，需要的代码和数据通过一个对象作为构
造函数实参传递进去，这个对象就是一个实现了Runnable 接口的类的实例。
面试题38 ：说出线程同步的方法
同步是一种各线程间协调使用共享资源的一种方式。各线程间的相互通信是实现同步的重要因素，
所以Java 提供了wait()和notify()等方法来使线程之间可以相互通信。
?8?0 wait() ：使线程处于等待状态，并且释放所持有的对象的 lock 。可以与 notify() 方法配套使用。
它有两种形式，一种是以毫秒为单位的一段时间作为参数，另一种是没有参数。
?8?0 sleep() ：使一个正在运行的线程处于阻塞状态，可以以毫秒为单位的一段时间作为参数，它可
以使得线程在设定的时间停止运行，但是在设定的时间一过，线程重新进入可执行状态。由于
sleep()是一个静态方法，所以调用此方法要捕捉InterruptedException 异常。
?8?0 notify() ：唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某
一个等待状态的线程，而是由JVM 确定唤醒哪个线程，而且不是按优先级。
?8?0 allnotity() ：唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让
它们竞争。只有获得锁的那一个线程才能进入可执行状态。
面试题39 ：分析程序推测输出结果（指向不同类实例的多线锃）
【考题题干】根据下列程序，试着分析输出结果是什么？
class ThreadA {
public static void main(String[] args) {
ThreadB b = new ThreadB();
Threadc c = new Threadc();
c.setName(“第二线程”);
b.setName(“第一线程”);
c.start();
System.out.println(Thread.currentThread().getName()+” is start….”);
synchronized (c)
{
try {
System.out.println(“Waiting for b1 to complete…”);
c.wait();
System.out.println(“Completed.Now back to “+Thread.currentThread().getName());
b.start();
} catch (InterruptedException e) {
}
}
}
}
class ThreadB extends Thread {
int total;
public void run() {
synchronized (this) {
System.out.println(Thread.currentThread().getName()+”is running..”);
for (int i = 0; i < 10; i++) {
total += i;
}
System.out.println(“total is ” + total);
}
}
}
class Threadc extends Thread {
int sum=1;
public void run() {
synchronized (this) {
System.out.println(Thread.currentThread().getName()+”is running..”);
for (int i = 1; i < 10; i++) {
sum *= i;
}
System.out.println(“sum is ” + sum);
notify();
}
}
}
【试题分析】要分析这个程序，首先要理解 notify()和 wait() 。wait()使线程处于等待状态，并且释
放所持有的对象的锁，如果一个线程调用了wait() ，那么就必须等待其他的线程调用该方法的notify()，
将其唤醒。
wait()可以使同步方法或者同步块暂时放弃对象锁，而将它暂时让给其他需要对象锁的线程用，这
就意味着在执行wait()期间可以调用线程对象中的其他同步方法。synchronized(c){…} ；的意思是定义一
个同步块，使用c 作为资源锁。c.wait(); 的意思是临时释放锁，进入等待状态，好让其他使用同一把锁的
线程有机会执行，在这里要用同一把锁的就是b 线程。这个线程调用start()方法在run()方法中执行到一
定地方后用notify() 唤醒处于wait 的c 线程，待notify()所在的同步块运行完之后，c 线程就可以继续执
行了。
【参考答案】 main is start….
Waiting for b1 to complete…
第二线程is running..
sum is 362880
Completed.Now back to main
第一线程is running..
total is 45
面试题40 ：sleep()和wait()有什么区别?
sleep 是线程类（Thread ）的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监
控状态依然保持，到时后会自动恢复。调用sleep 不会释放对象锁。
wait 是 Object 类的方法，对此对象调用 wait 方法导致本线程放弃对象锁，进入等待此对象的等待
锁定池。只有针对此对象发出notify 方法（或notifyAll ）后，本线程才进入对象锁定池准备获得对象锁
进入运行状态。
面试题41 ：关于yield()方法的选择题
【考题题干】调用yield()方法有什么作用？
请从下面选项中选择一个正确的答案：
A ．当前线程停止，知道其他线程终止。
B ．当前线程休眠一段时间，其他线程运行。
C ．所有优先级较低的线程获得CPU 时间。
D ．线程将等待，直到被通知。
E ．以上都不正确。
【试题分析】yield()是指暂停当前正在执行的线程对象，并执行其他线程。暂停执行是指当前线程
放弃所分得的 CPU 资源，并不是使线程处于阻塞状态，即线程仍处于可执行状态，随时可能再次分得
CPU 。调用yield() 的效果等价于调度程序认为该线程已执行了足够的时间从而转到另一个线程。
【参考答案】E
面试题42 ：Math. ceil(-6.8)的值等于多少
【考题题干】请从下面选项中选择Math. ceil(-6.8) 的返回值。
A ．-6.0
B ．-7.0
C ．-6.5
D ．-5.0
【试题分析】
Ceil 方法的含义是返回最小的（最接近负无穷大）double 值，该值大于或等于参数，并且等于某个
整数。可知道正确答案为-6.0。
【参考答案】A
面试题43 ：不能被外部类所访问的修饰符有哪些
【考题题干】类的设计要求它的某个成员变量不能被外部类直接访问。应该使用下面的哪些修饰符
获得需要的访问控制。
A ．public
B ．no modifier
C ．protected
D ．private
【试题分析】Java 有4 种访问类型，分别为public 、protected 、default 和private 。其中public 变量
可以被所有的外部类访问，而pretected 的可以被同一个包及该类的子类访问，default 即没有任何修饰符
的变量可以被同一个包中的类访问，而private 变量只能在被该类内部被访问。题目中的外部类应该理解
为除该类自身的所有其他类，因此只有使用private 可以达到要求。
【参考答案】D
面试题44 ：只能被同包中的类访问的修饰符有哪些
【考题题干】一个类中定义的成员变量只能被同一包中的类访问。下面的哪些修饰符可以获得需要
的访问控制。
A ．private
B ．no modifier
C ．public
D ．protected
【试题分析】同上
【参考答案】B
面试题45 ：HashMap 和Hashtable 的区别
HashMap 是Hashtable 的轻量级实现（非线程安全的实现），它们都完成了Map 接口，主要区别在
于HashMap 允许空（null ）键值（key ）。由于非线程安全，效率上可能高于Hashtable 。HashMap 允许
将null 作为一个entry 的key 或者value ，而Hashtable 不允许。HashMap 把Hashtable 的contains 方法去
掉了，改成containsvalue 和containsKey 。因为contains 方法容易让人引起误解。Hashtable 继承自Dictionary
类，而HashMap 是Java1.2 引进的Map interface 的一个实现。
最大的不同是，Hashtable 的方法是Synchronize 的，而HashMap 不是，在多个线程访问Hashtable
时，不需要自己为它的方法实现同步，而HashMap 就必须为之提供外同步。Hashtable 和HashMap 采用
的hash/rehash 算法都大概一样，所以性能不会有很大的差异。
面试题46 ：关于ArrayList,Vector, LinkedList 的问答题
【考题题干】说出ArrayList 、Vector 、LinkedList 的存储性能和特性
【参考答案】ArrayList 和 Vector 都是使用数组方式存储数据，此数组元素数大于实际存储的数据
以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，
所以索引数据快而插入数据慢。由于Vector 使用了synchronized 方法（线程安全），通常性能上较ArrayList
差，而LinkedList 使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时
只需要记录本项的前后项即可，所以插入速度较快。
面试题47 ：实现Map 接口的对象有哪些
【考题题干】对实现Map 接口的对象，可以调用下面哪些方法？
请选择2 个正确的答案：
A ．contains(Object o)
B ．addAll(Collection col)
C ．remove(Object o)
D ．values()
E ．toArray()
【试题分析】本面试题中，只有Map 定义了remove()和values() 。并没有定义contains(Object o) 、
addAll(Collection col) 和 toArray() 方法，这些方法都是在 Collection 中定义的，而 Map 并没有继承
Collection 。
【参考答案】CD
面试题48 ：在Servlet 生命周期中，哪个方法只能调用一次
【考题题干】在Servlet 的生命周期中，容器只调用一次的方法是什么？请选出正确的选项。
A ．service
B ．getServletConfig
C ．after
D ．init
【试题分析】参考Servlet 的生命周期
【参考答案】D
面试题49 ：Servlet 的class 文件放在哪个目录下
【考题题干】假设在helloapp 应用中有一个HelloServlet 类，它位于org.javathinker 包下，那么
这个类的class 文件应该放在什么目录下?下面选项中，哪个选项是正确的？
A ．helloapp/HelloServlet.class
B ．helloapp/WEB-INF/HelloServlet.class
C ．helloapp/WEB-INF/classes/HelloServlet.class
D ．helloapp/WEB-INF/classes/org/javathinker/HelloServlet.class
【参考答案】D
面试题50 ：了解Cookie 的工作流程
【考题题干】如何发送Cookie?下面选项中哪个是正确的？
A ．使用new Cookie 语句
B ．调用response.addCookie()方法
C ．使用Cookie 的setMaxAge()方法
D ．setCookie()方法
【试题分析】
在Cookie 发送到客户端前，先要通进new Cookie 创建一个Cookie 。所以A 选项是错误的。
然后用addCookie 方法发送一个HTTP Header 。JSP 将调用request.getCookies()从客户端读入Cookie，
getCookies()方法返回一个HTTP 请求头中的内容对应的Cookie 对象数组。你只需要用循环访问该数组
的各个元素，调用getName 方法检查各个Cookie 的名字，直至找到目标Cookie ，然后对该Cookie 调用
getValue 方法取得与指定名字关联的值。故B 选项是正确的。
setMaxAge(int expiry) : 以秒计算，设置Cookie 过期时间。所以C 选项是错误的。
没有setCookie()这个方法，所以D 选项是错误的。
【参考答案】B
