1. 在Java中，com包中某类的方法使用下列（ ）访问修饰符修饰后，可以被com.db包中的子类访
问，但不能被com.db中其他类访问。
A. private
2. 在Java中，下列（ ）类不能派生出子类。
A. public class Myclass{} B. class MyClass{} C. abstract class MyClass{} D. final class MyClass{}
3. 在Java中，关键字（ ）用来调用父类的构造方法。
A. super
B. this
C. extends
D. abstract
4. 以下属于OOP的特征的是（ ）。【选两项】
A. 封装 B. 继承 C. 重载 D. 重写
5. 以下对继承的描述错误的是（ ）。
A. Java中继承允许一个子类继承多个父类 B. 父类更具有通用性，子类更为具体 C. Java中的继承存在着传递性 D. 当实例化子类时会递归调用父类中的构造方法
6. 以下程序的运行结果是（ ）。
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
B. protected
C. public
D. friendly
C. 编译出错
D. 以上说法都不正确
7. 在使用super和this关键字时，以下描述正确的是（ ）。
A. 在子类构造方法中使用super()显示调用父类的构造方法，super()必须写在子类构造方法的第一行，否则编译不通过
B. super()和this()不一定要放在构造方法内第一行 C. this和super可以同时出现在一个构造函数里面
D. this ()和super()可以在static环境中使用，包括static方法、static语句块
8. 以下对封装的描述正确的是（ ）。
A. 只能对一个类中的方法进行封装，不能对属性进行封装
B. 如果子类继承了父类，对于父类中进行封装的方法，子类仍然可以直接调用 C. 封装的意义并不大，因此在编码时尽量不要使用封装
D. 封装的主要作用在于对外隐藏内部实现细节，增强程序的安全性
9. 以下属于Object类方法的是（ ）。【选两项】
A. clone()
10. 访问修饰符的访问范围从小到大依次是（ ）。
A. public,protected,private,default
C. protected,default,public,private
11. 以下代码中，this是指( )。 class bird{ int x,y;
void fly(int x,int y){ this.x=x; this.y=y; } }
A. bird
12. 下面是有关子类继承父类构造函数的描述，正确的是（ ）。
A. 创建子类的对象时，先调用子类自己的构造函数，然后调用父类的构造函数
B. 子类无条件地继承父类不含参数的构造函数 C. 子类必须通过super关键字调用父类的构造函数 D. 子类无法继承父类的构造函数
13. 在JAVA中，使用（ ）关键字来定义一个接口。
A. class B. interface C. extends D. implements
14. 在JAVA中，下面关于抽象类的描述正确的是（ ）。【选两项】
A. 抽象类可以被实例化
B. 如果一个类中有一个方法被声明为抽象的，那么该类必须是抽象类 C. 抽象类中的方法必须都是抽象的
B. private,protected,default,public D. private,default,protected,public
B. toString()
C. length()
D. forName()
B. fly C. bird或fly D. 不一定
D. 声明抽象类必须带有关键字abstract
15. 在Java中，已定义两个接口B和C，要定义一个类来实现这两个接口，以下语句正确的是（ ）。
A. interface A extends B,C B. inteface A implements B,C
C. class A implements B,C
D. class A implements B,implements C
16. 在Java中，如果父类中的某些方法不包含任何逻辑，并且需要由子类重写，应该使用（ ）关键
字来声明父类的这些方法。
A. final
17. 在Java中，使用（ ）关键字来定义一个接口。
A. class B. interface C. extends D. implements
18. 多态的两种表现形式有（ ）。【选两项】
A. 重载 B. 重写 C. 抽象 D. 继承
19. 以下对重载描述错误的是（ ）。
A. 方法重载只能发生在一个类的内部 C. 重载要求方法名相同，参数列表不同
20. 以下哪个选项的方法添加到ComputerBook中不会出错（ ）。
class Book
{
protected int getPrice() {
return 80; } }
public class ComputerBook extends Book {
}
A. protected float getPrice( ){ } C. int getPrice( ) { }
21. 以下对抽象类的描述正确的是（ ）。 A. 抽象类没有构造方法
D. 抽象类可以通过new关键字直接实例化
22. 以下对接口描述正确的是（ ）。 A. 接口没有提供构造方法
B. 接口不允许多继承
D. 接口中的方法默认使用public、abstract修
B. 抽象类必须提供抽象方法
B. static
C. abstract
D. void
B. 构造方法不能够重载
D. 方法的返回值类型不是区分方法重载的条件
B. protected int getPrice(int page){ } D. 以上说法都不正确
C. 有抽象方法的类一定是抽象类，抽象类不一定有抽象方法
C. 接口中的属性默认使用public、static、final修饰 饰
23. 以下对抽象类和接口描述正确的是（ ）。
A. 接口没有提供构造方法 C. 抽象类不能实现接口 B. 抽象类解决了Java不允许多继承的问题 D. 接口和抽象类都提供了构造方法
24. 以下代码正确的执行结果是（ ）。
class A {
private int i = 10; public void printI() { System.out.print(i); } }
class B extends A { private int i = 20; public void printI() { System.out.print(i); }
}
public class Test {
public static void main(String args[]) { B b = new B(); A a = b; b.printI(); a.printI(); } } A. 10 10
B. 10 20
C. 20 10
D. 20
25. 对于以下代码的执行结果描述正确的是（ ）。
public interface Guard{
void doYourJob();
}
abstract public class Dog implements Guard{ } A. 无法编译，因为接口中的方法必须定义为abstract B. 无法编译，Dog类必须实现这个方法
C. 无法编译，因为Dog类必须使用extends而不是impelments. D. 代码可以正确编译
26. 以下是public void example(){}重载函数的是（ ）。 A. public void example( int m){...} B. public int example(){...} C. public void example2(){...}
D. public int example ( int m, float f){...}
27. 下面关于重载(overload)的代码运行结果为（ ）。 //TestOverLoad.java
public class TestOverLoad {
public static void main(String[] args) {
20
Test test = new Test(); test.print(null); } }
class Test {
public void print(String some) {
System.out.println(\ }
public void print(Object some) {
System.out.println(\ } }
A. 编译错误
28. 下列关于修饰符混用的说法，错误的是（ ）。 A. abstract不能与final并列修饰同一个类 B. abstract类中不可以有private的成员 C. abstract方法必须在abstract类中
29. 对以下代码的描述正确的是（ ）。 abstract class AbstractOne { abstract int getInt(); }
class ATest extends AbstractOne { private int x = 1; private int getInt() { return x; }
}
A. 编译成功 C. 编译无法通过，第2行出错
B. 编译成功，但会导致运行时错误 D. 编译无法通过，第6行出错
D. final可以与private同时修饰属性
B. 输出 String version print D. 以上说法都不正确
C. 输出 Object version print
30. 以下方法中声明能够被加入到Child类中，并编译正确的是（ ）。 public class Parent { public int addValue( int a, int b) { return a+b; } }
class Child extends Parent { }
A. int addValue( int a, int b ){// do something...} B. public void addValue () {// do something...} C. public void addValue( int b, int a ){// do something...} D. public int addValue( int a, int b )throws Exception { // do something... }
31. 下面有关继承的代码运行结果是（ ）。
class Teacher extends Person { public Teacher() { super(); }
public Teacher(int a) { System.out.println(a); }
public void func() { System.out.print(\ }
public static void main(String[] args) { Teacher t1 = new Teacher(); Teacher t2 = new Teacher(3); } }
class Person {
public Person() { func(); }
public void func() { System.out.println(\ } }
A. 1 1 3
B. 2 2 3
C. 1 3
D. 2 3
32. 以下对异常的描述不正确的是（ ）。 A .异常分为Error和Exception Ｂ. Throwable是所有异常类的父类
C. 在程序中不管是Error类型还是Exception类型的异常，都可以捕获后进行异常处理 D. Exceptoin是RuntimeException和RuntimeException之外异常的父类
33. 在try-catch-finally语句块中，以下可以与finally一起使用的是（ ）。 A. catch B. try C. throws D. throw
34. 下面代码运行结果是（ ）。 package com; import java.util.*; public class Demo {
public int add(int a,int b){ try
{ return a+b; }
catch(Exception e) {
System.out.println(\语句块\
}
finally {
System.out.println(\语句块\
} return 0; }
public static void main(String args[]) {
Demo demo = new Demo();
System.out.println(\和是:\\t\
} }
A. 编译异常 B. finally语句块 和是:43 C．和是43 finally语句块 D. 和是:43
35. 以下对try-catch-finally语句块描述不正确的是（ ）。 A. try块不可以省略
B. 在try-catch-finally中可以使用多重catch块，使用多重catch块时，捕获范围小的异常必须放在捕获范围大的异常之前
C. finally语句块可以省略
D. catch语句块和finally语句块可以同时省略.
36. 以下对自定义的异常描述正确的是（ ）。 A. 自定义的异常必须继承Exception
B. 自定义的异常可以更加明确地定位异常出错的位置，同时给出详细的异常信息 C. 自定义的异常类的父类可以继承Error
D. 在程序中已经提供了丰富的异常类，所以使用自定义的异常没有意义
37. 关于Java的异常处理，以下说法正确的是（ ）。
A. 任何可能引发Error类异常的语句必须封装在try块中 B. 任何可能引发Exception异常的语句必须封装在try块中
C. 任何可能引发RuntimeException异常的语句必须封装在try块中 D. 正常情况下，程序无法捕获Error类的异常
38. 以下代码所产生的异常类型是（ ）。 String str = null;
System.out.println(str.length()); A. SQLException
B. IOException
C. NullPointerException
D. NumberFormatException
39. 以下异常类型属于运行时异常的是（ ）。 A. SQLException B. IOException C. NullPointerException
D. ClassCastException
40. 以下对try-catch-finally描述正确的是（ ）。 A. try可以省略 B. try、catch、finally都不允许省略 C. try可以省略，catch、finally不可以省略 D. try不可以省略，catch、finally可以省略
41. 以下对final、finally、finalize描述正确的是（ ）。 A. final可以修饰方法，其修饰的方法为构析方法 B. finally可以修饰方法，其修饰的方法为构析方法 C. finalize可以修饰方法，其修饰的方法为构析方法 D. finally可以修饰方法，其修饰的方法不可以被重写
42. 使用catch(Exception e)的好处是（ ）。 A. 只会捕获个别类型的异常 B. 捕获try块中产生的所有类型的异常 C. 忽略一些异常
43. 以下方法不属于Class类中的方法是（ ）。 A. forName() B. getConstructors() C. getFields()
44. 以下对log4j描述不正确的是（ ）。 A. log4j是Apache开源组织提供的开源程序包
B. log4j由三个重要的组件组成：日志的输出目的地、日志信息的输出格式和日志信息的优先级 C. 使用log4j时不能同时设定多个日志输出目的地
D. log4j的日志信息级别从高到低依次是：error、warn、info、debug
45. 在程序中使用log4j的步骤依次是（ ）。【选四项】 A. 配置log4j.properties文件 B. 导入log4j jar包 C. 建立Java文件 D. 在程序中使用log4j记录日志信息
46. 以下对装箱拆箱描述错误的是（ ）。
A. Java中的基本数据类型有以下几种：String、int、char、byte、short、double、long、float B. 装箱是由基本数据类型转换为包装类 C. 拆箱是由包装类转换为基本数据类型 D. 以上说法都不正确
47. 以下选项错误的是（ ）。 A. String是Java的基本数据类型 C. Java中的每种基本数据类型都有与之对应的包装类
48. 以下对反射描述错误的是（ ）。
A. 反射是程序在运行时能够获取自身信息的机制 B. 通过反射取得类的结构，首先要取得类的Class对象 C. 通过反射可以调用一个类中的方法
D. 通对反射只能获取当前类的结构信息，不可以获取当前类父类的结构结息
49. 要求使用log4j记录系统运行日志且要求每天生成一个日志文件，以下应选择日志输出目的地的类型
是（ ）。
D. getString()
D. 执行一些程序
B. byte是Java的基本数据类型
D. long是Java的基本数据类型
A. ConsoleAppender
B. FileAppender C. RollingFileAppender D. DailyRollingFileAppender
50. 以下描述正确的是（ ）。
A. 使用反射不能够获取提供类的父类信息
B. 使用反射不能够获取提供类的构造方法
C. 使用反射不能够获取接口的结构信息
D. 使用反射可以获取提供类的属性、方法以及父类的结构信息
51. 使用log4j记录程序日志，以下描述正确的是（ ）。 A. log4j配置文件必须放在工程指定的目录下 B. log4j配置文件可以不设置日志信息的格式 C. log4j默认的日志输出目的地是FileAppender
D. 日志输出目的地设置为FileAppender时，必须设置file属性用于指定文件的名称
52. 以下代码不能够正确执行的是（ ）。 A. Integer m = new Integer(90); int n = m B. float f = 9.8 C. Float f = 90.5f D. Integer i = 80
53. 以下属于Collection子接口的是（ ）。 A. List
B. Map
C. Set
D. Hashtable
54. 以下集合类以键值对形式存储的是（ ）。 A. ArrayList B. HashSet C. Vector
D. HashMap
55. 以下对HashSet和ArrayList描述正确的是（ ）。 A. ArrayList集合中的元素是无序的 B. ArrayList不允许有重复元素 C. HashSet集合中的元素是有序的 D. HashSet不允许有重复元素
56. 以下对HashMap和Hashtable描述正确的是（ ）。 A. HashMap和Hashtable均以“key-value”形式存储数据 B. HashMap不允许有空键和空值 C. Hashtable允许有空键和空值 D. HashMap和Hashtable中的键不允许重复
57. 以下对泛型描述错误的是（ ）。 A. 泛型可以解决数据安全性问题
B. 泛型是指建立对象时不指定类中属性的具体类型，而是在声明及实例化对象时由外部指定类型 C. 泛型定义包括泛型类定义和泛型对象定义两部分 D. 以上说法都不正确
58. 在Java中，（ ）接口位于集合框架的顶层。 A. Map
B. Collection
C. Set
D. List
59. java.util.HashMap实现了（ ）接口 A. Collection B. Set C. Map
D. List
60. ArrayList与Vector的区别描述正确的是（ ）。
A. ArrayList实现了Set接口 C. ArrayList是线程同步的 B. Vector实现了List接口 D. ArrayList是线程同步的
61. 以下对HashMap和Hashtable描述正确的是（ ）。【选两项】 A. HashMap与Hashtable都是”键值对”形式存储数据的 B. HashMap不允许有空键 C. Hashtable允许有空键 D. Hashtable是线程同步的，不允许有空键和空值
62. 以下对HashSet与ArrayList描述正确的是（ ）。 A. ArrayList与HashSet都是Set接口的实现类 B. ArrayList不允许保存重复元素 C. HashSet不允许保存重复元素 D. ArrayList其元素存放是无序的，HashSet其元素存放顺序是有序的
63. 采用先进后出顺序的数据存储方式的集合类是（ ）。 A. ArrayList B. LinkedList C. Stack D. Vector
64. 下列关于List的程序运行结果是（ ）。 import java.util.*; public class Test {
public static void main(String args[]) {
List
s.remove(i - 1); }
System.out.println(s.size()); } } A. 1
B. 100 C. throws Exception D. none of the Above
65. 构造一个ArrayList类的实例，下列方法正确的是（ ）。 A. ArrayList myList = new Object() B. List myList = new ArrayList() C. ArrayList myList = new List() D. List myList = new List()
66. 找出哪个是线程安全的集合（ ）。 A. java.util.ArrayList
B. java.util.Vector
C. java.util.HashSet
D. java.util.TreeSet
67. 在Java中，使用JDBC时，对于多次调用同一条SQL语句的情况，使用（ ）通常会提高效率。
A. Statement B. CallableStatement C. PreparedStatement D. ParementStatement
68. 在Java 中，已获得默认类型的ResultSet对象rs，要获取结果集中的数据，必须执行的语句是（ ）。 A. rs.next() B. rs.previous() C. rs.getNext() D. rs.getPrevious()
69. 在Java中，下列（ ）做法可以得到Connection对象和Statement对象。
A. 使用Class的getConnection方法可以得到Connection对象，使用Connection对象的createStatement方法可以得到Statement对象
B. 使用Class.getConnection方法可以得到Connection对象，使用DriverManager的createStatement方法可以获得Statement对象
C. 使用DriverManager的getConnection方法可以得到Connection对象，使用Connection对象的createStatement方法可以获得Statement对象
D. 使用DriverManager的getConnection方法可以得到Connection对象，使用Statement对象的createStatement方法可以获得Statement对象
70. 在Java中，通过调用以下（ ）方法，可以装载Sun的 JDBC-ODBC桥。 A. new Class().load(“sun.jdbc.odbc.jdbcOdbcDriver”); B. new Class().forName(“sun.jdbc.odbc.jdbcOdbcDriver”); C. Class.forName(“sun.jdbc.odbc.jdbcOdbcDriver”); D. Class.load(“sun.jdbc.odbc.jdbcOdbcDriver”);
71. 在Java中，对于PreparedStatement的方法 setInt(int i,int x)，描述正确的是（ A. 使得第i-1个参数的值设为 x B. 使得第x-1个参数的值设为 i C. 使得第x个参数的值设为 i
D. 使得第i个参数的值设为 x
72. 以下负责建立与数据库连接的是（ ）。 A. Statement B. PreparedStatement C. ResultSet D. DriverManager
73. 使用JDBC操作数据库的顺序是（ ）。 a. 加载驱动
b. 导入驱动包
c. 发送并处理sql语句 d. 建立与数据库的连接 e． 关闭连接
A. abcde B. bcdae C. badce D. acedb
74. 以下获取结果集正确的是（ ）。【选两项】 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.prepareStatement(); ResultSet rs = pst.executeQuery(“select * from book”); D. PreparedStatement pst =
con.prepareStatement(“select * from book”); ResultSet rs = pst.executeQuery();
75. 获取ResultSet对象rst的第一行数据，以下正确的是（ ）。 A. rst.hasNext() B. rst.next() C. rst.first() D. rst.nextRow()
76. 要删除book表中书籍名称(bookName)是“java”的记录，以下代码正确的是（ String sql = ＂delete from book where bookName=?＂; PreparedStatement pst = con.prepareStatement(sql);
―――――――――――――――――
）。 ）。 pst.execute();
A. pst.setString(1,＂java＂) C. pst.setInt(0,＂java＂)
B. pst.setString(0,＂java＂)
D. 以上选项都不正确
77. 以下对JDBC驱动描述正确的是（ ）。【选两项】 A. JDBC驱动有三种 B. 使用JDBC-ODBC桥驱动方式操作数据库需提供专有的驱动程序 C. JDBC纯驱动是开发中经常使用的JDBC驱动
D. JDBC驱动分为：JDBC-ODBC桥、JDBC纯驱动、JDBC网络驱动、本地协议纯JDBC驱动
78. 以下创建只能向前滚动的只读结果集是（ ）。
A. con.prepareSatement(sql, ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY);
B. con.prepareSatement(sql, ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE);
C. con.prepareSatement(sql, ResultSet. TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
D. con.prepareSatement(sql, ResultSet. TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE);
79. 假设Connection对象为con，以下创建事务回滚点类型正确的是（ ）。 A. Savepoint sp = con.setSavepoint() C. Savepoint sp = con.getSavepoint()
B. Savepoint sp = con.createSavepoint() D. Savepoint sp = con.beginSavepoint()
80. 以下不属于ResultSet接口的方法是（ ）。
A. next() B. first() C. previous() D. hasNext()
81. 以下描述正确的是（ ）。
A. CallableStatement是PreparedStatement的父接口 B. PreparedStatement是CallableStatement的父接口 C. CallableStatement是Statement的子接口
D. PreparedStatemen是Statement的父接口
82. 存储过程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(?,?,?)}”)
83. 要通过可滚动的结果集更新数据,以下正确的是（ ）。 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,ResultSet.TYPE_SCROLL_SENSITIVE); D. pst = con.prepareStatement(sql,ResultSet.CONCUR_UPDATABLE);
84. 以下对JDBC事务描述错误的是（ ）。 A. JDBC事务属于Java事务的一种 B. JDBC事务属于容器事务类型
C. JDBC事务可以保证操作的完整性和一致性
85. 使用JDBC事务的步骤是（ ）。 a. 取消Connection的自动提交方式 b. 发生异常回滚事务 c. 获取Connection对象 d. 数据操作完毕提交事务 A. abcd
B. bcda
C. cadb
D. dcba
D. JDBC事务是由Connection发起的，并由Connection控制
86. 以下对CallbleStatement接口描述正确的是（ ）。 A. CallbleStatement可以执行单条SQL语句 B. CallbleStatement是PreparedStatment的父接口 C. CallbleStatement不可以调用带输出参数的存储过程 D. CallbleStatement可以调用带任何类型参数的存储过程
87. 以下对可滚动的结果集描述正确的是（ ）。【选两项】 A. 可滚动的结果支持结果集的任意滚动 B. 使用可滚动的结果集不能修改结果集
C. 可滚动结果集不能修改表数据 D. 可滚动结果集可以修改结果集且修改后的数据可以反映到表中
88. 在Java中，以下代码（ ）正确地创建了一个InputStreamReader类型的对象。 A. new InputStreamReader(new FileInputStream(“1.dat”)); B. new InputStreamReader(new FileReader(“1.dat”)); C. new InputStreamReader(new BufferedReader(“1.dat”)); D. new InputStreamReader(“1.dat”);
89. 给定一段Java代码片段如下，运行后，要让file.txt中的内容为hello world，可以在A处插入代码
（ ）。
File file = new File(“d:/file.txt”); try{
FileWriter fw = new FileWriter(file);
BufferedWriter writer = new BufferedWriter(fw); writer. write(“hello ”); writer. write(“world”); //A
C. writer.end();
D. writer.append(true);
}catch(Exception ex){} A. writer.flush(); B. writer.close();
90. 在java中，要判断d盘下是否存在文件 abc.txt，应该使用以下（ ）判断语句。 A. if(new File (“d:/abc.txt”).exists()==1) C. if(new File(“d:/abc.txt”).exists())
B. if(File.exists(“d:/abc.txt”)==1) D. if(File.exists(“d:/abc.txt”))
91. 给定一个Java程序的main方法的代码片段如下：假如d目录下不存在abc.txt文件，现运行该程序，
下面的结果正确的是（ ）。
try{
PrintWriter out = new
PrintWrite(new FileOutputStream(“d:/abc.txt”)); String name =”chen”;
out.print(name); out.close();
}
catch(Exception e){ System.out.println(“文件没有发现！”); }
A. 将在控制台上打印：“文件没有发现！” C. 运行后生成abc.txt，但该文件中无内容
92. Java中File类操作文件时，以下文件的分隔符正确的是（ ）。【选两项】 A. // B. \\ C. \\\\ D. /
93. 以上对RandomAccessFile类描述正确的是（ ）。 【选两项】 A. RandomAccessFile类支持“随机访问”方式
B. RandomAccessFile类只能访问文件，不能修改文件
C. RandomAccessFile类即可以随机访问文件，同时也可以修改文件 D. 对RandomAccessFile类可以一次向文件中写入一个字符串
94. 以上关于对象序列化描述正确的是（ ）。【选两项】 A. 使用FileOutputStream可以将对象进行传输
B. 使用PrintWriter可以将对象进行传输
C. 使用ObjectOutputStream类完成对象存储，使用ObjectInputStream类完成对象读取 D. 对象序列化对象所属的类需使用Serializable接口
95. 以下说法描述正确的是（ ）。
A. 使用FileOutputStream向文件写入数据时必须调用flush()方法 B. InputStreamReader是InputStream的子类 C. OutputStreamWriter是OutputStream的子类
D. 使用PrintWriter向文件写入数据时必须调用flush()方法
96. 以下对字节流字符流描述错误的是（ ）。 A. 字节流、字符流以从文件传输的格式划分 B. 字节流、字符流可以相互转换 C. 字符流操作数据不使用到缓冲区 D. 字节流操作数据不使用到缓冲区
97. 以下描述错误的是（ ）。
A. InputStream和OutputStream是抽象类 C. Reader和Writer是抽象类
98. Java中的流（Stream）是（ ）。 A. 流动的字节 B. 流动的对象
C. 流动的文件
D. 流动的数据
B. 正常运行，但没有生成文件abc.txt
D. 运行后生成abc.txt，该文件内容为：chen
B. 使用InputStream和OutputStream可以直接操作文件 D. 使用Reader和Writer操作文件须借助其子类
99. 以下对线程的描述错误的是（ ）。 A. 线程是比进程更小的单位 B. 实现多线程可以通过继承Thread类和实现Runnable接口 C. 一个进程可以不包含任何线程 D. run()方法是线程的主体
100. 以下可以暂停当前运行线程的方法是（ ）。
A. wait()
B. notify() C. sleep() D. yield()
101. 以下代码的运行结果是（ ）。 package com;
public class MyThread extends Thread{ public void run() {
for(int i = 0;i<3;i++){ }
System.out.print(i+\
}
public static void main(String[] args) { }
MyThread t = new MyThread(); Thread x = new Thread(t); t.start();
}
A. 1..2..3..
B. 0..1..2..3.. C. 0..1..2 D. 运行出错
102. 以下对线程的优先级描述正确的是（ ）。【选两项】 A. 线程的优先级有三种级别 B. 线程的优先级有四种级别 C. 可以使用指定的数字代表特定的优先级
103. 以下描述正确的是（ ）。【选两项】 A. 线程可以多次调用start()方法 B. 使用sleep()方法可以使当前线程进入休眠状态 C. 使用yield()方法可以暂停当前运行的线程，运行其他线程 D. 线程的名称是系统自动分配的，不能自定义线程对象名称
104. 以下关于线程同步的描述错误的是( )。 A. 线程同步可以解决线程资源共享的安全问题 B. 同步分为代码块同步和方法同步
C. 同步代码块或方法时，同步范围过大将引发死锁 D. 线程同步中不会出现死锁
105. 以下对线程生命周期的描述正确的是（ ）。【选两项】 A. 线程的生命周期分为就绪、运行、终止3种状态
B. 线程的生命周期分为创建、就绪、运行、阻塞、终止5种状态 C. 线程生命周期中调用yield()方法可以使线程从运行状态转换为就绪状态 D. 以上说法都不正确
106. 以下属于Runnable接口的方法是（ ）。 A. sleep()
B. start()
C. notifyAll()
D. run()
D. 线程的优先级越高一定会优先执行
107. 以下对Thread类的构造方法定义错误的是（ ）。 A. Thread() B. Thread(Runnable target)
C. Thread(String name)
D. Thread(String name,Runnable target)
108. 以下描述正确的是（ ）。 A. Runnable接口不能够实现资源共享
B. 继承Thread类适合多个线程共享资源
D. Thread类与Runnable接口在使用上是没有区别的
C.实现 Runnable接口可以方便地实现资源共享
109. 下面关于线程的代码，编译和运行结果是（ ）。 public class X extends Thread implements Runnable { public void run() {
System.out.println(\ }
public static void main(String args[]) { Thread t = new Thread(new X()); t.start(); }
}
A. 第一行会产生编译错误 C. 第六行会产生运行错误
110. 以下对代码的描述正确的是（ ）. try {
sleep(10);
} catch (InterruptedException e) { }
A. 不能通过编译，因为在run方法中可能不会捕捉到异常 B. 在第2行，线程将暂停运行，正好在10毫秒后继续运行 C. 在第2行，线程将暂停运行，最多在10毫秒内将继续运行
D. 在第2行，线程将暂停运行，将在10毫秒后的某一时刻继续运行
111. 以下描述正确的是（ ）。 A. 端口号是区分不同计算机的标识 B. IP地址是区分不同计算机的标识 C. 两台电脑可以具有相同的IP地址 D. 两个网络应用程序可以使用相同的端口号
112. 对TCP程序设计描述正确的是（ ）。
A. Java中采用TCP协议进行网络编程只能提供单向的通信 B. 采用TCP协议进行网络编程需提供服务器端和客户端 C. ServerSocket类用于TCP客户端 D. Socket类用于TCP服务器端
113. 对UDP程序设计描述正确的是（ ）。
A. 采用UDP协议进行网络编程能够保证数据的可靠传输 B. DatagramPacket用于发送和接收信息
C. DatagramSocket是UDP网络编程中的数据传输格式 D. UDP协议编程中需提供信息发送方和接收方
B. 第六行会产生编译错误
D. 程序会运行和启动，输出: this is run()
114. 以下代码中的错误描述正确的是（ ）。 DatagramSocket ds = null; DatagramPacket dp = null;
byte[] buf = new byte[1024]; try {
ds = new DatagramSocket(); dp = new DatagramPacket(buf,1024); ds.receive(dp);
String str = new
String(dp.getData(),0,dp.getLength()); str=str+ \ \ System.out.println(str);
}catch(Exception e) {
e.printStackTrace(); }
A. 构建DatagramPacket对象时未指定端口号 C. 构建DatagramSocket对象时未指定端口号
B. 构建DatagramPacket对象时未指定IP地址 D. 以上说法都不正确
115. 以下对TCP和UDP描述正确的是（ ）。 A. TCP不能提供数据的可靠传输 B. UDP能够保证数据的可靠传输 C. TCP数据传输效率高于UDP
D. UDP数据传输效率高于TCP
116. 以下描述正确的是（ ）。
A. 使用TCP编写网络应用程序时，服务器端使用ServerSocket类来监听客户端的请求 B. 在构建ServerSocket对象时不需要指定端口号 C. 在构建Socket对象时不需要指定端口号
D. TCP网络应用程序属于“点对点”模式的通讯
117. 以下描述正确的是（ ）。
A. 使用UDP编写网络应用程序时,消息发送端使用ServerSocket类监听客户端的请求 B. 使用UDP编写网络应用程序时,消息发送端使用DatagramSocket类监听发送端的请求 C. 使用UDP编写网络应用程序时，消息发送端使用Socket类监听发送端的请求 D. UDP网络应用程序可以使用telnet作为消息发送端
118. 以下描述正确的是（ ）。
A. TCP网络应用程序, 不能实现双向通信
119. 以下描述错误的是（ ）。 A. ServerSocket() C. ServerSocket(int port, int backlog)
B. ServerSocket(int port)
B. UDP数据通信比TCP数据通信安全性高 D. TCP数据通信比UDP数据通信安全性高
C. TCP数据通信比UDP数据通信数据传输效率高
D. ServerSocket(String address,int port)
120. 以下表示IP地址的操作类是（ ）。 A. Socket B. ServerSocket C. DatagramPacket
121. 以下不属于DatagramPacket构造方法的是（ ）。
D. InetAddress
A. DatagramPacket(byte[] buf, int length)
B. DatagramPacket(byte[] buf, int length, InetAddress address, int port) C. DatagramPacket(byte[] buf, int length) D. DatagramPacket(InetAddress address, int port)
122. 对于JDBC连接，以下描述正确的是( ) A. 连接是由JDBC Driver管理的 B. 连接的建立及关闭是极其耗资源的 C. 连接不需要在代码中显式关闭 D. 连接是基于RMI创建的
123. 假设类A是类B的父类，下列声明对象x的语句中不正确的是（ ）。 A. A x=new A() B. A x=new B() C. B x=new B(); D. B x=new A();
124. 关于被私有访问控制符private修饰的成员变量，以下说法正确的是（ ）。
A. 可以被三种类所引用：该类自身、与它在同一个包中的其它类、在其它包中的该类的子类 B. 可以被两种类访问和引用：该类本身、该类的所有子类 C. 只能被该类自身所访问和修改
D 只能被同一个包中的类访问
125. 为了区分重载多态中同名的不同方法，要求（ ）。 A. 采用不同的参数列表 B. 返回值类型不同 C. 调用时用类名或对象名作为前缀 D. 参数名不同
126. 下列关于子类和父类关系的叙述中，错误的是（ ）。 A. 父类不能替代子类 B. 子类能够替代父类 C. 子类继承父类 D. 父类包含子类
127. 构造BufferedInputStream的合适参数是（ ）。【选两项】 A. BufferedInputStream B. BufferedOutputStream
C. FileInputStream D. FileOuterStream E. File
128. 下面的方法可以在任何时候被任何线程调用而不会产生预期的异常的是（ ）【选三项】 A. notify() B. synchronized(this) C. notifyAll() D. sleep() E. yield()
129. 下列可以以线程方式运行的类正确的是（ ）。 A. public class X implements Thread { public void run() { }
}
B. public class X implements Runnable { protected void run() { }
}
C. public class X implements Thread {
public int run() { }
}
D. public class X extends Thread { public void run() { } }
130. 有一个类A，对于其构造函数的声明正确的是（ ）。 A. void A(int x){…}
B. A(int x){…}
C. A A(int x){…}
D. int A(int x){…}
131. 下面有关子类调用父类构造函数的描述正确的是（ ）。 A. 子类定义了自己的构造函数，就不会调用父类的构造函数
B. 子类必须通过super关键字调用父类没有参数的构造函数
C. 如果子类的构造函数没有通过super调用父类构造函数，那么子类会先调用父类不含参数的构造函数，再调用子类自己的构造函数
D. 创建子类对象时，先调用子类自己的构造函数，然后调用父类的构造函数
132. 在Java中，要定义类的保护类型元素，则必须使用的关键字是（ ）。 A. default
B. private
C. public
D. protected
133. 下述哪一组方法为在一个类中方法重载的正确写法（ ）。 A. int addValue( int a, int b ){return a+b;} float addValue ( float a, float b) {return a+b;} B. int addValue (int a, int b ){value=a+b; } float addValue ( int a, int b) {return (float)(a+b);} C. int addValue( int a, int b ){return a+1;} int addValue ( int a, int b) {return a+b;} D. int addValue( int a, int b ) {return a+b;} int addValue(int x,int y) {return x+y;}
134. 以下关键字可以抛出异常的是（ ）。 A. transient B. finally C. throw
D. static
135. finally 块中的代码将（ ）。 A. 总是被执行 B．如果try块后面没有catch块时，finally块中的代码才会执行 C. 异常发生时才被执行 D. 异常没有发生时才被执行
136. java中，用于继承父类的关键字是（ ）。 A. public B. protected C. extends D. private
137. 下列可以终止当前线程的运行的是（ ）。【选三项】 A. 抛出一个例外时 B. 当该线程调用sleep()方法时 C. 当创建一个新线程时 D. 当一个优先级高的线程进入就绪状态时
138. 关于异常处理机制的叙述以下正确的是（ ）。【选两项】
A. catch部分捕捉到异常情况时，才会执行finally部分
B. 当try区段的程序发生异常时，才会执行catch区段的程序 C. 不论程序是否发生错误及捕捉到异常，都会执行finally部分 D. 以上都是
139. 下列关于接口的叙述错误的是（ ）。【选两项】 A. 接口中的数据必须设定初值 B. 接口中无法声明一般方法 C. 接口可以声明引用 D. 以上都正确
140. Java语言中，方法的重写（Overriding）和重载（Overloading）是多态性的不同表现。下面说法正确
的是（ ）。【选两项】
A. 重写是父类与子类之间多态性的一种表现 B. 重写是一个类中多态性的一种表现 C. 重载是一个类中多态性的一种表现
D. 重载是父类与子类之间多态性的一种表现
141. 在类设计中，类的成员变量要求仅仅能够被同一package下的类访问，请问应该使用下列哪个修饰符
（ ）。 A. protected B. public C. private D. 不需要任何修饰符
142. 已知A类被打包在packageA中，B类被打包在PackageB中，且B类被声明为public，且有一个成员
变量x被声明为protected控制方式。C类也位于packageA包，且继承了B类。则以下说法中正确的是（ ）。
A. A类的实例不能访问到B类的实例
143. 下列情况中，哪一项不需要异常机制（ ）。
A. 当方法因为自身无法控制的原因而不能完成其任务时 C. 处理在方法、类库、类中抛出的异常时
144. 下面关于Set里删除对象运行结果为（ ）。 import java.util.*; public class Test {
public static void main(String args[]) { Set
System.out.println(s.size()); } } A. 1
B. 100
C. throws Exception
D. none of the Above
B. 编译出错时
D. 使系统从故障中恢复时
B. A类的实例能过访问到B类一个实例的x成员 D. C类的实例不能访问到B类的实例
C. C类的实例可以访问到B类一个实例的x成员
145. 在面向对象数据模型中，子类不但可以从其超类中继承所有的属性和方法，而且还可以定义自己的属
性和方法，这有利于实现（ ）。 A. 可移植性
B. 可扩展性
C. 安全性
D. 可靠性
146. 在如下的代码处，可以填写的选项为（ ）。 class Person { private int a; }
public class Man extends Person { public int b;
public static void main(String arg[]) { Person p = new Person(); Man t = new Man(); int i; // 这里 } } A. i =a
B. i=b
C. i=p.a
D. i=t.b
147. 假设类MyBook实现了java.io.Serializable接口，有程序中某个MyBook的实例，被写到流两次，如下
代码：
MyBook book = new MyBook(); ...some code here... out.writeObject(book);
out.writeObject(book);
在反序列化的时候，进行了如下操作:
MyBook book1 = (MyBook)in.readObject(); MyBook book2 = (MyBook)in.readObject();
请问以上过程得到的两个引用book1和book2，是否指向同一个对象(即是否book1 == book2)？（ ）。 A. book1 == book2
148. 以下方法可以防止方法被子类覆盖(Override)的是（ ）。 A. final void methoda() {} C. static void methoda() {}
B. final abstract void methoda() {} C. static final void methoda() {}
B. book1!=book2
C. book1 > book2
D. book1 < book2
149. wait、notify不在sunchronized方法或者synchronized block中被调用的后果是（ ）。 A. 没有问题，完全可以独立使用 B. 编译不能通过 C.可以编译，但运行时可能出错 D. 以上说法都不正确
150. 以下不属于JDK 中集合框架接口的是（ ）。
A. Collection
B. Set
C. List
D. Map
E. Vector