当前位置：首页 > news >正文

Java试题-选择题（3）

news 2025/8/2 8:08:27

Java试题-选择题（3）

题目

开发中使用泛型取代非泛型的数据类型（比如用ArrayList取代ArrayList），程序的运行时性能会变得更好。（）？
A 正确
B 错误
关于异常的编程，以下描述错误的是：（）？
A：在有除法存在的代码处，为了防止分母为零，必须抛出并捕获异常
B：int i=Integer.parseInt(”123a”);将产生NumberFormatException
C：int a[]=null; a[0]=1; 将产生NullPointerException
D：输入输出流编程中，读和写时都要抛出IOException
以下程序的运行结果是：( ) ？
A：编译失败
B：发生运行时异常
C：[606, 608, 609，610, 612] [608, 609，610]
D：[606, 608, 609，610, 612] [608, 610]

TreeSet<Integer> set = new TreeSet<Integer>();
TreeSet<Integer> subSet = new TreeSet<Integer>();
for(int i=606;i<613;i++){if(i%2==0){set.add(i);}
}
subSet = (TreeSet)set.subSet(608,true,611,true);
set.add(609);
System.out.println(set+" "+subSet);

以下哪个式子有可能在某个进制下成立（）？
A：1314=204
B：1234=568
C：14*14=140
D：1+1=3
对于JVM内存配置参数：其最小内存值和Survivor区总大小分别是（）？
-Xmx10240m -Xms10240m -Xmn5120m -XXSurvivorRatio=3
A:5120m，1024m
B:5120m，2048m
C:10240m，1024m
D:10240m，2048m
java中Hashtable, Vector, TreeSet, LinkedList哪些线程是安全的？（多选）
A：Hashtable
B：Vector
C：TreeSet
D：LinkedList
在J2EE中，使用Servlet过滤器，需要在web.xml中配置（）元素?（多选）
A：filter
B：filter-mapping
C：servlet-filter
D：filter-config
以下说法中正确的有？（多选）
A：StringBuilder是线程不安全的
B：Java类可以同时用 abstract和final声明
C：HashMap中，使用 get(key)==null可以判断这个Hasmap是否包含这个key
D：volatile关键字不保证对变量操作的原子性
不能用来修饰interface的有（）（仅限外部接口）？（多选）
A：private
B：public
C：protected
D：static
下列哪些情况下会导致线程中断或停止运行（）？
A：抛出InterruptedException异常
B：线程调用了wait方法
C：当前线程创建了一个新的线程
D：高优先级线程进入就绪状态
Gadget has-a Sprocket and Gadget has-a Spring and Gadget is-a Widget and Widget has-a Sprocket 以下哪两段代码可以表示这个关系? (选择两项) ( ) ？（多选）
A：class Widget { Sprocket s; }
class Gadget extends Widget { Spring s; }
B：class Widget { }
class Gadget extends Widget { Spring s1; Sprocket s2; }
C：class Widget { Sprocket s1; Spring s2; }
class Gadget extends Widget { }
D：class Gadget { Spring s; }
class Widget extends Gadget{ Sprocket s; }
Java类Demo中存在方法func1、func2、func3和func4，请问该方法中，哪些是不合法的定义？( )（多选）
A：func1
B：func2
C：func3
D：func4

public class Demo{float func1(){int i=1;return;}float func2(){short i=2;return i;}float func3(){long i=3;return i;}float func4(){double i=4;return i;}
}

Hashtable 和 HashMap 的区别是？（多选）
A：Hashtable 是一个哈希表，该类继承了 AbstractMap，实现了 Map 接口
B：HashMap 是内部基于哈希表实现，该类继承AbstractMap，实现Map接口
C：Hashtable 线程安全的，而 HashMap 是线程不安全的
D：Properties 类继承了 Hashtable 类，而 Hashtable 类则继承Dictionary 类
E：HashMap允许将 null 作为一个 entry 的 key 或者 value，而 Hashtable 不允许。
若在某一个类定义中定义有如下的方法： abstract void performDial( ); 该方法属于（）？
A：本地方法
B：最终方法
C：解态方法
D：抽象方法
“先进先出”的容器是：( ) ？
A：堆栈(Stack)
B：队列（Queue）
C：字符串(String)
D：迭代器(Iterator)
在上下文和头文件正常的情况下，代码System.out.println(10%3*2);将打印？
A：1
B：2
C：4
D：6
与未加访问控制符的缺省情况相比，public和protected修饰符扩大了属性和方法的被访问范围，private修饰符则缩小了这种范围？
A正确
B错误
在异常处理中，以下描述不正确的有？
A：try块不可以省略
B：可以使用多重catch块
C：finally块可以省略
D：catch块和finally块可以同时省略
假设 A 类有如下定义，设 a 是 A 类的一个实例，下列语句调用哪个是错误的？（）？
A：System.out.println(a.i);
B：a.method1();
C：A.method1();
D：A.method2();

