Java试题-选择题（22）

Java试题-选择题（22）

题目

1. 以下对JDBC事务描述错误的是 ？
   A) JDBC事务属于JAVA事务的一种
   B) JDBC事务属于容器事务类型
   C) JDBC事务可以保证操作的完整性和一致性
   D) JDBC事务是由Connection发起的，并由Connection控制

2. 要通过可滚动的结果集更新数据，以下正确的是 ？
   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)

3. 存储过程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(?,?,?)}”);

4. 以下描述正确的是 ？
   A) CallableStatement是PreparedStatement的父接口
   B) PreparedStatement是CallableStatement的父接口
   C) CallableStatement是Statement的子接口
   D) PreparedStatement是Statement的父接口

5. 要删除book表中书籍(bookName)是”java”的记录，以下代码正确的是 ？
   A) pst.setString(1,”java”);
   B) pst.setString(0,”java”);
   C) pst.setInt(0,”java”);
   D) 以上选项都不正确

String sql=”delete from book where bookName=?”;
PreparedStatement pst=con.preparedStatement(sql);
______________________________
pst.execute();

6. 获取ResutlSet对象rst的第一行数据，以下正确的是 ？
   A) rst.hashNext();
   B) rst.next();
   C) rst.first();
   D) rst.nextRow();

7. 以下可以正确获取结果集的有 ？
   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();

8. 执行下列语句，变量a的值为：（）
   A. 0x26bdc00
   B. 0xc6bdc00
   C. 0x3fa0000
   D. 0x7e02ffff

int a = 0x9af700; //1001 1010 1111 0111 0000 0000
a <<= 2;

9. 下列代码的输出结果是（） ？
   A.0
   B.99
   C.100
   D.101

int j=0;
for(int i=0;i<100;i++){j=j++;
}
System.out.println(j);

10. 下列代码，如果想保证程序的输出结果是[1,2],那么<插入代码>处应填入的代码是（）
    A.Set set = new TreeSet();
    B.Set set = new HashSet();
    C.Set set = new SortedSet();
    D.Set set = new LinkedHashSet()

public static void main(String[] args) {< 插入代码>set.add(new Integer(2));set.add(new Integer(1));System.out.println(set);
}

11. 下列代码的运行结果是（） ？
    A.编译失败
    B.运行时,抛出异常
    C.Forest的实例被序列化到文件
    D.Forest的实例和Tree的实例都被序列化到文件

public class Forest implements Serializable {private Tree tree = new Tree();public static void main(String[] args) {Forest f = new Forest();try {FileOutputStream fs = new FileOutputStream(“Forest.ser”);ObjectOutputStream os = new ObjectOutputStream(fs);os.writeObject(f);os.close();} catch (Exception ex) {ex.printStackTrace();}}
}
class Tree {}

12. 请看下列代码，假设运行后输出“The value of p is 420”，那么<插入代码>处应填入代码是：
    A. p.setWeight(420);
    B. Payload.setWeight(420);
    C. p = new Payload(420);
    D. p = new Payload(); p.setWeight(420);

class Payload {private int weight;public Payload(int wt) {weight = wt;}public Payload() {}public void setWeight(int w) {weight = w;}public String toString() {return Integer.toString(weight);}
}
public class TestPayload {static void changePayload(Payload p) {< 插入代码>}public static void main(String[] args) {Payload p = new Payload();p.setWeight(1024);changePayload(p);System.out.println(“The value of p is ” + p);}
}

13. 下面关于ResultSet说法错误的是()
    A.ResultSet的的方法getString(…)意为取得该列的数据以字符串的形式返回
    B.查询结束后，ResutSet中的游标指向第一条记录之上，因此要先调用一次next才有可能取得记录
    C.查询结束后，所有的结果数据将一次被存储在ResultSet对象中
    D.关闭连接时最好按照resultSet先关，statement接着，connection最后的顺序

14. Java语句 String s=”a”+”b”+”c”+”d”+”e”; 创建对象的总个数是：（） ？
    A.1
    B.2
    C.3
    D.4

15. 下列代码的输出结果是 ？
    A. 0
    B. 0.1
    C. 0.10000000000000009
    D. 0.10

public static void main(String[] args) {BigDecimal d1 = new BigDecimal(“3.0″);BigDecimal d2 = new BigDecimal(“2.9″);BigDecimal d3 = d1.subtract(d2);System.out.println(d3);
}

