JAVA开发岗笔试题集(updating)

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

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

答案：ABD

解析：exit()是System类的方法，如System.exit(0)。

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

A 继承自Throwable B Serialable 

答案：A

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

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

1) Error: Throwable的子类，用于标记严重错误。合理的应用程序不应该去try/catch这种错误。绝大多数的错误都是非正常的，就根本不该出现的。

Exception: Throwable的子类，用于指示一种合理的程序想去catch的条件。即它仅仅是一种程序运行条件，而非严重错误，并且鼓励用户程序去catch它。

2) Error和RuntimeException 及其子类都是非检查异常（unchecked exceptions），而所有其他的Exception类都是检查了的异常（checked exceptions）。

检查异常: 通常是从一个可以恢复的程序中抛出来的，并且最好能够从这种异常中使用程序恢复。比如FileNotFoundException, ParseException等。异常检查发生在编译阶段，必须要使用try…catch（或者throws）否则编译不通过。

非检查异常:通常是正常情况下不该发生的异常发生了。发生在运行期，具有不确定性，主要由于程序逻辑问题引起的。比如ArrayIndexOutOfBoundException, ClassCastException等。从语言本身的角度讲，程序不该去catch这类异常，虽然能够从诸如RuntimeException这样的异常中catch并恢复，但是并不鼓励终端程序员这么做，因为完全没要必要。因为这类错误本身就是bug，应该被修复，出现此类错误时程序就应该立即停止执行。 因此，面对Errors和unchecked exceptions应该让程序自动终止执行，程序员不该做诸如try/catch这样的事情，而是应该查明原因，修改代码逻辑。

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

3. 下面程序的运行结果是（）

String str1 = "hello";

String str2 = "he" + new String("llo");

System.out.println(str1 == str2);

答案：false

解析：因为str2中的llo是新申请的内存块，而==判断的是对象的地址而非值，所以不一样。如果是String str2 = str1，那么就是true了。

4. 下列说法正确的有（）

A． class中的constructor不可省略

B． constructor必须与class同名，但方法不能与class同名

C． constructor在一个对象被new时执行

D．一个class只能定义一个constructor

答案：C

解析：普通的类方法是可以和类名同名的，和构造方法的区别就是，构造方法没有返回值。

5. 具体选项不记得，但用到的知识如下：

String []a = new String[10];

则：a[0]~a[9] = null

a.length = 10

如果是int []a = new int[10];

则：a[0]~a[9] = 0

a.length = 10

6.下面程序的运行结果：（）

public static void main(String[] args) {

Thread t = new Thread() {

public void run() {

pong(); } };

t.run();

System.out.print("ping");

}

static void pong() {

System.out.print("pong");}

5. Statement, PreparedStatement和

CallableStatement的区别(1)

A pingpong   B pongping   C pingpong和pongping都有可能   D 都不输出

答案：B

解析：这里考的是Thread类中start()和run()方法的区别了。start()用来启动一个线程，当调用start方法后，系统才会开启一个新的线程，进而调用run()方法来执行任务，而单独的调用run()就跟调用普通方法是一样的，已经失去线程的特性了。因此在启动一个线程的时候一定要使用start()而不是run()。

7. 下列属于关系型数据库的是（）

A. Oracle   B MySql   C IMS   D MongoDB

答案：AB

解答：IMS（Information Management System ）数据库是IBM公司开发的两种数据库类型之一;一种是关系数据库，典型代表产品：DB2；另一种则是层次数据库，代表产品：IMS层次数据库。非关系型数据库有MongoDB、memcachedb、Redis等。

8. GC线程是否为守护线程？（）

答案：是

解析：线程分为守护线程和非守护线程（即用户线程）。只要当前JVM实例中尚存在任何一个非守护线程没有结束，守护线程就全部工作；只有当最后一个非守护线程结束时，守护线程随着JVM一同结束工作。守护线程最典型的应用就是 GC (垃圾回收器).

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

