java面试题总结(三)----本文都是笔试题，值得学习

1. 下面哪些是Thread类的方法（）

A start() B run() C exit() D getPriority()

答案：ABD

解析：看Java API docs吧：http://docs.oracle.com/javase/7/docs/api/，exit()是System类的方法，如System.exit(0)。

2. 下面关于java.lang.Exception类的说法正确的是（）

A 继承自Throwable B Serialable CD 不记得，反正不正确

答案：A

解析：Java异常的基类为java.lang.Throwable，java.lang.Error和java.lang.Exception继承 Throwable，RuntimeException和其它的Exception等继承Exception，具体的RuntimeException继承RuntimeException。

扩展：错误和异常的区别(Error vs Exception)

1) java.lang.Error: Throwable的子类，用于标记严重错误。合理的应用程序不应该去try/catch这种错误。绝大多数的错误都是非正常的，就根本不该出现的。
java.lang.Exception: Throwable的子类，用于指示一种合理的程序想去catch的条件。即它仅仅是一种程序运行条件，而非严重错误，并且鼓励用户程序去catch它。

2) Error和RuntimeException 及其子类都是未检查的异常（unchecked exceptions），而所有其他的Exception类都是检查了的异常（checked exceptions）.
checked exceptions: 通常是从一个可以恢复的程序中抛出来的，并且最好能够从这种异常中使用程序恢复。比如FileNotFoundException, ParseException等。检查了的异常发生在编译阶段，必须要使用try…catch（或者throws）否则编译不通过。
unchecked exceptions: 通常是如果一切正常的话本不该发生的异常，但是的确发生了。发生在运行期，具有不确定性，主要是由于程序的逻辑问题所引起的。比如ArrayIndexOutOfBoundException, ClassCastException等。从语言本身的角度讲，程序不该去catch这类异常，虽然能够从诸如RuntimeException这样的异常中catch并恢复，但是并不鼓励终端程序员这么做，因为完全没要必要。因为这类错误本身就是bug，应该被修复，出现此类错误时程序就应该立即停止执行。因此，面对Errors和unchecked exceptions应该让程序自动终止执行，程序员不该做诸如try/catch这样的事情，而是应该查明原因，修改代码逻辑。

RuntimeException：RuntimeException体系包括错误的类型转换、数组越界访问和试图访问空指针等等。

处理RuntimeException的原则是：如果出现 RuntimeException，那么一定是程序员的错误。例如，可以通过检查数组下标和数组边界来避免数组越界访问异常。其他（IOException等等）checked异常一般是外部错误，例如试图从文件尾后读取数据等，这并不是程序本身的错误，而是在应用环境中出现的外部错误。

9. volatile关键字是否能保证线程安全？（）

答案：不能

解析：volatile关键字用在多线程同步中，可保证读取的可见性，JVM只是保证从主内存加载到线程工作内存的值是最新的读取值，而非cache中。但多个线程对

volatile的写操作，无法保证线程安全。例如假如线程1，线程2 在进行read,load 操作中，发现主内存中count的值都是5，那么都会加载这个最新的值，在线程1堆count进行修改之后，会write到主内存中，主内存中的count变量就会变为6；线程2由于已经进行read,load操作，在进行运算之后，也会更新主内存count的变量值为6；导致两个线程及时用volatile关键字修改之后，还是会存在并发的情况。

11. 存在使i + 1 < i的数吗（）

答案：存在

解析：如果i为int型，那么当i为int能表示的最大整数时，i+1就溢出变成负数了，此时不就<i了吗。

扩展：存在使i > j || i <= j不成立的数吗（）

答案：存在

解析：比如Double.NaN或Float.NaN，感谢@BuilderQiu网友指出。

12. 0.6332的数据类型是（）

A float B double C Float D Double

答案：B

解析：默认为double型，如果为float型需要加上f显示说明，即0.6332f

15. 不通过构造函数也能创建对象吗（）

A 是 B 否

答案：A

解析：Java创建对象的几种方式（重要）：

(1) 用new语句创建对象，这是最常见的创建对象的方法。
(2) 运用反射手段,调用java.lang.Class或者java.lang.reflect.Constructor类的newInstance()实例方法。
(3) 调用对象的clone()方法。
(4) 运用反序列化手段，调用java.io.ObjectInputStream对象的 readObject()方法。

