Java试题-选择题（6）

Java试题-选择题（6）

题目

1. 下面有关JDK中的包和他们的基本功能，描述错误的是 ？
   A：java.awt：包含构成抽象窗口工具集的多个类，用来构建和管理应用程序的图形用户界面
   B：java.io：包含提供多种输出输入功能的类
   C：java.lang：包含执行与网络有关的类，如URL，SCOKET，SEVERSOCKET
   D：java.util：包含一些实用性的类

2. 下列代码中的错误原因是（） ？
   A非法的表达式 i+=1
   B找不到符号i
   C类不应为public
   D尚未初始化变量i

public class Test
{public static void main(String [] args){int i;i+=1;}
}

3. 以下关于Object类的说法正确的是（） ？
   A：Java中所有的类都直接或间接继承自Object，无论是否明确的指明，无论其是否是抽象类。
   B：Java中的接口(interface)也继承了Object类
   C：利用“==”比较两个对象时，Java调用继承自Object的equals方法，判断是否相等。
   D：如果类的定义中没有重新定义toString()方法，则该类创建的对象无法使用toStrig()方法。

4. 关于抽象类叙述正确的是？ ( )
   A 抽象类不能实现接口
   B 抽象类必须有“abstract class”修饰
   C 抽象类必须包含抽象方法
   D 抽象类也有类的特性，可以被实例化

5. 一个类中，有两个方法名、形参类型、顺序和个数都完全一样，返回值不一样的方法,这种现象叫覆盖 ？
   A正确
   B错误

6. javac的作用是（ ） ？
   A 将源程序编译成字节码
   B 将字节码编译成源程序
   C 解释执行Java字节码
   D 调试Java代码

7. 关于以下代码，说法正确是什么？
   A：4行与9行不能通过编译，因为缺少方法名和返回类型
   B：编译通过，执行结果是：x=5
   C：编译通过，执行结果是：x=3
   D：9行不能通过编译，因为只能有一个静态初始化器

public class Test {static int x=10;static {x+=5;}public static void main(String[] args) //4{System.out.println("x="+x);}static{x/=3;};
}//9

8. 如果一个list初始化为{5，3，1}，执行以下代码后，其结果为（）？
   A：[5, 3, 1, 6]
   B：[4, 3, 1, 6]
   C：[4, 3, 6]
   D：[5, 3, 6]

nums.add(6);
nums.add(0,4);
nums.remove(1);

9. 以下java程序代码，执行后的结果是（）？
   A:0
   B:null
   C:1
   D:2

java.util.HashMap map=new java.util.HashMap();
map.put("name",null);
map.put("name","Jack");
System.out.println(map.size());

10. 下面哪个Set类是按元素排好序的？
    A：LinkedHashSet
    B：TreeSet
    C：HashSet
    D：AbstractSet

11. 关于final说法正确的是 ？
    A：final类的方法肯定不能被同一个包的类访问
    B：final类的方法能否被同一个包的类访问不是由final决定
    C：final方法等同于private方法
    D：final对象本身的引用和值都不能改变

12. 一般用()创建InputStream对象,表示从标准输入中获取数据,用()创建OutputStream对象，表示输出到标准输出设备中 ？
    A：System.in System.out
    B：System.out System.in
    C：System.io.in System.io.out
    D：System.io.out System.io.in

13. 以下代码输出的是 ？
    A：6
    B：10
    C：都不对
    D：16

public class SendValue{public String str="6";public static void main(String[] args) {SendValue sv=new SendValue();sv.change(sv.str);System.out.println(sv.str);}public void change(String str) {str="10";}
}

14. 指出下列程序运行的结果（） ？
    A：good and abc
    B：good and gbc
    C：test ok and abc
    D：test ok and gbc

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';}
}

15. 顺序执行下列程序语句后，则b的值是（） String a=“Hello”; String b=a.substring(0,2); ？
    A：Hello
    B：Hel
    C：He
    D：null

16. 关于继承和实现说法正确的 是 ？ ( )
    A 类可以实现多个接口，接口可以继承（或扩展）多个接口
    B 类可以实现多个接口，接口不能继承（或扩展）多个接口
    C 类和接口都可以实现多个接口
    D 类和接口都不可以实现多个接口

17. 对于同一类中的两个方法 , 在判断它们是不是重载方法时 , 肯定不考虑（ ） ？
    A 参数个数
    B 参数类型
    C 返回值类型
    D 参数顺序

18. 下面哪段程序能够正确的实现了GBK编码字节流到UTF-8编码字节流的转换： byte[] src,dst; ？
    A：dst=String.fromBytes(src，“GBK”).getBytes(“UTF-8”)
    B：dst=new String(src，“GBK”).getBytes(“UTF-8”)
    C：dst=new String(“GBK”，src).getBytes()
    D：dst=String.encode(String.decode(src，“GBK”))，“UTF-8” )