答案：不能

解析：volatile关键字用在多线程同步中，可保证读取的可见性，JVM只是保证从主内存加

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

10. 下列说法正确的是（）

A LinkedList继承List   C HashSet继承AbstractSet 

答案：AC

 

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

答案：存在

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

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

答案：存在

解析：比如Double.NaN或Float.NaN

12. 0.6332的数据类型是（）

A float B double C Float D Double

答案：B

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

13. 下面哪个流类属于面向字符的输入流( )

A BufferedWriter     B FileInputStream    C ObjectInputStream     D InputStreamReader

答案：D

解析：IO操作中有面向字节(Byte)和面向字符(Character)两种方式。面向字节的操作为以8位为单位对二进制的数据进行操作，对数据不进行转换，这些类都是InputStream和OutputStream的子类。面向字符的操作为以字符为单位对数据进行操作，在读的时候将二进制数据转为字符，在写的时候将字符转为二进制数据，这些类都是Reader和Writer的子类。

总结：以InputStream/OutputStream为后缀的是字节流；以Reader（输入）/Writer（输出）为后缀的是字符流。

14. Java接口的修饰符可以为（）

A private    B protected    C final    D abstract

答案：CD

解析：

（1）接口用于描述系统对外提供的所有服务,因此接口中的成员常量和方法都必须是public类型的,确保外部使用者能访问它们。

（2）接口仅仅描述系统能做什么,但不指明如何去做,所以接口中的方法都是抽象方法；

（3）接口不涉及和任何具体实例相关的细节,因此接口没有构造方法,不能被实例化,没有实

例变量，只有静态（static）变量。

（4）接口的中的变量都是常量。

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

A 是 B 否

答案：A

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

(1) 用new语句创建对象，这是最常见的创建对象的方法。

(2) 运用反射调用java.lang.Class或者java.lang.reflect.Constructor的newInstance()实例方法。

(3) 调用对象的clone()方法。

如图可知，Object类有12个成员方法，按照用途可以分为以下几种

1，构造函数

2，hashCode和equals函数用来判断对象是否相同

3，wait(),wait(long),wait(long,int),notify(),notifyAll()

4，toString()和getClass,

5，clone()

6，finalize()用于在垃圾回收

函数说明

clone()

用来另存一个当前存在的对象。

equals()

用于确认两个对象是否相同。

hashCode()

用于获取对象的哈希值，这个值的作用是检索。

equals()

返回true的两个对象一定相同。

getClass()

返回一个Class对象，如果打印出来会发现结果是如下格式。

class package.name.xxx 1

因为返回的是一个class对象,后面可以跟class类的方法。用的是谁的构造函数，那么getClass返回的就是谁的类型。getClass()经常用于java反射机制。

wait(),wait(long),wait(long,int),notify(),notifyAll()

这几个函数体现的是Java的多线程机制。使用的时候要求在synchronize语句中使用。

wait()，wait(long) 和wait(long,int)

用于让当前线程失去操作权限，当前线程进入等待序列。重载的方法用于通知所有持有对象的锁的线程获取操作权限用于设定下一次获取锁的距离当前释放锁的时间间隔。

notify()

用于随机通知一个持有对象的锁的线程获取操作权限。

notifyAll()

finalize()

这个函数在进行垃圾回收的时候会用到，匿名对象回收之前会调用到。