(1)和(2)都会明确的显式的调用构造函数；(3)是在内存上对已有对象的影印，所以不会调用构造函数；(4)是从文件中还原类的对象，也不会调用构造函数。

16. ArrayList list = new ArrayList(20);中的list扩充几次（）

A 0 B 1 C 2 D 3

答案：A

解析：这里有点迷惑人，大家都知道默认ArrayList的长度是10个，所以如果你要往list里添加20个元素肯定要扩充一次（扩充为原来的1.5倍），但是这里显示指明了需要多少空间，所以就一次性为你分配这么多空间，也就是不需要扩充了。

19. 下面程序能正常运行吗（）

public class NULL {

public static void haha(){
System.out.println("haha");
}
public static void main(String[] args) {
((NULL)null).haha();
}

}
答案：能正常运行

解析：输出为haha，因为null值可以强制转换为任何java类类型,(String)null也是合法的。但null强制转换后是无效对象，其返回值还是为null，而static方法的调用是和类名绑定的，不借助对象进行访问所以能正确输出。反过来，没有static修饰就只能用对象进行访问，使用null调用对象肯定会报空指针错了。这里和C++很类似。这里感谢@Florian网友解答。

20. 下面程序的运行结果是什么（）

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) {
　　　　 new HelloB();
　　 }

}
答案：

static A
static B
I'm A class
HelloA
I'm B class
HelloB
解析：说实话我觉得这题很好，考查静态语句块、构造语句块（就是只有大括号的那块）以及构造函数的执行顺序。

对象的初始化顺序：（1）类加载之后，按从上到下（从父类到子类）执行被static修饰的语句；（2）当static语句执行完之后,再执行main方法；（3）如果有语句new了自身的对象，将从上到下执行构造代码块、构造器（两者可以说绑定在一起）。

22. 下面代码的运行结果为：（）

import java.io.*;
import java.util.*;

public class foo{

public static void main (String[] args){

String s;

System.out.println("s=" + s);

}

}
A 代码得到编译，并输出“s=”

B 代码得到编译，并输出“s=null”

C 由于String s没有初始化，代码不能编译通过

D 代码得到编译，但捕获到 NullPointException异常

答案：C

解析：开始以为会输出null什么的，运行后才发现Java中所有定义的基本类型或对象都必须初始化才能输出值。

24. 指出下列程序运行的结果（）这道题很有价值

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

答案：B

解析：大家可能以为Java中String和数组都是对象所以肯定是对象引用，然后就会选D，其实这是个很大的误区：因为在java里没有引用传递，只有值传递

这个值指的是实参的地址的拷贝，得到这个拷贝地址后，你可以通过它修改这个地址的内容（引用不变），因为此时这个内容的地址和原地址是同一地址，

但是你不能改变这个地址本身使其重新引用其它的对象，也就是值传递，可能说的不是很清楚，下面给出一个完整的能说明情况的例子吧：

package test;

/**
* @description Java中没有引用传递只有值传递
*
* @author Alexia
* @date 2013-10-16
*
*/
class Person {

private String name;

private String sex;

public Person(String x, String y) {
this.name = x;
this.sex = y;
}

// 重写toString()方法，方便输出
public String toString() {

return name + " " + sex;
}

// 交换对象引用
public static void swapObject(Person p1, Person p2) {
Person tmp = p1;
p1 = p2;
p2 = tmp;
}

// 交换基本类型
public static void swapInt(int a, int b) {
int tmp = a;
a = b;
b = tmp;
}

// 交换对象数组
public static void swapObjectArray(Person[] p1, Person[] p2) {
Person[] tmp = p1;
p1 = p2;
p2 = tmp;
}

// 交换基本类型数组
public static void swapIntArray(int[] x, int[] y) {
int[] tmp = x;
x = y;
y = tmp;
}

// 改变对象数组中的内容
public static void changeObjectArray(Person[] p1, Person[] p2) {
Person tmp = p1[1];
p1[1] = p2[1];
p2[1] = tmp;

// 再将p1[1]修改
Person p = new Person("wjl", "male");
p1[1] = p;
}

// 改变基本类型数组中的内容
public static void changeIntArray(int[] x, int[] y) {
int tmp = x[1];
x[1] = y[1];
y[1] = tmp;

x[1] = 5;
}
}