public class A
{public int i;static String s;void method1(){}static void method2(){}
}

委托事件模型中，源生成事件并把它发送给一个或多个监听器，每个监听器必须向事件源注册？
A正确
B错误

答案与解析

1. B

Java泛型（如ArrayList）主要通过编译时类型擦除实现：泛型类型信息在编译阶段被移除，生成的字节码与非泛型代码（如原始ArrayList）几乎相同，因此不会改善运行时性能。
泛型提升了类型安全和代码可读性，但执行速度不受影响，因为它仅是语法糖而非运行时优化机制。
潜在性能优化仅限编译时（如减少强制类型转换），但JVM运行效率不变。

2. A

A: 在有除法存在的代码处，为了防止分母为零，必须抛出并捕获异常‌ — 错误。分母为零会抛出 ArithmeticException，这是一个运行时异常（RuntimeException 的子类），在Java中不强制要求必须抛出或捕获，开发者可以选择忽略或处理它。
例如：int result = 10 / 0; 会抛出异常，但代码中无需显式声明或捕获。
B: int i = Integer.parseInt(“123a”); 将产生 NumberFormatException‌ — 正确。字符串 “123a” 无法解析为整数，Integer.parseInt 方法会抛出 NumberFormatException。
C: int a[] = null; a[0] = 1; 将产生 NullPointerException‌ — 正确。数组引用 a 为 null，尝试访问其元素时会抛出 NullPointerException。
D: 输入输出流编程中，读和写时都要抛出 IOException‌ — 正确。Java的输入输出流操作（如文件读写）可能因I/O错误（如文件不存在）抛出 IOException，需要在代码中处理（捕获或声明抛出）。
综上，错误描述是A。

3. C

程序的运行结果是选项C：[606, 608, 609, 610, 612] [608, 609, 610]。原因分析如下：

初始循环中，set 添加了606到612之间（不包括613）的所有偶数，结果为 {606, 608, 610, 612}。
subSet = set.subSet(608, true, 611, true) 返回一个基于原集合的视图，包含范围从608（包含）到611（包含）的元素。初始时，视图中的元素为 {608, 610}（因为611未被添加）。
执行 set.add(609) 后，原集合变为 {606, 608, 609, 610, 612}。由于 subSet 是原集合的视图，且609在子集范围内（608 ≤ 609 ≤ 611），它会自动添加到子集中，因此 subSet 更新为 {608, 609, 610}。
最终输出时，set 打印为 [606, 608, 609, 610, 612]，subSet 打印为 [608, 609, 610]，与选项C一致。

此行为由 TreeSet.subSet 的视图特性决定：对原集合的修改会实时反映在子集视图中，因此选项A（编译失败）和选项B（运行时异常）不正确；选项D错误，因为它忽略了子集视图的动态更新。

4. A

根据给定的选项分析，等式“13*14=204”在八进制下成立，而其他选项在任何进制下均不成立。具体解析如下：

选项 A：13*14=204（即 13 乘以 14 等于 204）

假设该等式在 (n) 进制下成立，则数字解析为：
- 左侧：( (1 \times n + 3) \times (1 \times n + 4) )
- 右侧：( 2 \times n + 0 \times n + 4 )
建立方程：( (n + 3)(n + 4) = 2n + 4 )
展开并简化：( n + 7n + 12 = 2n + 4 ) → ( n - 7n - 8 = 0 )
解得：( n = 8 ) 或 ( n = -1 )（舍去负值），故 ( n = 8 )
在八进制下验证：13₈ = 11₁₀, 14₈ = 12₁₀, 204₈ = 132₁₀，且 11 × 12 = 132，成立。

选项 B：12*34=568（即 12 乘以 34 等于 568）

假设在 (n) 进制下：
- 左侧：( (1 \times n + 2) \times (3 \times n + 4) )
- 右侧：( 5 \times n + 6 \times n + 8 )
建立方程：( (n + 2)(3n + 4) = 5n + 6n + 8 )
展开并简化：( 3n + 10n + 8 = 5n + 6n + 8 ) → ( 2n - 4n = 0 ) → ( n(2n - 4) = 0 )
解得：( n = 0 )（无效）或 ( n = 2 )
但在二进制（(n=2)）下，数字范围应为 0-1，而选项中出现 2、3、4、5、6、8 等超范围数字，违反进制规则，故无解。