(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倍），但是这里显示指明了需要多少空

间，所以就一次性为你分配这么多空间，也就是不需要扩充了。

17. 下面哪些是对称加密算法（）

A DES     B AES     C DSA     D RSA

答案：AB

解析：常用的对称加密算法有：DES、3DES、RC2、RC4、AES

常用的非对称加密算法有：RSA、DSA、ECC

使用单向散列函数的加密算法：MD5、SHA

18.新建一个流对象，下面哪个选项的代码是错误的？（）

A）new BufferedWriter(new FileWriter("a.txt"));

B）new BufferedReader(new FileInputStream("a.dat"));

C）new GZIPOutputStream(new FileOutputStream("a.zip"));

D）new ObjectInputStream(new FileInputStream("a.dat"));

答案：B

解析：请记得13题的那个图吗？Reader只能用FileReader进行实例化。

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调用对象肯定会报空指针错了。

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

­­­­­­­main start­­­­­­­

I'm A class

HelloA

I'm B class

HelloB

解析：考查静态语句块、构造语句块（就是只有大括号的那块）以及构造函数的执行顺序。

对象的初始化顺序：

（1）类加载之后，按从上到下（从父类到子类）执行被静态块；

（2）当static语句执行完之后,再执行main方法；

（3）如果有语句new了自身的对象，将从上到下执行构造代码块、构造器（两者可以说绑定在一起）。

21. getCustomerInfo()方法如下，try中可以捕获三种类型的异常，如果在该方法运行中产生了一个IOException，将会输出什么结果（）

public void getCustomerInfo() {

try {// do something that may cause an Exception

} catch (java.io.FileNotFoundException ex) {

System.out.print("FileNotFoundException!");

} catch (java.io.IOException ex) {

System.out.print("IOException!");

} catch (java.lang.Exception ex) {

System.out.print("Exception!");

}}

A IOException!

B IOException!Exception!

C FileNotFoundException!IOException!

D FileNotFoundException!IOException!Exception!

答案：A

解析：当用多个catch语句时，catch语句块在次序上有先后之分。从最前面的catch语句块依次先后进行异常类型匹配，这样如果父异常在子异常类之前，那么首先匹配的将是父异常类，子异常类将不会获得匹配的机会，也即子异常类型所在的catch语句块将是不可到达的语句。所以一般将父类异常类即Exception老大放在catch语句块的最后一个。

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

1 import java.io.*;

2 import java.util.*;

3 public class foo{

4 public static void main (String[] args){

5 String s;

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

7 }

8 }

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

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

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

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

答案：C

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

须初始化才能输出值。

23. System.out.println("5" + 2);的输出结果应该是（）。

A 52    B7    C2    D5

答案：A

解析：Java会自动将2转换为字符串。

24. 指出下列程序运行的结果 （）

public class Example {

String str = new String("good");

char[] ch = { 'a', 'b', 'c' };

public void change(String str, char ch[]) {

str = "test ok";

ch[0] = 'g';

}

 

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);

}}

A、good and abc   B、good and gbc   C、test ok and abc   D、test ok and gbc

答案：B

解析：大家可能以为Java中String和数组都是对象所以肯定是对象引用，然后就会选D，其实这是个很大的误区：因为在java里没有引用传递，只有值传递。这个值指的是实参的地址的拷贝，得到这个拷贝地址后，你可以通过它修改这个地址的内容（引用不变），因为此时这个内容的地址和原地址是同一地址，但是你不能改变这个地址本身使其重新引用其它的对象，也就是值传递。

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

A NullPointerException

B ClassCastException

C FileNotFoundException

D IndexOutOfBoundsException

答案：C

解析：参见2题。

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;

}

A 0     B 2     C 4     D 10

答案：D

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

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

public abstract class MyClass {

public int constInt = 5;

//add code here

public void method() { }}

A public abstract void method(int a);

B constInt = constInt + 5;

C public int method();

D public abstract void anotherMethod() {}

答案：A

解析：abstract关键字只能修饰类和方法，不能修饰字段。

29. 阅读Shape和Circle两个类的定义。在序列化一个Circle的对象circle到文件时，下面哪个字段会被保存到文件中？ ( )

class Shape {

public String name;

}

class Circle extends Shape implements Serializable{

private float radius;

transient int color;

public static String type = "Circle";

}

A name  B radius  C color  D type

答案：B