19. 假定str0,…,str4后序代码都是只读引用。Java 7中，以下述代码为基础，在发生过一次FullGC后，上述代码在Heap空间（不包括PermGen）保留的字符数为（）
    A：5
    B：10
    C：15
    D：20

static String str0="0123456789";
static String str1="0123456789";
String str2=str1.substring(5);
String str3=new String(str2);
String str4=new String(str3.toCharArray());
str0=null;

20. ArrayList list = new ArrayList(20);中的list扩充几次 ？
    A：0
    B：1
    C：2
    D：3

答案

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

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

解析

1. C

选项A（java.awt）‌：描述正确，该包包含抽象窗口工具集类，用于构建和管理图形用户界面（GUI。
选项B（java.io）‌：描述正确，该包提供多种输入输出功能类，支持数据流和文件操作。
选项C（java.lang）‌：描述错误，该包主要负责Java语言的基础类（如Object、String），并不包含网络相关类（如URL、Socket）；网络功能实际由java.net包提供。
选项D（java.util）‌：描述正确，该包包含集合、日期等实用工具类。

2. D

局部变量i在方法内部声明后，必须显式初始化才能使用‌。Java要求局部变量在使用前必须赋值，否则编译器会抛出类似“variable might not have been initialized”的错误；成员变量或静态变量有默认值，但局部变量没有。
代码int i;声明了局部变量i，但未赋初值；紧接着i += 1;尝试读取并修改i，此时i未被初始化，导致编译错误。

3.A

A：Java中所有的类都直接或间接继承自Object，无论是否明确的指明，无论其是否是抽象类。‌
正确。Object类是Java继承体系的根类，所有类（包括抽象类）都直接或间接继承自它，即使未显式指明父类，编译器也会默认继承Object。例如，用户自定义类或系统类（如String）都源于Object。

B：Java中的接口(interface)也继承了Object类‌
错误。接口本身不继承Object类；接口定义的方法（如equals或toString）是抽象形式，实际由实现该接口的类通过继承Object来提供具体实现。例如，Comparable或Serializable接口并未继承Object。

C：利用“ == ” 比较两个对象时，Java调用继承自Object的equals方法，判断是否相等。‌
错误。“ == ” 操作符直接比较对象的内存地址（引用是否相同），而equals方法（默认继承自Object）的内容比较行为需显式调用；默认equals方法内部仅使用“ == ”，但“==”本身不触发equals方法。例如，obj1 == obj2不会调用obj1.equals(obj2)。

D：如果类的定义中没有重新定义toString()方法，则该类创建的对象无法使用toString()方法。‌
错误。Object类已提供默认toString()方法，所有类继承该方法，即使未重写，对象仍可调用它（返回类名和哈希码）。例如，未重写toString()时，调用new MyClass().toString()仍有效。

4. B

关于抽象类叙述正确的是选项B：抽象类必须有“abstract class”修饰。

其他选项的分析如下：
A错误：抽象类可以实现接口（例如，Java中抽象类可以实现多个接口）。
C错误：抽象类不一定包含抽象方法（它可能只包含具体方法）。
D错误：抽象类不能被实例化（只能通过子类继承并实例化子类）。

5. B

在Java（以及其他常见的面向对象语言如C#）中，方法覆盖（Override）是指子类重新定义父类中已有的方法，要求方法签名（方法名、参数类型、顺序和个数）必须完全相同，且返回类型需相同或是父类方法返回类型的子类型（协变返回类型）。覆盖的核心是发生在‌继承关系‌中（子类覆盖父类）。
问题描述的现象是：‌在同一个类中‌，有两个方法名、形参类型、顺序和个数完全一样，但返回值不同的方法。这种现象在Java中：
不是覆盖（Override）‌，因为覆盖必须涉及子类和父类的关系。
实际上，‌这种代码在Java中是非法的‌，编译器会报错（例如：method is already defined in class），因为Java不允许在同一个类中存在签名（方法名 + 参数列表）相同但返回类型不同的方法。这违反了方法重载（Overloading）的规则（重载要求参数列表必须不同）。

覆盖（Override）‌：必须发生在子类和父类之间，签名相同（包括返回类型兼容）。
重载（Overloading）‌：在同一个类中，方法名相同但参数列表不同（返回类型可以不同，但不是决定因素）。
本例中，在同一个类中签名相同但返回类型不同的方法，既不满足覆盖的条件（无继承关系），也不满足重载的条件（参数列表相同），而是编译错误。

6. A

正确选项（A）‌：
javac 是 Java 编译器，专门负责将 Java 源程序（.java 文件）编译成字节码文件（.class 文件），供 Java 虚拟机（JVM）执行。这是其核心功能，所有搜索结果均一致确认。