选项 C：14*14=140（即 14 乘以 14 等于 140）

假设在 (n) 进制下：
- 左侧：( (1 \times n + 4) )
- 右侧：( 1 \times n + 4 \times n + 0 )
建立方程：( (n + 4) = n + 4n ) → ( n + 8n + 16 = n + 4n ) → ( 4n = -16 )
解得：( n = -4 )（无效，进制必须为正整数）
个位分析：左侧个位 (4 \times 4 = 16) 应等于右侧个位 0，即 (16 \mod n = 0)，但代入方程仍得负解，矛盾，故无解。

选项 D：1+1=3

在任何 (n) 进制下，(1 + 1 = 2)（十进制值），而右侧 3 的十进制值为 3。
恒有 (2 \neq 3)，矛盾，且无合理的 (n) 满足此等式。

综上，仅选项 A 可能在某个进制下成立（八进制时成立）。

5. D

关键参数解析：
-Xms10240m‌：指定JVM初始堆大小（即最小内存值），为10240m。
-Xmn5120m‌：设置年轻代（Young Generation）大小为5120m。
-XXSurvivorRatio=3‌：定义Eden区与单个Survivor区的比例比为3:1；由于年轻代包含一个Eden区和两个Survivor区，总比例分配为Eden:Survivor1 = 3:1:1（即5等份）。
Survivor区大小计算：
年轻代总大小（-Xmn）为5120m，按比例分为5份：
每份大小 = 5120m / 5 = 1024m。
单个Survivor区大小 = 1024m。
Survivor区总大小（两个Survivor区之和） = 1024m × 2 = 2048m。

综上，参数配置下最小内存值为10240m，Survivor区总大小为2048m。

6. AB

线程安全的集合实现是：
A: Hashtable‌（所有方法使用 synchronized 修饰）
B: Vector‌（所有方法使用 synchronized 修饰）

非线程安全的集合实现包括：
C: TreeSet‌（基于 TreeMap 实现，未添加同步控制）
D: LinkedList‌（未进行同步处理，并发修改可能引发问题）

7. AB

在J2EE中配置Servlet过滤器时，必须在web.xml文件中声明两个核心元素：‌‌和‌‌。具体说明如下：
元素（对应选项A）‌：用于定义过滤器的基础信息，包括过滤器名称（）、实现类（）以及可选的初始化参数（）。
元素（对应选项B）‌：用于声明过滤器的映射规则，指定该过滤器拦截的URL模式（）或Servlet名称（）。

错误选项分析：
C: servlet-filter‌：J2EE规范中无此元素，属于无效命名。
D: filter-config‌：filter-config并非配置元素；过滤器参数通过内的子元素定义，而非独立元素。

因此，正确答案为‌A（filter）和 B（filter-mapping）‌。

8. AD

A: StringBuilder 是线程不安全的‌：正确。StringBuilder 的设计未考虑线程同步，因此在多线程环境下并发修改可能导致数据不一致或异常。与之对比，StringBuffer 通过同步方法实现了线程安全。
B: Java 类可以同时用 abstract 和 final 声明‌：错误。abstract 修饰类表示该类需被子类继承以实现抽象方法，而 final 修饰类表示该类不可被继承，两者语义冲突，Java 语法不允许同时使用。
C: HashMap 中，使用 get(key)==null 可以判断这个 HashMap 是否包含这个 key‌：错误。get(key)==null 可能表示 key 不存在，也可能表示 key 存在但其关联的 value 为 null（HashMap 允许 null 值和 null 键）。要准确判断 key 是否存在，应使用 containsKey(key) 方法。
D: volatile 关键字不保证对变量操作的原子性‌：正确。volatile 仅保证变量的可见性（即修改对其他线程立即可见）和禁止指令重排序，但不保证复合操作（如自增 i++）的原子性；原子性需通过 synchronized 或原子类实现。

正确的说法为 A 和 D‌。

9. ACD

不能用来修饰外部接口（interface）的选项是：
A. private‌：private 访问权限限制接口仅在当前类可见，但外部接口需被其他类实现，故不可用。
C. protected‌：protected 要求子类继承或同包访问，而接口通过实现（非继承）开放给所有类，与权限冲突。
D. static‌：static 修饰符仅适用于嵌套接口（内部接口），题目限定为外部接口（顶层接口），故不可用。

唯一可用的修饰符是：
B. public‌：public 允许接口被任何类访问并实现，符合外部接口的开放特性。

10. A