30.下面是People和Child类的定义和构造方法，每个构造方法都输出编号。在执行newChild("mike")的时候都有哪些构造方法被顺序调用？请选择输出结果 ( )

class People {

String name;

public People() {

System.out.print(1);}

public People(String name) {

System.out.print(2);

this.name = name;} }

class Child extends People {

People father;

public Child(String name) {

System.out.print(3);

this.name = name;

father = new People(name + ":F");}

public Child() {

System.out.print(4); }}

A312 B 32 C 432 D 132

答案：D

解析：考察的又是父类与子类的构造函数调用次序。在Java中，子类的构造过程中必须调用其父类的构造函数，是因为有继承关系存在时，子类要把父类的内容继承下来。但如果父类有多个构造函数时，该如何选择调用呢？第一个规则：子类的构造过程中，必须调用其父类的构造方法。一个类，如果我们不写构造方法，那么编译器会帮我们加上一个默认的构造方法（就是没有参数的构造方法），但是如果你自己写了构造方法，那么编译器就不会给你添加了，所以有时候当你new一个子类对象的时候，肯定调用了子类的构造方法，但是如果在子类构造方法中我们并没有显示的调用基类的构造方法，如：super(); 这样就会调用父类没有参数的构造方法。

第二个规则：如果子类的构造方法中既没有显示的调用基类构造方法，而基类中又没有无参的构造方法，则编译出错，所以，通常我们需要显示的：super(参数列表)，来调用父类有参数的构造函数，此时无参的构造函数就不会被调用。总之，一句话：子类没有显示调用父类构造函数，不管子类构造函数是否带参数都默认调用父类无参的构造函数，若父类没有则编译出错。最后，给大家出个思考题：下面程序的运行结果是什么？

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

package test;

/** @description Java中没有引用传递只有值传递*/

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

说明：不管是对象、基本类型还是对象数组、基本类型数组，在函数中都不能改变其实际地址但能改变其中的内容。

 

31． 以下属于面向对象的特征的是（）

A) 重载  B) 重写  C) 封装  D) 继承

32． 以下代码运行输出是（）

public class Person{

private String name=”Person”;

int age=0;

}

public class Child extends Person{

public String grade;

public static void main(String[] args){

Person p = new Child();

System.out.println(p.name);

}

}

A) 输出：Person  B) 没有输出  C) 编译出错  D) 运行出错

33． 在使用super 和this关键字时，以下描述正确的是（）

A) 在子类构造方法中使用super（）显示调用父类的构造方法，super（）必须写在子类构造方法的第一行，

否则编译不通过

B) super（）和this（）不一定要放在构造方法内第一行

C) this（）和super（）可以同时出现在一个构造函数中

D) this（）和super（）可以在static环境中使用，包括static方法和static语句块

34． 以下对封装的描述正确的是（）

A) 只能对一个类中的方法进行封装，不能对属性进行封装

B) 如果子类继承了父类，对于父类中进行封装的方法，子类仍然可以直接调用

C) 封装的意义不大，因此在编码时尽量不要使用

D) 封装的主要作用在于对外隐藏内部实现细节，增强程序的安全性

35． 以下对继承的描述错误的是（）

A) Java中的继承允许一个子类继承多个父类

B) 父类更具有通用性，子类更具体

C) Java中的继承存在着传递性

D) 当实例化子类时会递归调用父类中的构造方法

36． 以下程序的运行结果是（）

class Person{

public Person(){

System.out.println(“this is a Person”);}}

public class Teacher extends Person{

private String name=”tom”;

public Teacher(){

System.out.println(“this is a teacher”);

super();}

public static void main(String[] args){

Teacher teacher = new Teacher();

System.out.println(this.name);}}

A) this is a Person

this is a teacher

tom

B) this is a teacher

this is a Person

tom

C) 运行出错

D) 编译有两处错误

37． 以下说法错误的是（）

A) super.方法（）可以调用父类的所有非私有方法