16. 运行下面程序，输出的结果是：
    A.
    condition 1
    finally
    B.
    condition 2
    finally
    C.
    condition 1
    condition 3
    finally
    D.
    condition 1
    condition 2
    finally

public class Foo{public static void main(String[] args) {try {test();System.out.println(“condition 1″);} catch (ArrayIndexOutOfBoundsException e) {System.out.println(“condition 2″);} catch (Exception e) {System.out.println(“condition 3″);} finally {System.out.println(“finally”);}}public static void test() {String str = “cc”;str.compareTo(“abc”);}
}

17. 关于下列代码说法正确的是 ？
    A. 该类编译失败
    B. 输出：1
    C. 输出：3
    D. 输出：0

public class A {private int counter = 0;public static int getInstanceCount() {return counter;}public A() {counter++;}public static void main(String[] args) {A a1 = new A();A a2 = new A();A a3 = new A();System.out.println(A.getInstanceCount());}
}

18. 运行下列代码发生的异常或错误是 ？
    A. java.lang. StackOverflowError
    B. java.lang.IllegalStateException
    C. java.lang.ExceptionlnlnitializerError
    D. java.lang.ArraylndexOutOfBoundsException

public class ClassB {public void count(int i) {count(++i);}public static void main(String[] args) {ClassB a = new ClassB();a.count(3);}
}

19. 为了获取远程主机的文件内容，当创建URL对象后，需要使用哪个方法获取信息()
    A. getHost()
    B.openStream(
    C. getPort()
    D.openConnection()

20. 下列Java类的定义，错误的是（） ？
    A.public class Test extends Object{……}
    B.final class Operators{……}
    C.class Point{……}
    D.void class Point{……}

答案

1	2	3	4	5	6	7	8	9	10
B	A	C	B	A	B	A	A	A	A

11	12	13	14	15	16	17	18	19	20
B	A	C	A	B	A	A	A	B	D

解析

1. B

B) JDBC事务属于容器事务类型‌：错误。JDBC事务是‌本地事务（resource-local transaction）‌，由数据库连接（Connection）直接管理，仅限于单个数据库。而“容器事务”通常指由Java EE应用服务器（如WebLogic、JBoss）管理的‌分布式事务‌，使用JTA（Java Transaction API）实现，支持跨多个资源（如多个数据库）。JDBC事务不属于容器事务类型，因此该描述错误。

2. A

A) pst=con.prepareStatement(sql, ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE)‌
同时满足可滚动（TYPE_SCROLL_SENSITIVE）和可更新（CONCUR_UPDATABLE），正确。

B) pst=con.prepareStatement(sql, ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY)‌
结果集可滚动，但并发模式为只读（CONCUR_READ_ONLY），无法更新数据。

C) pst=con.prepareStatement(sql, ResultSet.TYPE_SCROLL_SENSITIVE)‌
语法错误：prepareStatement 方法的重载要求同时指定结果集类型和并发模式（两个参数）。仅提供一个参数会导致编译失败。

D) pst=con.prepareStatement(sql, ResultSet.CONCUR_UPDATABLE)‌
语法错误：同样缺少参数，CONCUR_UPDATABLE 必须与结果集类型（如 TYPE_SCROLL_SENSITIVE）一起指定。

3.C

选项A‌: CallableStatement cst=con.prepareCall(“(call pro(?,?))”);
错误：使用了圆括号()而不是花括号{}。JDBC要求存储过程调用必须用{}包裹。

选项B‌: CallableStatement cst=con.prepareCall(“(call pro(?))”);
错误：使用了圆括号()而非花括号{}，并且参数数量不正确（只有1个）。存储过程需要两个参数（一个输入，一个输出），但这里只提供了一个?。

选项C‌: CallableStatement cst=con.prepareCall(“{call pro(?,?)}”);
正确：使用了花括号{}，参数数量为两个?，符合存储过程的定义。第一个?对应输入参数，第二个?对应输出参数（后续需要通过cst.registerOutParameter(2, Types.XXX)注册为输出类型）。

选项D‌: CallableStatement cst=con.prepareCall(“{call pro(?,?,?)}”);
错误：使用了花括号{}，但参数数量为三个?，而存储过程只有两个参数。这会抛出SQLException，因为参数数量不匹配。

4. B