在 Java 线程机制中，导致线程中断或停止运行的情况分析如下：
正确选项分析：
A：抛出 InterruptedException 异常‌
当线程抛出 InterruptedException 异常时，表明该线程被中断请求触发，通常会终止当前阻塞状态（如 sleep(), wait()）并清除中断标志。线程需主动响应此异常以终止运行，否则可能继续执行。
错误选项辨析：
B：线程调用了 wait 方法‌
wait() 仅使线程进入等待队列（阻塞状态），需通过 notify() 唤醒，不会直接导致中断或停止运行。
C：当前线程创建了一个新的线程‌
创建新线程（如 new Thread().start()）不会中断当前线程，二者并行执行。
D：高优先级线程进入就绪状态‌
高优先级线程可能抢占 CPU 资源，但仅暂停当前线程运行（转为就绪态），不会中断或停止其执行。

11. AC

根据给定的关系：

Gadget has-a Sprocket（Gadget 包含一个 Sprocket 对象）
Gadget has-a Spring（Gadget 包含一个 Spring 对象）
Gadget is-a Widget（Gadget 是 Widget 的子类）
Widget has-a Sprocket（Widget 包含一个 Sprocket 对象）

分析各选项代码：

选项 A：
```
class Widget { Sprocket s; }
class Gadget extends Widget { Spring s; }
```
- Gadget 继承自 Widget（Gadget is-a Widget）。
- Widget 定义了 Sprocket 字段（Widget has-a Sprocket）。
- Gadget 继承了 Widget 的 Sprocket 字段，因此 Gadget has-a Sprocket（通过继承）。
- Gadget 自身定义了 Spring 字段（Gadget has-a Spring）。
  满足所有关系。
选项 B：
```
class Widget { }
class Gadget extends Widget { Spring s1; Sprocket s2; }
```
- Gadget 继承自 Widget（Gadget is-a Widget）。
- Gadget 定义了 Spring 和 Sprocket 字段（Gadget has-a Spring 和 has-a Sprocket）。
- 但 Widget 未定义任何 Sprocket 字段，因此 不满足 Widget has-a Sprocket。
选项 C：
```
class Widget { Sprocket s1; Spring s2; }
class Gadget extends Widget { }
```
- Gadget 继承自 Widget（Gadget is-a Widget）。
- Widget 定义了 Sprocket 字段（Widget has-a Sprocket）。
- Gadget 继承了 Widget 的 Sprocket 和 Spring 字段，因此 Gadget has-a Sprocket 和 has-a Spring（通过继承）。
  满足所有关系。（虽然 Widget 额外定义了 Spring 字段，但问题未禁止 Widget 拥有其他字段，因此不影响关系。）
选项 D：
```
class Gadget { Spring s; }
class Widget extends Gadget { Sprocket s; }
```
- Widget 继承自 Gadget，但问题要求 Gadget is-a Widget（Gadget 是 Widget 的子类），而此处关系颠倒（Widget is-a Gadget），因此 不满足 Gadget is-a Widget。

因此，能正确表示关系的代码是选项 A 和 C。

答案：A 和 C

12. AD

在Java类Demo的方法定义中，不合法的方法为func1（选项A）和func4（选项D）。具体分析如下（基于方法返回值类型与返回表达式的一致性要求）：

方法合法性分析：

func1（选项A）不合法：
- 方法声明返回float类型，但实际return;语句未提供任何返回值（即等效于返回void），这违反了Java方法必须有返回值的语法规则（除非方法声明为void）。
- 编译器错误：missing return value。
```
float func1() {int i=1;return; // 错误：缺少返回值
}
```
func2（选项B）合法：
- 方法声明返回float，实际返回short类型的变量i（值为2）。
- short是整型，Java允许整型到浮点型的隐式转换（short自动提升为float），因此合法。
```
float func2() {short i=2;return i; // 合法：short → float 隐式转换
}
```
func3（选项C）合法：
- 方法声明返回float，实际返回long类型的变量i（值为3）。
- long是整型，其数值范围（-9.2E18 ~ +9.2E18）在float的表示范围（-3.40E+38 ~ +3.40E+38）内，因此Java允许隐式转换（尽管可能有精度损失）。
```
float func3() {long i=3;return i; // 合法：long → float 隐式转换
}
```
func4（选项D）不合法：
- 方法声明返回float，但实际返回double类型的变量i（值为4）。
- double的精度和范围（-1.79E+308 ~ +1.79E+308）高于float，Java不允许从高精度类型到低精度类型的隐式转换，需显式强制转换（如(float)i）。
- 编译器错误：incompatible types: possible lossy conversion from double to float。
```
float func4() {double i=4;return i; // 错误：需强制转换为(float)
}
```

13. BCDE‌