B) super（）可以调用父类的所有非私有构造函数

C) super.属性可以调用父类的所有非私有属性

D) this和super关键字可以出现在同一个构造函数中

38． 以下关于final关键字说法错误的是（）

A) final是java中的修饰符，可以修饰类、接口、抽象类、方法和属性

B) final修饰的类肯定不能被继承

C) final修饰的方法不能被重载

D) final修饰的变量不允许被再次赋值

39． 访问修饰符作用范围由大到小是（）

A) private­default­protected­public

B) public­default­protected­private

C) private­protected­default­public

D) public­protected­default­private

40． 以下（）不是Object类的方法

A) clone（）    B) finalize（）    C) toString（）    D) hasNext（）

41． 多态的表现形式有（）

A) 重写    B) 抽象    C) 继承    D) 封装

42． 以下对重载描述错误的是（）

A) 方法重载只能发生在一个类的内部

B) 构造方法不能重载

C) 重载要求方法名相同，参数列表不同

D) 方法的返回值类型不是区分方法重载的条件

43． 以下（）添加到ComputerBook中不会出错

class Book{

protected int getPrice(){

return 30;}}

public class ComputerBook extends Book{}

A) protected float getPrice(){}

B) protected int getPrice(int page){}

C) int getPrice(){}

D) public int getPrice(){return 10;}

44． 以下对抽象类的描述正确的是（）

A) 抽象类没有构造方法

B) 抽象类必须提供抽象方法

C) 有抽象方法的类一定是抽象类

D) 抽象类可以通过new关键字直接实例化

45． 以下对接口描述错误的有（）

A) 接口没有提供构造方法

B) 接口中的方法默认使用public、abstract修饰

C) 接口中的属性默认使用public、static、final修饰

D) 接口不允许多继承

46． 以下代码，描述正确的有（）

interface IDemo{

public static final String name;1

void print();2

public void getInfo();3}

abstract class Person implements IDemo{4

public void print(){}}

A) 第1行错误，没有给变量赋值

B) 第2行错误，方法没有修饰符

C) 第4行错误，没有实现接口的全部方法

D) 第3行错误，没有方法的实现

47． 接口和抽象类描述正确的有（）

A) 抽象类没有构造函数    B) 接口没有构造函数    C) 抽象类不允许多继承    D) 接口中的方法可以有方法体

48． 以下描述错误的有（）

A) abstract 可以修饰类、接口、方法

B) abstract修饰的类主要用于被继承

C) abstract 可以修饰变量

D) abstract修饰的类，其子类也可以是abstract修饰的

49． 以下描述正确的有（）

A) 方法的重写应用在一个类的内部

B) 方法的重载与返回值类型无关

C) 构造方法不能重载

D) 构造方法可以重写

50． 以下程序运行结果是（）

public class Test extends Father{

private String name=”test”;

public static void main(String[] args){

Test test = new Test();

System.out.println(test.getName());}}

class Father{

private String name=”father”;

public String getName() {

return name;}}

A) father    B) test    C) 编译出错    D) 运行出错，无输出

51． 以下对异常的描述不正确的有（）

A) 异常分为Error和Exception

B) Throwable是所有异常类的父类

C) Exception是所有异常类父类

D) Exception包括RuntimeException和RuntimeException之外的异常

52． 在try­catch­finally语句块中，以下可以单独与finally一起使用的是（）

A) catch    B) try    C) throws    D) throw

53． 下面代码运行结果是（）

public class Demo{

public int add(int a,int b){ 43

try{

return a+b;

}catch(Exception e){

System.out.println(“catch 语句块”);

}finally{

System.out.println(“finally 语句块”);}

return 0;}

public static void main(String[] args){

Demo demo = new Demo();

System.out.println(“和是：”+demo.add(9,34));}}

A) 编译异常    B) finally语句块 和是：43    C) 和是：43 finally语句块    D) catch语句块 和是：43