Statement 是顶层接口，用于执行静态SQL语句。
PreparedStatement 继承自 Statement，是它的子接口，用于预编译SQL语句，提高执行效率。
CallableStatement 继承自 PreparedStatement，是它的子接口，专门用于调用存储过程。

因此，继承链为：
Statement ← PreparedStatement ← CallableStatement

分析选项：
A) CallableStatement是PreparedStatement的父接口‌：错误。CallableStatement 是 PreparedStatement 的子接口，而不是父接口。
B) PreparedStatement是CallableStatement的父接口‌：正确。PreparedStatement 是 CallableStatement 的直接父接口。
C) CallableStatement是Statement的子接口‌：错误。虽然 CallableStatement 间接继承自 Statement（通过 PreparedStatement），但“子接口”通常指直接继承关系。CallableStatement 的直接父接口是 PreparedStatement，而不是 Statement。Statement 的直接子接口是 PreparedStatement。
D) PreparedStatement是Statement的父接口‌：错误。PreparedStatement 是 Statement 的子接口，而不是父接口。

5. A

PreparedStatement 的参数占位符（?）索引是从 ‌1‌ 开始计数的，而非0。因此 setString(1, “java”) 是正确的。

6.B

A) rst.hashNext();‌：
错误。ResultSet 没有 hashNext() 方法（可能是拼写混淆）。正确的方法是 hasNext()，但 JDBC 的 ResultSet 实际使用的是 ‌next()‌。

B) rst.next();‌：
正确‌。next() 方法将游标‌从初始位置移动到第一行‌。如果第一行存在则返回 true，否则返回 false。这是获取第一行数据的标准操作。

C) rst.first();‌：
错误。first() 方法仅适用于‌可滚动的 ResultSet‌（如 TYPE_SCROLL_INSENSITIVE），但默认的 ResultSet 是‌不可滚动‌的（只能单向移动）。若在默认 ResultSet 上调用 first() 会抛出 SQLFeatureNotSupportedException。

D) rst.nextRow();‌：
错误。ResultSet 没有 nextRow() 方法（该方法不存在于 JDBC API 中）。

7.A

Statement 的正确用法‌：
创建：con.createStatement()
执行查询：sta.executeQuery(String sql)

PreparedStatement 的正确用法‌：
创建：con.prepareStatement(String sql)（‌注意拼写‌）
执行查询：pst.executeQuery()（‌无参数‌）

常见错误‌：
方法名拼写错误（如 preparedStatement）。
参数缺失或多余（如 createStatement(sql) 或 executeQuery(sql) 用于 PreparedStatement）。

8. A

初始值‌：
int a = 0x9af700;
十六进制 0x9af700 的二进制表示为：
1001 1010 1111 0111 0000 0000（24位）。
在 int 类型（32位）中，完整二进制为：
00000000 10011010 11110111 00000000。

左移操作‌：
a <<= 2; 表示将 a 的二进制值左移 2 位：
高位溢出部分丢弃，低位补 0。
移位后二进制结果为：
00000010 01101011 11011100 00000000。

转换为十六进制‌：
将 32 位二进制按 4 位一组分组：
0000 0010 0110 1011 1101 1100 0000 0000
对应的十六进制：
0 2 6 B D C 0 0
合并结果为：‌0x026bdc00‌（通常简写为 0x26bdc00）。

9. A

代码中，j = j++; 是核心语句。
j++ 是后缀递增操作符，其行为是：返回 j 的当前值，然后将 j 增加 1。

因此，j = j++; 的执行步骤为：
1、计算 j++：返回 j 的当前值（例如初始值 0），然后 j 被隐式增加为 1。
2、将步骤 1 返回的值（0）赋值给 j，覆盖了之前的增加，因此 j 最终变回 0。

在循环中，每次迭代执行 j = j++;：
无论迭代多少次（这里循环 100 次），j 的值始终被重置为 0。
最终，System.out.println(j); 输出 0。

如果改为 j++;（不带赋值），则每次迭代 j 会增加 1，输出 100。
如果改为 j = ++j;（前缀递增），则输出 100。
但此处是 j = j++;，因此输出为 0。

10. A

A) Set set = new TreeSet();‌
TreeSet 基于红黑树实现，元素‌按自然顺序（升序）自动排序‌。
添加 Integer(2) 和 Integer(1) 后，会排序为 [1, 2]。