错误选项分析‌：
B（将字节码编译成源程序）‌：
javac 不具备反编译功能；将字节码还原为源程序需使用其他工具（如 javap 或第三方反编译器），而非 javac。
C（解释执行Java字节码）‌：
解释执行字节码是 java 命令的作用（例如 java HelloWorld），而非 javac。
D（调试Java代码）‌：
调试功能由 IDE 或 jdb 等调试工具提供，javac 仅负责编译，不涉及调试过程。

7.B

代码执行逻辑
静态变量初始化顺序‌：Java类加载时，静态变量和静态初始化块按照源代码中的顺序依次执行，且仅执行一次。
static int x = 10;：初始化为10。
static { x += 5; }：执行后x = 10 + 5 = 15。
static { x /= 3; }（9行）：执行后x = 15 / 3 = 5。
main方法输出‌：执行System.out.println(“x=” + x)时，x的值为5。

8. B

初始列表‌
nums = [5, 3, 1]

执行 nums.add(6)‌
add(element) 方法在列表末尾添加元素。
操作后：nums = [5, 3, 1, 6]

执行 nums.add(0, 4)‌
add(index, element) 方法在指定索引位置插入元素。
在索引 0 处插入 4，列表变为：[4, 5, 3, 1, 6]

执行 nums.remove(1)‌
remove(index) 方法删除指定索引位置的元素。
删除索引 1 的元素（当前为 5），列表变为：[4, 3, 1, 6]

9. C

代码解析：
HashMap 的键是唯一的，后插入的键值对会覆盖之前同名的键。
第一次 map.put(“name”, null) 存入键 “name” 和值 null。
第二次 map.put(“name”, “Jack”) 覆盖了之前的 “name” 键，最终 HashMap 中仅有一个键值对。
map.size() 返回的是键值对的数量，因此输出 ‌1‌。

10. B

在 Java 集合框架中，能够按元素的‌自然顺序或自定义顺序‌自动排序的 Set 实现类是 ‌TreeSet‌。具体分析如下：

TreeSet：‌
元素按自然顺序（如字符串按字典序、数字按大小）或通过自定义 Comparator 排序。
底层基于红黑树实现，添加元素时自动排序，保证唯一性和有序性。
是唯一按元素内容排序的 Set 实现类‌。

其他选项分析：‌
LinkedHashSet：‌
仅维护元素的‌插入顺序‌（即添加顺序），不按元素内容排序。
HashSet：‌
完全无序‌，既不保证插入顺序，也不按元素内容排序。
AbstractSet：‌
是抽象类，不能直接实例化，主要用于扩展实现自定义 Set，不代表具体排序行为。

11. B

A：错误‌
final类的方法能否被访问取决于其访问修饰符（如public、protected），而非final关键字；同一个包的类可能通过public或protected修饰符访问方法。
B：正确‌
final仅限制类被继承或方法被重写，方法的访问权限由访问修饰符（如public、default）独立控制，因此final不决定同一个包的类能否访问方法。
C：错误‌
final方法可被其他类访问（需符合修饰符规则），而private方法仅限本类访问，二者不等同。
D：错误‌
final修饰对象时，引用不可变（如不能指向新对象），但对象内部的值可通过方法修改（如setter更新字段）。

12. A

在Java中，标准输入输出流的创建方式如下：
标准输入（InputStream）‌：通过 System.in 获取，表示从控制台（键盘）读取数据。
标准输出（OutputStream）‌：通过 System.out 获取（实际为 PrintStream，继承自 OutputStream），表示输出到控制台（屏幕）。

13. A

这段代码的输出结果是 ‌6‌，对应选项 ‌A‌。以下是详细解析：

初始状态‌
类 SendValue 中定义了一个成员变量 str，初始值为 “6”。
在 main 方法中，创建了 SendValue 的实例 sv，此时 sv.str 的值为 “6”。

方法调用 change(sv.str)‌
调用 sv.change(sv.str) 时，‌Java 是值传递‌，即传递的是 str 的副本（引用地址的副本），而非原始引用。
在 change 方法内部，str=“10” 修改的是局部变量 str 的指向，不影响外部的 sv.str。

输出结果‌
方法调用后，sv.str 仍为初始值 “6”，因此 System.out.println(sv.str) 输出 6。
关键点
Java 是值传递‌：方法参数传递的是变量的副本（对于对象类型，传递的是引用地址的副本）。
字符串不可变性‌：String 是不可变类，str=“10” 实际是让局部变量 str 指向新对象，不影响原引用。

14. B

String 类型参数（值传递引用副本）‌
成员变量 ex.str 初始值为 “good”。
change 方法中的 str 是参数的局部副本，修改为 “test ok” ‌不影响‌原成员变量 ex.str。
因此 ex.str 输出仍为 “good”。