54． 以下描述不正确的有（）

A) try块不可以省略   B) 可以使用多重catch块   C) finally块可以省略   D) catch块和finally块可以同时省略

55． 以下对自定义异常描述正确的是（）

A) 自定义异常必须继承Exception

B) 自定义异常可以继承自Error

C) 自定义异常可以更加明确定位异常出错的位置和给出详细出错信息

D) 程序中已经提供了丰富的异常类，使用自定义异常没有意义

56． 以下程序运行结果是（）

public class Test {

public int div(int a, int b) {

try {

 return a / b;

}catch(Exception e){

System.out.println(“Exception”);

}catch(NullPointerException e){

System.out.println(“ArithmeticException”);}

catch (ArithmeticException e) {

System.out.println(“ArithmeticException”);

} finally {

System.out.println(“finally”);}

return 0;}

public static void main(String[] args) {

Test demo = new Test();

System.out.println(“商是：” + demo.div(9, 0));}}

A) Exception finally 商是：0

B) ArithmeticException finally 商是：0

C) finally商是：0

D) 编译报错

57. 以下对TCP和UDP描述正确的是（）

A) TCP不能提供数据的可靠性

B) UDP能够保证数据库的可靠性

C) TCP数据传输效率高于UDP

D) UDP数据传输效率高于TCP

58. 在Java中，下面对于构造函数的描述正确的是（）

A) 类必须显示定义构造函数

B) 构造函数的返回类型是void

C) 构造函数和类有相同的名称，并且不能带任何参数

D) 一个类可以定义多个构造函数

59. 根据下面的代码，

String s = null;

会抛出NullPointerException异常的有（）。[两项]

A) if( (s!=null) & (s.length()>0) )

B) if( (s!=null) & & (s.length()>0) )

C) if( (s==null) | (s.length()==0) )

D) if( (s==null) || (s.length()==0) )

60.在Java中，关于HashMap类的描述，以下廉洁错误的是(  )。

A) HashMap使用键/值得形式保存数据

B) HashMap 能够保证其中元素的顺序

C) HashMap允许将null用作键

D) HashMap允许将null用作值

61. 下列选项中关于java中super关键字的说法错误的是（ ）

A) super关键字是在子类对象内部指代其父类对象的引用

B) super关键字不仅可以指代子类的直接父类，还可以指代父类的父类

C) 子类可以通过super关键字调用父类的方法

D) 子类可以通过super关键字调用父类的属性

62. 在Java中，以下代码(  )正确地创建了一个InputStreamReader对象。

A) InuptStreamReader(new FileInputStream(“1.dat”));

B) InuptStreamReader(new FileReader(“1.dat”));

C) InuptStreamReader(new BufferReader(“1.dat”));

D) InuptStreamReader (“1.dat”);

63. 在Java中，(  )类提供定位本地文件系统，对文件或目录及其属性进行基本操作。

A) FileInputStream

B) FileReader

C) FileWriter

D) File

64. Java中的集合类包括ArrayList、LinkedList、HashMap等类，下列关于集合类描述错误的是（）

A) ArrayList和LinkedList均实现了List接口

B) ArrayList的访问速度比LinkedList快

C) 添加和删除元素时，ArrayList的表现更佳

D) HashMap实现Map接口，它允许任何类型的键和值对象，并允许将null用作键或值

65. 在Java中开发JDBC应用程序时，使用DriverManager类的getConnection（）方法建立与数据源的连接语句为：

Connection con = DriverManager.getConnection(“jdbc:odbc:news”);URL连接中的”news”表示的是（）（选择一项）

A) 数据库中表的名称    B) 数据库服务器的机器名    C) 数据源的名称    D) 用户名

66． 在Java中,JDBCAPI定义了一组用于与数据库进行通信的接口和类，它们包括在（）包中。

A) java.lang    B) java.sql    C) java.util    D) java.math