B) Set set = new HashSet();‌
HashSet 基于哈希表实现，‌不保证顺序‌（可能输出 [1,2] 或 [2,1]）。
顺序不确定。

C) Set set = new SortedSet();‌
SortedSet 是一个‌接口‌，无法直接实例化（编译错误）。
语法错误。

D) Set set = new LinkedHashSet();‌
LinkedHashSet 维护‌插入顺序‌。
先添加 2，后添加 1，输出为 [2, 1]。

11. B

序列化要求‌：
如果一个类实现了 Serializable 接口，其所有成员变量必须是可序列化的（基本类型或实现 Serializable 的引用类型）。
此处 Forest 实现了 Serializable，但其成员 private Tree tree = new Tree(); 中的 Tree 类‌未实现 Serializable 接口‌。

序列化过程‌：
当执行 os.writeObject(f) 时，会尝试序列化 Forest 对象及其所有成员（包括 tree 对象）。
由于 Tree 类不可序列化，Java 会抛出 java.io.NotSerializableException（运行时异常）。

12. A

A. p.setWeight(420);‌
直接调用 p 的 setWeight 方法，修改 weight 为 420。符合逻辑。

B. Payload.setWeight(420);‌
错误：setWeight 是实例方法，不能通过类名调用。

C. p = new Payload(420);‌
错误：重新赋值 p 不会影响原对象（Java 是值传递）。

D. p = new Payload(); p.setWeight(420);‌
错误：同 C，重新创建对象不会影响原对象。

13. C

错误原因分析：
ResultSet 的数据加载机制‌：
ResultSet ‌默认不会一次性加载所有查询结果‌（特别是大型数据集）。它的行为取决于驱动和配置：
对于 TYPE_FORWARD_ONLY 类型的 ResultSet，数据通常是‌逐步从数据库流式传输‌的（按需加载）。
即使使用可滚动的 ResultSet，驱动程序也可能分批加载数据（非一次性全加载）。
数据库连接关闭前，ResultSet 可能只持有部分结果集。

14. A

编译器优化‌：
由于所有连接的元素都是字符串字面量（常量），编译器会在编译阶段直接将其合并为一个完整的字符串常量 “abcde”。
编译后的代码等价于：String s = “abcde”;。

15. B

BigDecimal 的精确计算‌：
BigDecimal 用于高精度的十进制运算，避免浮点计算的精度误差。
使用字符串构造（如 new BigDecimal(“3.0”)）可以精确表示数值。

数学上：3.0 - 2.9 = 0.1。
BigDecimal 会精确输出 0.1‌，没有浮点误差。

16. A

A‌：输出 condition 1 和 finally（符合逻辑）。
B‌：包含 condition 2（不匹配，未触发 ArrayIndexOutOfBoundsException）。
C‌：包含 condition 3（不匹配，未触发任何 Exception）。
D‌：包含 condition 2（不匹配，未触发异常）。

17. A

编译错误‌：
getInstanceCount() 是静态方法（static），但试图直接访问实例变量（非静态）counter。
Java 规则‌：静态方法只能访问静态成员（类变量/方法），不能直接访问实例成员。
编译器会报错：non-static variable counter cannot be referenced from a static context。

18. A

代码逻辑分析‌：
类 ClassB 包含一个递归方法 count(int i)，每次调用时对参数 i 进行自增（++i）并再次调用自身。
main 方法中创建 ClassB 实例并调用 count(3)，触发无限递归。
递归调用无终止条件，导致栈空间被持续占用，最终抛出 ‌栈溢出错误‌（StackOverflowError）。

19. B

openStream()‌：
URL类的openStream()方法直接‌打开与远程资源的连接，并返回一个InputStream‌，用于读取文件内容（如文本、二进制数据）。这是获取文件内容的最简方式。

其他选项分析‌：
A. getHost()‌：仅返回URL的主机名（如example.com），不涉及文件内容。
C. getPort()‌：返回URL的端口号（未显式指定时返回-1），与文件内容无关。
D. openConnection()‌：返回URLConnection对象，需通过getInputStream()进一步获取输入流，步骤多于openStream()，非最直接方式。

20. D

语法错误‌：Java类的声明‌不能包含返回类型‌（如void、int等）。
正确语法应为：[访问修饰符] class 类名 { … }
void是方法的返回类型标识符，只能用于方法声明（如void method()）。