char[] 类型参数（引用传递）‌
成员变量 ex.ch 初始为 {‘a’,‘b’,‘c’}。
change 方法直接通过引用修改数组元素：ch[0] = ‘g’，‌直接影响原数组‌。
因此 ex.ch 变为 {‘g’,‘b’,‘c’}，输出 “gbc”。
最终输出：
text
Copy Code
good and gbc

15. C

String a = “Hello”;
创建字符串 a，内容为 “Hello”。
String b = a.substring(0, 2);
substring(0, 2) 方法从索引 0（包含）开始，到索引 2（不包含）结束。
因此截取的子串是索引 0 和 1 的字符，即 ‌"He"‌。

16. A

类可以实现多个接口‌
在Java中，一个类可以通过implements关键字实现多个接口，从而获得多个接口定义的方法签名，并在类中提供具体实现。

接口可以继承（或扩展）多个接口‌
接口使用extends关键字继承其他接口，且支持多重继承（即一个接口可同时继承多个接口），继承后会包含所有父接口的方法。

其他选项错误分析：
B（类可以实现多个接口，接口不能继承多个接口）‌：错误，接口支持多重继承，可通过extends扩展多个接口。
C（类和接口都可以实现多个接口）‌：错误，类可通过implements实现接口，但接口本身不能“实现”其他接口（只能通过extends继承接口）。
D（类和接口都不可以实现多个接口）‌：错误，类可实现多个接口，接口也可继承多个接口。

17. C

在Java中，方法重载（Overload）是指在同一个类中定义多个同名方法，其核心特征是‌参数列表必须不同‌，而返回值类型、访问修饰符或异常声明等均不影响重载的判断。具体分析如下：

重载的关键考虑因素‌（必须满足至少一项）：
参数个数不同‌（例如：void test(int a) 与 void test(int a, int b)）。
参数类型不同‌（例如：void test(int a) 与 void test(String a)）。
参数顺序不同‌（例如：void test(int a, String b) 与 void test(String b, int a)）。
肯定不考虑的因素‌：
返回值类型‌：即使两个方法的返回值不同（如 int method() 与 void method()），若参数列表相同，则不构成重载且会导致编译错误。

18. B

题目要求从 ‌GBK编码的字节流（byte[] src）转换为UTF-8编码的字节流（byte[] dst）‌，关键点在于：
解码（GBK → String）‌：将GBK编码的字节数组转换为Java字符串（Unicode）。
编码（String → UTF-8）‌：将字符串重新编码为UTF-8字节数组。

选项解析
A：dst=String.fromBytes(src,“GBK”).getBytes(“UTF-8”)‌
错误。String类没有fromBytes方法，语法错误。

B：dst=new String(src,“GBK”).getBytes(“UTF-8”)‌
正确。
new String(src, “GBK”)：将GBK字节数组解码为字符串。
getBytes(“UTF-8”)：将字符串编码为UTF-8字节数组。

C：dst=new String(“GBK”,src).getBytes()‌
错误。String构造方法参数顺序错误，且未指定目标编码（UTF-8）。

D：dst=String.encode(String.decode(src,“GBK”),“UTF-8”)‌
错误。String类没有encode/decode方法，语法错误。

关键点
正确流程‌：GBK字节数组 → String → UTF-8字节数组。
必须显式指定编码‌，否则会使用平台默认编码（可能导致乱码）。

19. C

代码分析：

str0 和 str1‌
均为静态字符串常量 “0123456789”，存储在 ‌常量池（PermGen）‌，不占用Heap空间。
str0=null 仅解除引用，不影响常量池。

str2‌
str1.substring(5) 生成新字符串 “56789”（5字符），存储在Heap。

str3 和 str4‌
new String(str2) 和 new String(str3.toCharArray()) 分别创建新的Heap对象，各包含5字符。

FullGC后的Heap占用：
str2、str3、str4 各占5字符，总计 ‌15字符‌（PermGen中的常量池内容不计入）。

20. A

在 Java 中，ArrayList list = new ArrayList(20); 创建了一个初始容量为 20 的 ArrayList。这里的 20 是构造函数的参数，表示直接指定了底层数组的大小为 20。

扩容机制说明‌：ArrayList 的扩容发生在添加元素时，当元素数量（size）超过当前容量时，才会触发扩容（通常扩容为当前容量的 1.5 倍）。然而，‌此语句仅创建了 ArrayList 实例，并没有执行任何添加元素的操作‌。因此，没有触发扩容的条件。
关键点‌：指定初始容量的构造函数 ArrayList(int initialCapacity) 会直接分配一个大小为 initialCapacity 的数组。这是一个初始化操作，而非扩容。扩容仅在后续添加元素导致容量不足时发生。

因此，在这个语句执行后，list 的扩容次数为 ‌0‌。