Hashtable 与 HashMap 的区别分析如下（：

继承关系
- Hashtable 继承 Dictionary 类（非 AbstractMap）。
- HashMap 继承 AbstractMap 类，并实现 Map 接口。
  选项 B 正确（描述 HashMap），选项 D 正确（描述 Properties 与 Hashtable 关系）。
  选项 A 错误：Hashtable 未继承 AbstractMap。
线程安全性
- Hashtable 方法用 synchronized 修饰，实现线程安全。
- HashMap 非线程安全（需手动同步）。
  选项 C 正确。
对 null 键值的支持
- HashMap 允许一个 null 键和多个 null 值。
- Hashtable 不允许 null 键或值（插入 null 会抛出 NullPointerException）。
  选项 E 正确。
其他关键差异
- 迭代器：HashMap 使用 Iterator，Hashtable 使用 Enumeration。
- 扩容机制：
  - HashMap 默认容量 16，扩容为 2 倍。
  - Hashtable 默认容量 11，扩容为 2 倍 + 1。
- 哈希计算：HashMap 通过扰动函数优化哈希分布，Hashtable 直接取模。

14. D

抽象方法（D选项）‌：
方法声明包含 abstract 关键字且以分号结束（无方法体），如 abstract void performDial();。该方法必须在抽象类中定义，并要求子类实现其具体逻辑。

其他选项错误原因‌：
A：本地方法‌：本地方法需使用 native 关键字，表示用其他语言实现，而题目方法未使用此修饰符。
B：最终方法‌：最终方法需使用 final 关键字，禁止子类重写，与 abstract 要求的必须被实现语义冲突。
C：解态方法‌：此选项可能为笔误（应为“静态方法”）。静态方法需使用 static 关键字，可直接通过类调用，但 abstract 方法不能为静态，因其实例化需依赖子类。（注：搜索结果中选项为“静态方法”，但题目表述不影响判断逻辑）

15. B

“先进先出”的容器是队列（Queue）。

队列（Queue）‌：严格遵循先进先出（FIFO）原则，数据从队尾插入、队首移除，保证先进入的元素优先被处理。
其他选项辨析：
堆栈（Stack）‌：采用后进先出（LIFO）机制，与先进先出矛盾。
字符串（String）‌：仅存储字符序列，无特定存取顺序规则。
迭代器（Iterator）‌：用于遍历集合元素，其顺序取决于底层数据结构而非自身特性。

16. B

10 % 3‌（取模运算）：
10 除以 3 的余数是 1。
结果为 1。
1 * 2 = 2。
最终输出结果为 ‌2‌。

17. A

访问控制修饰符的比较：

缺省（无修饰符）‌：
访问范围：仅允许‌同一个包内‌的类访问。

public修饰符‌：
访问范围：‌所有类‌（无论是否同包）均可访问。
结论‌：相比缺省情况，public显著‌扩大了访问范围‌。

protected修饰符‌：
访问范围：允许‌同一个包内‌的类访问 + ‌不同包中的子类‌访问。
结论‌：相比缺省情况，protected额外覆盖了不同包的子类，因此‌扩大了访问范围‌。

private修饰符‌：
访问范围：仅允许‌当前类内部‌访问。
结论‌：相比缺省情况（同包可访问），private严格限制到当前类，因此‌缩小了访问范围‌。

18. D

A：try块不可以省略‌ — 正确。在异常处理结构中，try块是必需的，用于包裹可能抛出异常的代码；若省略try，单独的catch或finally块将无法存在并导致编译错误。
B：可以使用多重catch块‌ — 正确。Java语言支持在try块后使用多个catch块，以分别处理不同类型的异常（需注意异常类继承顺序）。
C：finally块可以省略‌ — 正确。finally块用于资源清理等最终操作，但它是可选的（例如，可使用try-catch而不含finally，或仅用try-finally）。
D：catch块和finally块可以同时省略‌ — ‌不正确‌。若同时省略catch和finally块，try块将缺乏配套的异常处理或清理结构，导致编译错误；因此，catch和finally中必须至少保留一个。

综上，描述‌不正确的选项是 D‌。

19. C

A：System.out.println(a.i);‌
i是实例变量（非静态），必须通过实例（如a）访问。此语法正确。
B：a.method1();‌
method1()是实例方法（非静态），必须通过实例（如a）调用。此语法正确。
C：A.method1();‌
method1()是实例方法，不能直接用类名A调用（需通过实例）。此语法错误，导致编译失败。
D：A.method2();‌
method2()是静态方法，可通过类名A直接调用。此语法正确。

综上，错误调用发生在选项 ‌C‌。