67. Java中，以下(  )接口以键_值对的方式存储对象。

A) java.util.Collection    B) java.util.Map    C) java.util.List    D) java.util.Set

68. 以下关于对象序列化描述正确的是（  ）[两项]

A) 使用FileOutputStream可以将对象进行传输

B) 使用PrintWriter可以将对象进行传输

C) 使用ObjectOutputStream类完成对象存储，使用ObjectInputStream类完成对象读取

D) 对象序列化的所属类需要实现Serializable接口

69. 在Java中，( A )类可用于创建链表数据结构的对象。

A) LinkedList    B) ArrayList    C) Collection    D) HashMap

70. 分析下面这段Java代码，它的运行结果是( )。

Import java.io.*;

Public class B{

Public static void main(string [] args){

int i=12;

System.out.println(i+=i­=i*=i);  //i+=i-=i=i*i

}}

A) 100    B) 0    C) ­120    D) 程序无法编译

71. 使用JDBC事务的步骤是（cabd）（多选）

A) 取消Connection的事务自动提交方式

 B) 发生异常回滚事务

C) 获取Connection对象

D) 操作完毕提交事务

72. 以下对JDBC事务描述错误的是（ ）

A) JDBC事务属于JAVA事务的一种

B) JDBC事务属于容器事务类型

C) JDBC事务可以保证操作的完整性和一致性

D) JDBC事务是由Connection发起的，并由Connection控制

73. 要通过可滚动的结果集更新数据，以下正确的是（)

A) pst=con.prepareStatement(sql,

ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE)

B) pst=con.prepareStatement(sql,

ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_READ_ONLY)

C) pst=con.prepareStatement(sql, Resu ltSet.TYPE_SCROLL_SENSITIVE)

D) pst=con.prepareStatement(sql, ResultSet.CONCUR_UPDATABLE)

74. 存储过程pro有两个参数，第一个为输入参数，第二个为输出参数，以下代码正确的是（）

A) CallableStatement cst=con.prepareCall(“(call pro(?,?))”);

B) CallableStatement cst=con.prepareCall(“(call pro(?))”);

C) CallableStatement cst=con.prepareCall(“{call pro(?,?)}”);

D) CallableStatement cst=con.prepareCall(“{call pro(?,?,?)}”);

75. 以下描述正确的是()

A) CallableStatement是PreparedStatement的父接口

B) PreparedStatement是CallableStatement的父接口

C) CallableStatement是Statement的子接口

D) PreparedStatement是Statement的父接口

76. 要删除book表中书籍(bookName)是”java”的记录，以下代码正确的是（)

String sql=”delete from book where bookName=?”;

PreparedStatement pst=con.preparedStatement(sql);

______________________________

pst.execute();

A) pst.setString(1,”java”);    B) pst.setString(0,”java”);    C) pst.setInt(0,”java”);    D) 以上选项都不正确

77. 获取ResutlSet对象rst的第一行数据，以下正确的是（）

A) rst.hashNext();      B) rst.next();      C) rst.first();      D) rst.nextRow();

78. 以下可以正确获取结果集的有（）（多选）

A) Statement sta=con.createStatement();

ResultSet rst=sta.executeQuery(“select * from book”);

B) Statement sta=con.createStatement(“select * from book”);

ResultSet rst=sta.executeQuery();

C) PreparedStatement pst=con.preparedStatement();

ResultSet rst=pst.executeQuery(“select * from book”);

D) PreparedStatement pst=con.preparedStatement(“select * from book”);

ResultSet rst=pst.executeQuery();

79. 以下负责建立与数据库连接的是（）

A) Statement      B) PreparedStatement      C) ResultSet      D) DriverManager

80. 使用JDBC连接数据库的顺序是（b,a,d,c,e）

A) 加载驱动  B) 导入驱动包  C) 发送并处理SQL语句  D) 建立于数据库的连接  E)关闭连接