public class ByValueTest {

public static void main(String[] args) {

// 建立并构造两个对象
Person p1 = new Person("Alexia", "female");
Person p2 = new Person("Edward", "male");

System.out.println("对象交换前：p1 = " + p1.toString());
System.out.println("对象交换前：p2 = " + p2.toString());

// 交换p1对象和p2对象
Person.swapObject(p1, p2);
// 从交换结果中看出，实际对象并未交换
System.out.println("\n对象交换后：p1 = " + p1.toString());
System.out.println("对象交换后：p2 = " + p2.toString());

// 建立两个对象数组
Person[] arraya = new Person[2];
Person[] arrayb = new Person[2];

// 分别构造数组对象
arraya[0] = new Person("Alexia", "female");
arraya[1] = new Person("Edward", "male");
arrayb[0] = new Person("jmwang", "female");
arrayb[1] = new Person("hwu", "male");

System.out.println('\n' + "对象数组交换前：arraya[0] = "
+ arraya[0].toString() + ", arraya[1] = "
+ arraya[1].toString());
System.out.println("对象数组交换前：arrayb[0] = "
+ arrayb[0].toString() + ", arrayb[1] = "
+ arrayb[1].toString());

// 交换这两个对象数组
Person.swapObjectArray(arraya, arrayb);
System.out.println('\n' + "对象数组交换后：arraya[0] = "
+ arraya[0].toString() + ", arraya[1] = "
+ arraya[1].toString());
System.out.println("对象数组交换后：arrayb[0] = "
+ arrayb[0].toString() + ", arrayb[1] = "
+ arrayb[1].toString());

// 建立两个普通数组
int[] a = new int[2];
int[] b = new int[2];

// 给数组个元素赋值
for (int i = 0; i < a.length; i++) {
a[i] = i;
b[i] = i + 1;
}

System.out.println('\n' + "基本类型数组交换前：a[0] = " + a[0] + ", a[1] = " + a[1]);
System.out.println("基本类型数组交换前：b[0] = " + b[0] + ", b[1] = " + b[1]);

// 交换两个基本类型数组
Person.swapIntArray(a, b);
System.out.println('\n' + "基本类型数组交换后：a[0] = " + a[0] + ", a[1] = " + a[1]);
System.out.println("基本类型数组交换后：b[0] = " + b[0] + ", b[1] = " + b[1]);

// 改变对象数组的内容
Person.changeObjectArray(arraya, arrayb);
System.out.println('\n' + "对象数组内容交换并改变后：arraya[1] = " + arraya[1].toString());
System.out.println("对象数组内容交换并改变后：arrayb[1] = " + arrayb[1].toString());

// 改变基本类型数组的内容
Person.changeIntArray(a, b);
System.out.println('\n' + "基本类型数组内容交换并改变后：a[1] = " + a[1]);
System.out.println("基本类型数组内容交换并改变后：b[1] = " + b[1]);
}
}
程序有些啰嗦，但能反映问题，该程序运行结果为：

对象交换前：p1 = Alexia female
对象交换前：p2 = Edward male

对象交换后：p1 = Alexia female
对象交换后：p2 = Edward male

对象数组交换前：arraya[0] = Alexia female, arraya[1] = Edward male
对象数组交换前：arrayb[0] = jmwang female, arrayb[1] = hwu male

对象数组交换后：arraya[0] = Alexia female, arraya[1] = Edward male
对象数组交换后：arrayb[0] = jmwang female, arrayb[1] = hwu male

基本类型数组交换前：a[0] = 0, a[1] = 1
基本类型数组交换前：b[0] = 1, b[1] = 2

基本类型数组交换后：a[0] = 0, a[1] = 1
基本类型数组交换后：b[0] = 1, b[1] = 2

对象数组内容交换并改变后：arraya[1] = wjl male
对象数组内容交换并改变后：arrayb[1] = Edward male

基本类型数组内容交换并改变后：a[1] = 5
基本类型数组内容交换并改变后：b[1] = 1
说明：不管是对象、基本类型还是对象数组、基本类型数组，在函数中都不能改变其实际地址但能改变其中的内容。

27. 下面的方法，当输入为2的时候返回值是多少?（）

public static int 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;
}
return result;
}
A0 B2 C4 D10

答案：D

解析：注意这里case后面没有加break，所以从case 2开始一直往下运行。

28. 选项中哪一行代码可以替换题目中//add code here而不产生编译错误？（）

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() {}

答案：A

解析：考察抽象类的使用。

抽象类遵循的原则：

（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 型，其值可以在子类中重新定义，也可以在子类中重新赋值。

最后，给大家出个思考题：下面程序的运行结果是什么？

public class Dervied extends Base {

private String name = "dervied";

public Dervied() {
tellName();
printName();
}

public void tellName() {
System.out.println("Dervied tell name: " + name);
}

public void printName() {
System.out.println("Dervied print name: " + name);
}

public static void main(String[] args){

new Dervied();
}
}

class Base {

private String name = "base";

public Base() {
tellName();
printName();
}

public void tellName() {
System.out.println("Base tell name: " + name);
}

public void printName() {
System.out.println("Base print name: " + name);
}
}
输出结果

Dervied tell name: null
Dervied print name: null
Dervied tell name: dervied
Dervied print name: dervied

java面试题总结(三)----本文都是笔试题，值得学习相关推荐

【机试题】2014大疆嵌入式笔试题（附超详细解答，下篇）
上一篇主要是对<2014大疆嵌入式笔试题>的前一部分进行了解答,本文主要是对接下来的几道题进行解答.想要参考上一篇的点击链接:[机试题]2014大疆嵌入式笔试题(附超详细解答,上篇). 嵌 ...
php程序员试题,php面试题带答案,php程序员笔试题与答案(一)
php面试题带答案,php程序员笔试题与答案(一) php程序员招聘笔试题: 问题 1．选择合适的答案填入空白处 PHP 是一种______脚本语言,基于______引擎.PHP 最常被用来开发动态 ...
【笔试题】简单的两道笔试题（1、打印杨辉三角；2、三个数排序）
笔试题简单的两道笔试题(1.打印杨辉三角:2.三个数排序) 1.打印杨辉三角 import java.util.Scanner; public class MyYanghuiTriangle {pu ...
php mysql笔试题_初级PHP程序员笔试题
初级PHP程序员笔试题答题时间:60 – 90分钟一.基础及程序题(建议使用你擅长的语言:C/C++.PHP.Java) 1.写一个排序算法,可以是冒泡排序或者是快速排序,假设待排序对象是一个维数 ...
中兴校招c语言在线笔试题,中兴2017校招软件在线笔试题
硬件工程师Hardware Engineer职位要求熟悉计算机市场行情;制定计算机组装计划;能够选购组装需要的硬件设备,并能合理配置.安装计算机和外围设备;安装和配置计算机软件系统;保养硬件和外围设 ...
【机试题】2019大疆嵌入式笔试题A卷（附超详细解答）
前不久的大疆嵌入式线上笔试,可能是因为最近只是在做毕设项目,还没有来得及认真系统复习,直接崩了.就凭借着记忆,把一些记得住的笔试题分享一下,作下记录. 整个大疆嵌入式线上笔试,分为选择题(单选题.多选 ...
深信服笔试题 php,2019深信服校招笔试题------木板接水
2019深信服校招笔试题--木板接水题目: 空地上竖立着n个从左到右排列的木板,它们可以把水挡住,但溢出最边上木板的水将会流到空地上.已知木板间距都是单位1,现给定每个木板的高度,请求出总共能接住的 ...
html5 笔试题选择题,2019拼多多前端笔试题
选择.填空题: 1.IP地址,子网掩码的计算 2.Internet网络层重要协议 3.http请求方法 4.HTML中a标签的伪类 5.alert(undefined==null)的输出结果 6.ht ...
百度linux c面试题,【百度百度糯米算法百度LinuxC语言数据面试题】面试问题：百度笔试题… - 看准网...
第一部分选择题: 有几道网络相关的题目,巨简单,比如第一题是TCP.RIP.IP.FTP中哪个协议是传输层的.......有一道linux的chown使用题目.其他的全是数据结构的题目!什么链,表,码 ...

java面试题总结(三)----本文都是笔试题，值得学习

java面试题总结(三)----本文都是笔试题，值得学习相关推荐

最新文章

热门文章