java基础选择题--7

erqwert

于 2024-06-03 14:51:15 发布

阅读量969

点赞数 7

分类专栏： Java基础选择题文章标签：开发语言 java

本文链接：https://blog.csdn.net/erqwert/article/details/139402824

版权

Java基础选择题专栏收录该内容

18 篇文章 0 订阅

订阅专栏

一、单选题

1. 下面属于Java关键字的是（）。

A、NULL B、IF C、DO D、while

在Java中，关键字是那些被Java语言保留并具有特殊含义的标识符。它们不能用作变量名、方法名、类名或其他标识符的名称。

A、NULL - 这并不是Java的关键字。在Java中，我们使用null来表示一个引用类型的变量没有引用任何对象。注意null是小写的。

B、IF - 这实际上是Java的关键字，用于条件语句。但是，由于Java是大小写敏感的，所以IF（大写）不是关键字。

C、DO - 这也是Java的关键字，用于do-while循环。但同样，DO（大写）不是关键字。

D、while - 这是Java的关键字，用于while循环。

所以，在提供的选项中，唯一完全正确的关键字是（忽略大小写差异）"while"。但是，如果我们要选择一个与给出的选项完全匹配的答案（包括大小写），那么没有一个是完全匹配的，因为Java的关键字都是小写的。但如果我们忽略大小写，那么最接近的正确答案是D、while。

因此，正确答案是D。

2. 下例正确的是（）。

A、float 3.14; B、byte i=225; C、log k=33.5; D、int p[][];

首先，我们来分析每个选项的正确性：

A、正确的写法是：float pi = 3.14f; （注意这里的f或F是必需的，以表明这是一个float类型的字面量，而不是double）。

B、byte i=225; - 这是不正确的。在Java中，byte类型的范围是-128到127。225超出了这个范围，所以不能被声明为byte类型。

C、log k=33.5; - 这是不正确的。首先，Java中没有名为log的基本数据类型。你可能想要的是long，但是即使如此，33.5是一个浮点数，不能被直接赋值给long类型的变量。如果你想表示一个长整型，你需要一个整数，而不是浮点数。

D、int p[][]; - 这是正确的。这是Java中声明二维整数数组的简写方式。它等价于int[][] p;。这里只是声明了数组，没有初始化或分配空间。

所以，正确答案是D。

3. MAX_LENGTH是int型public成员变量, 变量值保持为常量100，用简短语句定义这个变量。( )

A、public int MAX_LENGTH=100 B、final int MAX_LENGTH=100

C、final public int MAX_LENGTH=100 D、public final int MAX_LENGTH=100

4. 下列叙述中，正确的是（）。

A、Java语言的标识符是区分大小写的 B、原文件名与public类名可以不同

C、原文件名其扩展名为.jar D、原文件中public类的数目不限

A、Java语言的标识符是区分大小写的 - 这是正确的。在Java中，标识符（如变量名、类名、方法名等）是区分大小写的。例如，myVariable 和 myvariable 是两个不同的标识符。

B、原文件名与public类名可以不同 - 这是不正确的。在Java中，如果一个源文件（.java 文件）包含了一个 public 类，那么这个源文件的名称必须与这个 public 类的名称完全相同（包括大小写）。

C、原文件名其扩展名为.jar - 这是不正确的。.jar 文件是Java的归档文件，通常用于打包多个 .class 文件和相关的资源文件。而源文件（包含Java代码的文件）的扩展名应该是 .java。

D、原文件中public类的数目不限 - 这是不正确的。在Java中，一个源文件中只能有一个 public 类，但可以有任意数量的非 public 类。

5. 下列语句中，属于多分支语句的是（）。

A、if语句 B、switch语句 C、do while语句 D、for语句

6. 以下选项中，合法的赋值语句是( )。

A、a == 1; B、++i; C、a = a+1 = 5; D、y = int(i);

A、a == 1; - 这不是一个赋值语句，而是一个比较语句。它会检查变量 a 是否等于 1，但结果（一个布尔值）不会被存储在任何地方。

B、++i; - 这是一个合法的赋值语句（尽管它通常被称为“递增语句”）。它将变量 i 的值增加 1。

C、a = a+1 = 5; - 这是不合法的。在Java（以及许多其他编程语言）中，你不能连续进行赋值。此外，这个语句在逻辑上也是没有意义的。

D、y = int(i); - 这在Java中是不合法的。如果你想将 i 的值转换为 int 类型（如果它本来就不是 int 类型），你应该使用类型转换，但语法是 (int)i 而不是 int(i)。此外，如果 i 已经是一个 int，那么类型转换是不必要的。

7. 下列属于合法的Java标识符是（）

A、_cat B、5books C、+static D、-3.14159

8. 在Java中，表示换行符的转义字符是（）

A、\n B、\f C、’n’ D、\dd

9. 能够支持javadoc命令的注释语句是（）

A、/**…// B、/*…*/ C、// D、/**…*/

10. 下列语句序列执行后，x 的值是( )。

int a=3, b=4, x=5;

if( ++a<b ) x=x+1;

A、5 B、3 C、4 D、6

if( ++a<b ) x=x+1; 这行代码包含了一个前置递增操作 ++a 和一个条件判断 if。

前置递增 ++a 会先将 a 的值增加 1，然后返回增加后的值。所以在这里，a 的值从 3 变为 4，并且 ++a 的结果是 4。
接着，判断 4 < 4 是否为真。显然，这个条件是不成立的。
因为条件不成立，所以 if 语句块内的代码 x=x+1; 不会被执行。
由于 x=x+1; 没有被执行，所以 x 的值仍然是 5。

11. Java语言使用的字符码集是（）

A、ASCII B、BCD C、DCB D、Unicode

12. 指出正确的表达式（）

A、byte = 128;//超范围 B、Boolean = null;

C、long l = 0xfffL; D、double = 0.9239d; //应该定义变量

A、byte = 128; - 这是不正确的。在Java中，byte 是一个8位的有符号二进制整数，其取值范围是-128到127。所以你不能将128赋值给一个byte类型的变量。

B、Boolean = null; - 这是不正确的。Boolean 是Java的一个封装类，用于表示基本数据类型 boolean 的值。你不能将 null 赋值给 Boolean 类型本身，但你可以将 null 赋值给 Boolean 类型的变量。例如：Boolean b = null; 是正确的。

C、long l = 0xfffL; - 这是正确的。这里，0xfffL 是一个长整型字面量，前面的 0x 表示这是一个十六进制数，后面的 L（或 l，但通常建议使用大写以避免与数字1混淆）表示这是一个长整型（long）。这个值在 long 类型的取值范围内。

D、double = 0.9239d; - 这是不正确的。你不能将值直接赋值给数据类型本身（如 double）。你应该将值赋给一个 double 类型的变量。例如：double d = 0.9239d; 是正确的。

因此，正确的表达式是 C。

13. 下列说法不正确的是( )

A、IOException必须被捕获或抛出 B、java语言会自动初始化变量的值

C、java语言不允许同时继承一个类并实现一个接口

D、java语言会自动回收内存中的垃圾

14. 以下选项中循环结构合法的是（）。？

A、 while (int i<7){

i++;

System.out.println(“i is “+i);

}

B、 int j=3;

while(j){

System.out.println(“ j is “+j);

}

C、 int j=0;

for(int k=0; j + k !=10; j++,k++){

System.out.println(“ j is “+ j + “k is”+ k);

}

D、 int j=0;

do{

System.out.println( “j is “+j++);

if (j = = 3) {

continue loop;

}

}while (j<10);

15. 下列语句序列执行后，k 的值是( )。

int i=6, j=8, k=10, n=5, m=7;

if( i<j || m<n ) k++; else k--;

A、9 B、10 C、11 D、12

16. 以下字符常量中不合法的是（）。？？

A、'|' B、'\'' C、"\n" D、'我'

A、'|' - 这是合法的。它表示垂直线字符。

B、'\'' - 这也是合法的。这里使用了转义字符 \' 来表示单引号字符自身。

C、"\n" - 这实际上不是一个字符常量，而是一个字符串常量。因为它使用了双引号 " 而不是单引号 '。但是，如果我们只考虑单引号内的部分（即 '\n'），那么它就是一个合法的字符常量，表示换行符。

D、'我' - 这是不合法的。在大多数编程语言中（包括Java），字符常量不能包含多字节字符（除非你的源代码文件是用UTF-16或UTF-32等编码编写的，并且你的编译器/解释器支持这种编码）。'我' 包含了多个字节（在UTF-8编码中），所以不能用一个字符常量来表示。

17. 若有循环：

int x=5，y=20;

do{

y-=x;

x++;

}while(++x<--y)；则循环体将被执行（）。

A、0次 B、1次 C、2次 D、3次

为了解决这个问题，我们需要逐步分析这个 do-while 循环。

首先，给定初始值：

复制
int x = 5;
int y = 20;

然后，我们进入 do 循环体，执行以下操作：

y -= x; // y 变为 20 - 5 = 15
x++; // x 变为 6

现在，我们检查 do-while 循环的条件部分 while(++x<--y)：

首先，--y 执行，但这里有一个重要的点，--y 是后置递减，这意味着它会先返回 y 的当前值（15），然后再将 y 减1。因此，条件判断时 y 的值是15，但执行完这个表达式后，y 的值变为14。
接着，++x 执行，此时 x 的值是6，前置递增后变为7。

现在条件变为 7 < 15，这是 true，所以循环体会再次执行。

第二次进入循环体：

y -= x; // y 变为 14 - 7 = 7
x++; // x 变为 8

再次检查循环条件：

--y 执行，返回7但随后 y 变为6。
++x 执行，x 变为9。

条件变为 9 < 7，这是 false，所以循环结束。

综上，循环体被执行了两次。

答案是 C、2次。

18. Java编程默认引用的包为（）。

A、java.sys包 B、java.lang包 C、java.new包 D、以上都不是

19. 编译Java Application源程序文件将产生相应的字节码文件，这些字节码文件的扩展名为（）。

A、java B、class C、html D、exe

20. 下列语句序列执行后，j 的值是( )。

int j=0;

for( int i=3; i>0; i-- ) j+=i;

A、3 B、4 C、5 D、6

21. 下列说法正确的是（）。

A、当运行Javac命令对一个Java源程序进行编译时，必须写出该源文件的完整的文件名，包括扩展名.java

B、当运行Javac命令对一个Java源程序进行编译时，不必写出该源文件的扩展名.java

C、当用Java命令解析运行一个class时，必须写出该class文件的扩展名.class

D、无论是运行Javac还是Java命令，后面的源文件都必须给出文件扩展名

对于javac命令，你需要提供.java扩展名，但对于java命令，你不需要提供.class扩展名。

22. 能从循环语句的循环体中跳出的语句是（）。

A、for 语句 B、break 语句 C、while 语句 D、continue语句

23. 下列语句序列执行后，k 的值是（）。

int i=6,j=8,k=10,m=7;

if(i>j||m<k--)

k++;

else

k--;

A、12 B、11 C、10 D、9

24. 编译和解释执行一个Java应用程序应分别采用的命令是（）。

A、java和javac B、javac和java

C、javap和java D、javac和jdb

25. 下列关于Java Application与Applet的说法中，正确的是（）

A、都包含main( )方法 B、都通过“appletviewer”命令执行

C、都通过“javac”命令编译 D、都嵌入在HTML文件中

A、都包含main( )方法

这是不正确的。Java Application必定含有一个而且只有一个main方法，这是其执行的入口点。而Applet则不包含main方法，它有一个由java.applet.Applet派生的类，用于在支持Java的浏览器中运行。

B、都通过“appletviewer”命令执行

这是不正确的。Applet可以通过appletviewer命令或者嵌入到HTML文件中在浏览器中执行。而Java Application则是通过java命令直接执行的，不需要appletviewer。

C、都通过“javac”命令编译

这是正确的。无论是Java Application还是Applet，它们的源代码（.java文件）都是通过javac命令进行编译的，生成对应的字节码文件（.class文件）。

D、都嵌入在HTML文件中

这是不正确的。只有Applet需要嵌入到HTML文件中才能在浏览器中运行。Java Application是一个完整的程序，可以独立运行，不需要嵌入到HTML文件中。

。

26. 在下列说法中，选出正确的一项是（）。

A、Java语言是以方法为程序的基本单位的

B、Java语言是不区分大小写的

C、多行注释语句必须以//开始

D、Java运行时系统自动释放内存

27. Java语言是以哪一种语言为基础的?（）

A、Basic B、Smalhalk C、C D、C++

28. 下列语句中，正确的给出初始值为222.111的单精度浮点数f的定义的一个是（）。

A、float f=222.111f B、float f=222．111

C、float f=222.111d D、float f='222．111'

29. 设有类型定义short i=32；long j=64；下面赋值语句中不正确的一个是（）。

A、j=i B、i=j //大转小需要强制类型转换

C、i=(short)j D、j=(long)i；

A、j=i;
这个赋值语句是合法的。因为 i 是 short 类型，其值会自动提升为 int 类型（这是Java中的隐式类型转换或称为自动类型转换）然后再赋值给 long 类型的 j。

B、i=j;
这个赋值语句是不合法的。因为 j 是 long 类型，它的值不能直接赋值给 short 类型的 i，这会导致数据丢失（因为 long 类型的范围大于 short 类型）。为了完成这个赋值，我们需要进行显式类型转换（强制类型转换），但这里并没有这样做。

C、i=(short)j;
这个赋值语句是合法的，但可能会导致数据丢失或溢出。因为这里使用了显式类型转换（强制类型转换）(short) 将 long 类型的 j 转换为 short 类型的 i。但转换时会截断 long 类型的高位字节，只保留低位字节。

D、j=(long)i;
这个赋值语句是合法的。虽然 i 是 short 类型，但在赋值给 long 类型的 j 之前，它会被自动提升为 int 类型。但由于 int 类型的值可以无损地转换为 long 类型（因为 long 类型的范围更大），所以这里不需要显式类型转换，但即使加上 (long) 也是合法的。

30. 现有一个int类型的整数和一个double类型的浮点数，当它们之间做了加法运算之后，得到的结果类型应该是( )。

A、int类型 B、double类型 C、float类型 D、long类型

当一个 int 类型的整数和一个 double 类型的浮点数进行加法运算时，由于 double 类型具有更高的精度和更大的表示范围，所以 int 类型的值会被自动转换为 double 类型，然后两个 double 类型的值进行加法运算。因此，得到的结果类型应该是 double 类型。

31. 在Java中，用package语句说明一个包时，该包的层次结构必须是（）。

A、与文件的结构相同 B、与文件目录的层次相同

C、与文件类型相同 D、与文件大小相同

32. 在Java中，所有类的根类是（）

A、java.lang.Object B、java.lang.Class

C、java.applet.Applet D、java.awt.Frame

33. 要使类中的某个成员变量只能被它自身和它的子类访问到，该变量可用什么修饰符修饰？（）。

A、protected B、public C、private D、应不加修饰符

34. 以下关于构造方法的描述错误的是（）。

A、构造方法的返回类型只能是void型。

B、构造方法是类的一种特殊方法，它的方法名必须与类名相同。

C、构造方法的主要作用是完成对类的对象的初始化工作。

D、一般在创建新对象时，系统会自动调用构造方法。

35. 在使用interface声明一个接口时，只可以使用（）修饰符修饰该接口。

A、public B、protected C、private protected D、private

36. 以下代码段将创建（）个对象。

String s1="bc";

String s2="bc";

A、0 B、1 C、2 D、3

37. 设 x,y 均为已定义的类名，下列声明对象x1的语句中正确的是（）。

A、public x x1 = new y( ); B、x x1 = x( );

C、x x1 = new x( ); D、int x x1;

38. Java语言的类间的继承关系是（）。

A、多重的 B、单重的 C、线程的 D、不能继承

39. 下面是有关子类继承父类构造方法的描述，其中正确的是（）。

A、创建子类的对象时，先调用子类自己的构造方法，然后调用父类的构造方法。

B、子类无条件地继承父类所有构造方法。

C、子类必须通过super关键字调用父类的构造方法。

D、子类无法继承父类的构造方法。

40. 下面说法正确的是（）。

A、final可修饰类、属性、方法。 B、abstract可修饰类、属性、方法。

C、定义抽象方法需有方法的返回类型、名称、参数列表和方法体。

D、用final修饰的变量，在程序中可对这个变量的值进行更改。

41. 对象使用时，下面描述错误的是（）。

A、通过“.”运算符调用成员变量和方法

B、通过成员变量的访问权限设定限制自身对这些变量方法的调用

C、将一个对象申明为类的成员时，必须在使用前为其分配内存

D、在方法中使用对象作为参数时，采用引用调用

A、通过“.”运算符调用成员变量和方法

这是正确的。在Java等面向对象编程语言中，我们使用.运算符（点运算符）来访问对象的成员变量和调用其方法。

B、通过成员变量的访问权限设定限制自身对这些变量方法的调用

这是错误的。成员变量的访问权限（如public、protected、private等）是用来限制其他类或对象对它们的访问，而不是限制对象自身对其成员变量和方法的调用。对象总是可以访问其自己的所有成员变量和方法。

C、将一个对象申明为类的成员时，必须在使用前为其分配内存

这通常是正确的，但描述可能有些模糊。当一个对象作为类的成员时，它通常会在创建该类的实例时（通过构造函数或其他初始化方法）被分配内存（除非它是静态的，静态成员在类加载时分配内存）。但是，说“必须在使用前为其分配内存”可能意味着在调用任何方法或访问任何成员变量之前，这不一定是准确的，因为某些成员变量可能在构造过程中被初始化，而其他成员变量可能在之后的方法中被初始化。但核心意思是，对象成员确实需要在使用前被创建和初始化。

D、在方法中使用对象作为参数时，采用引用调用

这是正确的。在Java等语言中，对象是通过引用来传递的，这意味着当我们将一个对象作为参数传递给方法时，我们实际上传递的是该对象的引用（地址），而不是对象的实际内容。

42. 下列类头定义中，错误的是（）。

A、class x

{ .... }

B、public x extends y

{ .... }

//B、public x extends y { .... }
这个定义是错误的。因为它使用了public修饰符来定义一个类，但没有给出类名后面的class关键字。正确的写法应该是public class x extends y { .... }。

C、public class x extends y

{ .... }

D、class x extends y implements y1

{ .... }

43. 内部类是在一个类内嵌套定义的类。其特点描述错误的是（）。？？？

A、只能在定义它的类或程序段中或表达式内匿名使用，外部使用时必须给出类的全名

B、可以使用它所在类的静态成员变量或实例成员变量，但不可以使用所在类中的局部变量

C、可以作为其它类的成员，而且可访问它所在类的成员

D、除static内部类外，不能在类内声明static成员

44. Java中访问限定符不包括（）。

A、public B、private C、default D、final

45. 为AB类的一个无形式参数无返回值的方法method书写方法头，使得使用类名AB作为前缀就可以调用它，该方法头的形式为（）。

A、static void method( ) B、public void method( )

C、final void method( ) D、abstract void method( )

要使一个方法能够使用类名作为前缀来调用，即静态地调用，该方法必须是静态的（static）。让我们逐一分析选项：

A、static void method( ) - 这是正确的。因为static修饰符允许该方法在没有创建类的实例的情况下被调用，即可以使用类名直接调用。

46. 如果在子类中需要调用父类的带参数构造方法，可以通过super()调用所需的父类构造方法，且该语句必须作为子类构造方法中的（）。

A、第一条语句 B、第二条语句 C、第三条语句 D、最后一条语句

47. 下列不属于面向对象特性的选项是（）。

A、封装性 B、继承性 C、多态性 D、鲁棒性

48. 下列关于类、包和源文件的说法中，错误的一项是（）。

A、一个文件可以属于一个包 B、一个包可包含多个文件

C、一个类可以属于一个包 D、一个包只能含有一个类

一个包可以包含多个Java源文件，每个文件可以定义多个类或接口。因此，一个包可以包含多个类。

49. 以下关于面向对象概念的描述中，不正确的一项是（）。

A、在现实生活中，对象是指客观世界的实体

B、程序中的对象就是现实生活中的对象

C、在程序对象是通过一种抽象数据类型来描述的，这种抽象数据类型称为类(class)

D、在程序中，对象是一组变量和相关方法的集合

50. 下列关于作用域的说法中，正确的一个是（）。

A、不同方法中声明的不同变量，可以互相访问

B、在不同方法中可以声明相同数据类型的同名局部变量

C、在同一个类中可以声明相同数据类型的同名类变量

D、在同一个程序块中可以声明相同数据类型的同名变量

51. 以下哪个表达式是不合法的（）

A、String x=”Hello”; int y=9; x+=y;

B、String x=”Hello”; int y=9; if(x==y){ }

C、String x=”Hello”; int y=9; x=x+y;

D、String x=null; int y=(x!=null)&&(x.length()>0) ? x.length : 0

分析每个表达式：

A、String x="Hello"; int y=9; x+=y;
这个表达式是合法的。在Java中，String 类型可以与 int 类型进行连接操作，x+=y; 会将 y 的值转换为字符串并与 x 连接，所以 x 的值会变成 "Hello9"。

B、String x="Hello"; int y=9; if(x==y){ }
这个表达式是不合法的。在Java中，你不能使用 == 运算符来比较 String 和 int 类型的值，因为它们的类型不匹配。如果你想要比较 String 对象的值（而不是引用）和 int 类型的值，你需要先将 int 转换为 String，然后使用 equals() 方法（但在这个上下文中，比较本身没有意义）。

C、String x="Hello"; int y=9; x=x+y;
这个表达式是合法的。和A选项一样，x+y 会将 y 的值转换为字符串并与 x 连接，所以 x 的值会变成 "Hello9"。

D、String x=null; int y=(x!=null)&&(x.length()>0) ? x.length : 0;
这个表达式在某些情况下是合法的，但在这里它是非法的。因为 x 被初始化为 null，在检查 x.length() 之前应该先检查 x 是否为 null。如果 x 是 null，那么 x.length() 会抛出 NullPointerException。为了使其合法，你应该将条件表达式修改为 (x!=null) ? (x.length()>0 ? x.length() : 0) : 0;。

但是，根据问题的直接要求（找出“不合法”的表达式），B选项是最直接的不合法表达式，因为它试图比较一个 String 和一个 int。

所以答案是 B。

52. 有语句String s = ”hello world”;以下操作哪个是不合法的？（）

A、s>>>=1;

//A、s>>>=1; - 这是不合法的。s 是一个 String 类型的变量，而 >>>= 是无符号右移赋值运算符，它仅适用于整数类型（如 int, long 等），不适用于 String 类型。

B、int i = s.length();

C、String ts = s.trim(); D、String t = s+”!”;

53. 创建字符串s：String s = new String（“hello”）；以下哪条语句将改变s（）。

A、s.append(“aaa”); B、s.concat(s);

C、s.substring(3) D、以上语句都不会

54. 若数组a定义为int[][] a = new int[3][4]，则a是（）

A、一维数组 B、二维数组 C、三维数组 D、四维数组

55. 在一个应用程序中有如下定义：int a[]={1,2,3,4,5,6,7,8,9,10};，为了打印输出数组a的最后一个元素，下面正确的代码是（）。

A、System.out.println(a[10]); B、System.out.println(a[9]);

C、System.out.println(a[a.length]); D、System.out.println(a(8));

56. 执行完以下代码int [ ] x = new int[25]；后，以下哪项说明是正确的（）。

A、x[24]为0 B、x[24]未定义 C、x[25]为0 D、x[0]为空

57. 设有定义语句int a[]={66,88,99}; 则以下对此语句的叙述错误的是（）。

A、定义了一个名为a的一维数组 B、a数组有3个元素

C、a数组的下标为1～3 D、数组中的每个元素是整型

58. 为了定义三个整型数组a1、a2、a3,下面声明正确的语句是（B ）。

59. 给出如下声明:

String s1=new String(“Hello”);

String s2=new String(“there”);

String s3=new String(“Hello”);

下列选项中（）是合法的。

A、s3=s1+s2 B、s3=s1-s2 C、s3=s1&s2 D、s3=s1&&s2

60. 现有一整型数组a[4]，它的所有数组元素是( )

A、a0, a1, a2, a3 B、a[1], a[2], a[2], a[4]

C、a[0], a[1], a[2], a[3] D、a[0], a[1], a[2], a[3], a[4]

61. 有程序片段如下，以下哪个表示式的结果为true？（）

Float s=new Float(0.1f);

Float t=new Float(0.1f);

Double u=new Double(0.1);

A、s==t、//==比较基本数据类型的时候，比较的是值

B、s.equals(t) C、u.equals(s) D、t.equals(u)

62. paint()方法使用哪种类型的参数? （）

A、Graphics B、Graphics2D C、String D、Color

//paint() 方法在 Java 的 Swing 图形用户界面（GUI）编程中，特别是当用于自定义组件（如 JPanel）时，通常使用 Graphics 类型的参数

63. 为了区分重载多态中同名的不同方法，要求（）。

A、采用不同的形式参数列表 B、返回值类型不同

C、调用时用类名或对象名做前缀 D、参数名不同

64. 哪个关键字可以抛出异常？（）

A、transient B、finally C、throw D、static

65. main()方法的返回类型是：（）。

A、int B、void C、boolean D、static

66. 下面哪些选项是正确的main方法说明？（）

A、public main(String args[]) B、public static void main(String args[])

C、private static void main(String args[]) D、void main()

67. 设有下面两个赋值语句：

a = Double.parseDouble(“1.2”);

b = Double.valueOf(“1.2”);

//Double.parseDouble("1.2") 方法是将字符串转换为double基本数据类型的值。
Double.valueOf("1.2") 方法是将字符串转换为Double包装类的对象。

下述说法正确的是（）。

A、a是double类型变量，b是Double类对象。

B、a是Double类对象，b是double类型变量。

C、a和b都是Double类对象并且值相等。

D、a和b都是double变量并且值相等。

68. 为了使paint(Graphics)方法执行，调用下列方法中的（）是最适当的。

A、piant() B、repaint() C、paint(Graphics) D、update(Graphics)

//为了使 paint(Graphics) 方法执行，最适当的方法是调用组件的 repaint() 方法。这个方法会标记组件需要重绘，然后在下一个AWT事件调度循环中，系统会调用该组件的 paint(Graphics) 方法来执行实际的绘制操作。

69. 数Float.MAX_VALUE是由哪个包装类提供的?（）

A、java.1ang.Integer B、java.1ang.Long

C、java.1ang.Float D、java.1ang.Double

70. 下面叙述正确的是（）。

A、栈不能进行插入元素的操作，而队列可以。

B、栈和队列都不能在中间位置进行插入操作。

//是正确的。栈只允许在栈顶进行插入和删除操作，队列只允许在队尾进行插入和在队头进行删除操作。它们都不支持在中间位置进行插入操作（除非先将中间及之后的所有元素逐个移动）。

C、链表不能进行插入操作。

D、数组不能进行插入操作。

71. 下列方法中可以用来创建一个新线程的是（）

A、实现java.lang.Runnable接口并重写start( )方法

B、实现java.lang.Runnable接口并重写run( )方法

C、实现java.lang.Thread类并重写run( )方法

D、实现java.lang.Thread类并实现start( )方法

72. 下列关于线程优先级的说法中，正确的是（）

A、线程的优先级是不改变的

B、线程的优先级是在创建线程时设置的

C、在创建线程后的任何时候都可以设置

D、B和C

73. 线程生命周期中正确的状态是（）

A、新建状态、运行状态和终止状态

B、新建状态、运行状态、阻塞状态和终止状态

C、新建状态、可运行状态、运行状态、阻塞状态和终止状态

D、新建状态、可运行状态、运行状态、恢复状态和终止状态

74. Thread类中能运行线程体的方法是（）

A、start() B、resume() C、init() D、run()

75. 下列哪个方法可用于创建一个可运行的类( )。

A、public class X implements Runable{ public void run(){......} }

B、public class X implements Thread{ public void run(){......} }

C、public class X implements Thread{ public int run(){......} }

D、public class X implements Runable{ protected void run(){......} }

76. 下面属于Java线程同步方法的方法有（）。

A、joiny() B、run() C、wait() D、destroy()

77. 下列方法中，可能使一个线程停止执行的是（）。

A、wait() B、notify() C、synchronizized() D、notifyAll()

78. 下列方法中，用于调度线程使其运行的是（）。

A、init() B、start() C、resume() D、sleep()

79. 下列方法中，不能使线程停止的是（）。

A、sleep() B、stop() C、wait() D、notify()

80. 下列哪一个包给出了Runnable接口的定义?（）

A、iava.uti1 B、java.io C、java.1ang D、java.sql

类JPanel默认的布局管理器是C、FlowLayout。

在Java的Swing库中，JPanel是一个轻量级的容器，用于组合和组织窗体上的控件。默认情况下，JPanel使用FlowLayout作为其布局管理器。FlowLayout类对放置在容器中的控件按行进行布局（从左到右逐行排列）。不过，与JPanel一样，你也可以通过调用setLayout()方法或指定一个布局管理器来轻松更改其布局管理器。

其他提到的布局管理器，如GridLayout、BorderLayout和CardLayout，虽然都是Swing支持的布局管理器，但它们并不是JPanel的默认布局管理器。

GridLayout：将容器划分为等大的网格，并将组件按网格顺序添加。
BorderLayout：将容器划分为五个区域（北、南、东、西、中），并允许将组件添加到这些区域中。
CardLayout：帮助用户通过一组卡片来管理多个组件，每次只显示一个组件。

81. 类JPanel默认的布局管理器是（）。

A、GridLayout B、BorderLayout

C、FlowLayout D、CardLayout

82. 下列不属于Swing中组件的是（）。

A、JPanel B、JTable C、Menu D、JFrame

JPanel 是一个容器，用于容纳和组织其他Swing组件。
JTable 是一个显示和编辑表格数据的组件。
JFrame 是一个顶级容器，用于创建窗口。

83. 关于以下代码所画图形的说明，正确的是（）

g.setColor(Color.black);

g.drawLine(10,10,10,50);

g.setColor(Color.red);

g.drawRect(100,100,150,150);

A、一条40像素长的垂直红线，一个边长为150像素的红色四方形

B、一条40像素长的垂直黑线，一个边长为150像素的红色四方形

C、一条50像素长的垂直黑线，一个边长为150像素的红色四方形

D、一条50像素长的垂直红线，一个边长为150像素的红色四方形

//g.setColor(Color.black); 设置绘图颜色为黑色。
g.drawLine(10,10,10,50); 画一条从点(10,10)到点(10,50)的线。这条线的x坐标相同，因此是一条垂直线，长度为50-10=40像素。
g.setColor(Color.red); 设置绘图颜色为红色。
g.drawRect(100,100,150,150); 画一个矩形，其左上角坐标为(100,100)，宽度为150像素，高度为150像素。

84. 容器被重新设置大小后，哪种布局管理器的容器中的组件大小不随容器大小的变化而改变？（）

A、CardLayout B、FlowLayout C、BorderLayout D、GridLayout

85. 以下哪项可能包含菜单条（）。

A、JPanel B、JFrame C、JApplet D、JDialog

//JFrame 是一个顶级窗口，它可以包含菜单条。你可以通过调用 setJMenuBar(JMenuBar menuBar) 方法将 JMenuBar 添加到 JFrame。

86. 当表格需要刷新显示时，表格对象应调用的方法是（）。

A、paint() B、set() C、repaint() D、JTable()

87. 下列说法中错误的一项是（）。

A、若要编写出色的图形用户界面程序，首先需要考虑如何在界面中放置构件

B、若要编写出色的图形用户界面程序，不需要让构件响应用户的操作

C、若要编写出色的图形用户界面程序，需要考虑如何让构件响应用户的操作

D、若要编写出色的图形用户界面程序，需要掌握构件的显示效果

88. Swing将GUI组件分成了几个部分，其中处于核心地位的是（）。

A、控制 B、模型 C、视图 D、对象

89. 下列说法中错误的一项是（）。

A、LayoutManager是一个接口，编程时通常使用的是实现该接口的类

B、布局管理器体现了Java平台无关性

C、每个容器都对应一个布局管理器

D、在Java中，必须直接设置构件在容器中的位置和直接设置构件的大小

A、LayoutManager是一个接口，编程时通常使用的是实现该接口的类

正确。LayoutManager 是 Java Swing 中的一个接口，用于定义如何安排组件在容器中的位置和大小。实际编程时，我们使用的是实现了这个接口的类，如 BorderLayout、FlowLayout、GridLayout 等。

B、布局管理器体现了Java平台无关性

大部分正确，但可能有些误导。Java 的平台无关性主要来自于其“编写一次，到处运行”的特性，即 Java 字节码可以在任何支持 Java 的平台上运行。布局管理器与平台无关性直接关联不大，但它们确实使得 Swing GUI 可以在不同平台上以相似的方式显示，因为布局管理器处理了不同平台的屏幕尺寸、分辨率等差异。但更直接地说，它们更多地是体现了 Java Swing 的灵活性和可定制性。

C、每个容器都对应一个布局管理器

正确。在 Java Swing 中，每个容器（如 JFrame、JPanel 等）都有一个与之关联的布局管理器，用于确定容器中组件的布局。如果没有明确设置布局管理器，则使用默认的布局管理器（如 JFrame 的默认布局管理器是 BorderLayout）。

D、在Java中，必须直接设置构件在容器中的位置和直接设置构件的大小

错误。在 Java Swing 中，通常不需要（也不建议）直接设置组件在容器中的位置和大小。相反，应该使用布局管理器来管理这些。布局管理器会根据容器的尺寸和组件的属性自动确定组件的位置和大小。直接设置位置和大小可能会破坏 GUI 的可移植性和在不同平台上的显示效果。

因此，错误的选项是 D。

90. 下面说法不正确的是（）。

A、菜单只能放在窗口的正上方

这个说法是不正确的。在Java Swing中，菜单（通过JMenuBar实现）可以放在窗口的顶部，但并非只能放在正上方。//

B、工具栏可以任意拖放

C、组合框是列表框的一种变体 D、JEditorPane是一个文本组件类

91. 在读字符文件Employee.dat时，需使用文件作为参数的类是（）。

A、BufferedReader B、DataInoutStream

C、DataOutputStream D、FileInputStream

92. java.io包的File类是（）

A、字符流类 B、字节流类 C、对象流类 D、非流类

93. 下列不是OutputStream子类的是（）。

A、文件输出流FileOuputStream B、对象输出流ObjectOuputStream

C、字符输出流CharOuputStream D、压缩文件输出流ZipOuputStream

94. 下列说法中，错误的一项是（）。

A、Java系统的标准输入对象是System.in

B、打开一个文件时不可能产生IOException

C、使用File对象可以判断一个文件是否存在

D、使用File对象可以判断一个目录是否存在

A、正确。Java系统的标准输入对象是System.in，它通常与键盘输入相关联。

B、错误。打开一个文件时完全可能产生IOException。当文件不存在、没有读取或写入权限、磁盘空间不足、文件路径错误等情况发生时，都会抛出IOException或其子类异常。

C、正确。使用File对象可以判断一个文件是否存在，通过调用exists()方法即可。

D、正确。同样，使用File对象也可以判断一个目录是否存在，也是通过调用exists()方法。

95. 在读字符文件Employee.dat时，使用文件作为参数的类是（）

A、BufferedReader B、DataInoutStream

C、DataOutputStream D、FileInputStream

96. 在Applet中显示文字、图形等信息时，应使用的方法是（）。

A、paint() B、init() C、start() D、destroy()

97. 当启动Applet程序时，首先调用的方法是（）

A、stop( ) B、init( ) C、start( ) D、destroy( )

98. 下列关于Applet的说法中，错误的是（）。

A、Applet自身不能运行，必须嵌入到其他的应用程序（如浏览器）中运行

B、可以在安全策略的控制下读写本地磁盘文件

C、Java中不支持向Applet传递参数

D、Applet的主类要定义为java.applet.Applet类的子类

A、正确。Applet本身不能单独运行，它必须嵌入到支持Java的Web浏览器中运行。

B、正确。在适当的安全策略控制下，Applet可以读写本地磁盘文件。但是，由于安全原因，这通常是被限制的，并且需要用户的明确许可。

C、错误。Java确实支持向Applet传递参数。这些参数可以在HTML的<applet>标签（虽然在现代的HTML5中<applet>已被废弃）或<object>和<embed>标签中作为属性来定义，并通过Applet类的getParameter(String name)方法获取。

D、正确。Applet的主类必须是java.applet.Applet类的子类（或者更常见的javax.swing.JApplet的子类，它提供了对Swing组件的支持）。

99. 当浏览器重新返回Applet所在的页面时，将调用Applet类的方法是（）

A、start( ) B、init( ) C、stop( ) D、destroy( )

//这是因为在Applet的生命周期中，当Applet所在的页面首次被加载或重新变为可见时（例如，用户从另一个页面返回到包含Applet的页面），start()方法会被调用。而init()方法仅在Applet首次被加载时调用一次，stop()方法在Applet不再可见时调用（例如，用户导航到另一个页面），destroy()方法则在Applet被垃圾回收之前调用，通常不需要直接调用。

100. 在Java Applet程序用户自定义的Applet子类中，一般需要重载父类的（）方法来完成一些画图操作。

A、start( ) B、stop( ) C、init( ) D、paint( )

在Java Applet程序中，如果你想要在用户自定义的Applet子类中完成一些画图操作，你需要重载父类的paint(Graphics g)方法。这个方法会在Applet需要被重绘时自动被调用，比如首次显示Applet、Applet窗口恢复、Applet窗口大小改变或者调用repaint()方法时。

二、判断题

101. 注释的作用是使程序在执行时在屏幕上显示//之后的内容。X

//程序运行时，注释内容不会被执行或显示在屏幕上。

102. 当一个方法在运行过程中产生一个异常，则这个方法会终止，但是整个程序不一定终止运行。√

103. for 语句中的循环体不能是空的。x

//实际上，for 语句中的循环体（即循环内部执行的代码块）可以是空的。在编程中，这虽然不是一个常见的做法，但在某些情况下可能是有意为之的。一个空的循环体可以用一对大括号 {} 来表示。

104. 程序执行过程中需要的所有类都是通过字节码校验程序装入的。√

105. Java标识符只能由大小写字母组成。x

106. Java语言的内存由程序员管理，使用完内存后由程序员释放内存。x

107. Java字符使用的是 16 位Unicode 编码。√

108. false 是合法的 Java 标识符。x

//由于 false 是 Java 的一个关键字，用于表示布尔值，因此它不能用作标识符。

109. 应用程序一定要有main()方法，小程序一定要继承于Applet 类。√

110. 双精度数强制转换成单精度数后，其数值精度会提高。x

111. 程序中抛出异常时(throw …)，只能抛出自己定义的异常对象。x

//，当使用throw关键字抛出异常时，你不仅可以抛出自己定义的异常对象（通常是通过扩展Exception或RuntimeException类），还可以抛出Java标准库中的异常对象，比如NullPointerException、IllegalArgumentException、IOException等。

112. 一个异常处理中 finally语句块只能有一个或者可以没有。√

113. 用Javac编译Java源文件后得到代码叫字节码。√

114. Java语言中一个Char类型的数据占用2个字节大小的内存空间。√

115. Java是强类型语言。√

116. Java支持多继承。x

117. 任何类都有构造方法，如果没有构造方法，就不能创建该类的对象。x

118. 类及其属性、方法可以同时有一个以上的修饰符来修饰。√

119. 构造方法的方法名可由编程人员任意命名。x

120. 属性的隐藏是指子类重新定义从父类继承来的同名变量。√

121. 如果p是父类Parent的对象，而c是子类Child的对象，则语句p=c是正确的。x

122. 一个类如果实现了某个接口，那么它必须覆盖该接口中的所有方法。v

123. 子类不能继承父类的构造方法。√

124. 一个子类可以重新定义从父类那里继承来的同名方法，而且允许它们有不同的返回值？。

125. 类的构造方法名必须和类名相同。√

126. 面向对象的软件开发方法用类把数据和基于数据的操作封装在一起，并且类之间可以存在继承关系。√

127. 方法可以没有返回值，或有一个返回值，也可以有多个返回值。？？？

128. 一个类中用private 修饰符修饰的属性成员，可被该类的方法和它的子类的方法访问。//x 应该是抽象

129. 接口是一种特殊的类，接口中的变量都是常量，接口中的方法都是抽象方法，因此接口中的变量都应该由public static final修饰，接口中的方法都应该由public abstract修饰。x

//只能是public修斯

130. 一个Java类可以有多个父类。x // 儿子只有一个父亲

131. 接口是特殊的类，所以接口也可以继承，子接口将继承父接口的所有常量和抽象方法√

132. 用static修饰的方法称为静态方法，它不属于类的一个具体对象，而是整个类的类方法。√

133. Java语言中的接口可以继承，一个接口通过关键字extends可以继承另一个接口。//

是的，您完全正确。在Java中，接口（interface）可以继承自另一个或多个接口，使用extends关键字来实现。这允许接口之间共享常量和方法的定义。

当一个接口继承另一个接口时，它会继承被继承接口中定义的所有常量和抽象方法。接口之间可以有单继承（即只继承一个接口）或者多继承（即继承多个接口，使用逗号分隔）。

下面是一个简单的例子，展示了一个接口如何继承另一个接口：

java
复制
// 定义一个接口A
public interface InterfaceA {
void methodA();
int CONSTANT_A = 10;
}

// 定义一个接口B，它继承了接口A
public interface InterfaceB extends InterfaceA {

134. 保留字 this 代表当前对象。 Java语言中的接口可以继承，一个接口通过关键字extends可以继承另一个接口√

135. 构造方法能继承，也能被重载。√

136. Java语言中的数组元素下标总是从0开始，下标可以是整数或整型表达式。√

137. 设String对象s=”H”，运行语句System.out.println(s.concat(“ello!”));后String对象s的内容为”Hello!”，所以语句输出为”Hello!”。x

//输出会是 "Hello!"，但是String对象s的内容仍然是 "H"。concat方法返回的是一个新的String对象，该对象的内容是 "Hello!"，但这个新对象并没有被赋值给变量s。

138. 用“+”可以实现字符串的拼接，用- 可以从一个字符串中去除一个字符子串。x

139. 数组一定占用连续的内存空间。√

140. 使用方法length( )可以获得字符串或数组的长度。x

var str = "Hello";
var lengthStr = str.length; // 字符串的长度

var array = [1, 2, 3, 4, 5];
var lengthArray = array.length; // 数组的长度

141. 所有的鼠标事件都由MouseListener监听接口的监听者来处理。x

142. Java的屏幕坐标是以像素为单位，容器的左下角被确定为坐标的起点。x

//实际上，Java的Swing和AWT图形用户界面（GUI）框架中的屏幕坐标和容器坐标的约定与您的描述略有不同。在Swing和AWT中，坐标系统的原点（即(0,0)点）通常位于容器的左上角，而不是左下角。

143. 一个容器中可以混合使用多种布局策略。√

144. Java的事件处理机制中引入了委托事件模型，具体说来就是，所有事件类都有一个监听者接口与之相对应，而事件类中的每个具体事件类型都只有一个具体的抽象方法与之对应。x

//有些事件类可能包含多个方法，用于处理不同类型的事件细节。

145. 容器是用来组织其他界面成分和元素的单元，它不能嵌套其他容器。x

146. 凡是Java Applet程序，必须加载java.applet包。√

147. 在 Applet 的坐标系中，(0,0) 代表输出窗口左上角的象素点。√

148. Java Applet是由独立的解释器程序来运行的。x

不完全正确。Java Applet 并不是由独立的解释器程序来运行的，而是由支持 Java 的 Web 浏览器中的 Java 插件（或称为 Java 运行环境，JRE）来运行的。这个 Java 插件实际上是一个内置的 Java 虚拟机（JVM），它负责解释和执行嵌入在网页中的 Applet 字节码。

149. Java Applet只能在图形界面下工作。√

150. Applet程序既可以通过浏览器来运行，也可以通过命令行来运行。√

三、阅读分析

151. 阅读程序，回答问题

1): public class A {

2): public static void main(String args[]) {

3): int x=1;

4): for(int i=1;i<=5;i++) {

5): if(i%2==0)

6): continue;

7): x*=i; //1x3x5 = 15

8): }

9): System.out.println("x="+x);

10): }

11): }

问题：程序输出的结果是什么？

程序输出的结果是 x=15。

解释：

变量 x 初始化为 1（第3行）。
循环从 i = 1 开始，直到 i = 5（第4行）。
在循环内部，程序首先检查 i 是否为偶数（第5行）。
如果 i 是偶数（i%2==0 为真），则执行 continue 语句（第6行），这将跳过当前循环的剩余部分（即跳过第7行），并立即开始下一次循环迭代。
如果 i 不是偶数（即 i 是奇数），则执行第7行，将 x 乘以 i。

具体到这次循环：

当 i = 1，i 不是偶数，所以 x = 1 * 1 = 1
当 i = 2，i 是偶数，所以跳过 x *= i，直接开始下一次循环
当 i = 3，i 不是偶数，所以 x = 1 * 3 = 3
当 i = 4，i 是偶数，所以跳过 x *= i，直接开始下一次循环
当 i = 5，i 不是偶数，所以 x = 3 * 5 = 15

最后，程序输出 x=15（第9行）。

152. 阅读程序，回答问题

1): public class A {

2): public static void main(String args[]) {

3): X x=new X(); //因为 x 是直接通过 new X() 创建的 X 类的实例，并不包含任何对 showX 方法的重写。

4): Y y=new Y();

5): x.showX();

6): y.showY();

7): }

8): }

9):

10): class X {

11): public void showX() {

12): System.out.println("aaaaa");

13): }

14): }

15):

16): class Y {

17): X a=new X( ) {

18): public void showX() {

19): System.out.println("bbbbb"); //虽然 Y 类中有一个 X 类型的成员变量 a，并且 a 被初始化为一个匿名内部类的实例，这个匿名内部类重写了 showX 方法以打印 "bbbbb"，但这并不影响 x 对象的行为

20): }

21): };

22): public void showY() {

23): a.showX(); } //它会调用 Y 类中定义的 showY 方法，该方法内部又调用了成员变量 a 的 showX 方法。但是，由于这里调用的是 Y 类内部匿名 X 子类的 showX 方法，所以它会打印 "bbbbb"（第19行）。然而，这并不影响第5行 x.showX(); 的输出。

24): }

程序第5行的方法调用输出的结果如何？

程序第5行的方法调用 x.showX(); 将输出 "aaaaa"。

解释：

在类 A 的 main 方法中，首先创建了两个对象：X 类型的 x 和 Y 类型的 y（第3行和第4行）。

当调用 x.showX(); 时（第5行），它直接调用了 X 类中定义的 showX 方法，该方法打印 "aaaaa"（第12行）。

接着，虽然 Y 类中有一个 X 类型的成员变量 a，并且 a 被初始化为一个匿名内部类的实例，这个匿名内部类重写了 showX 方法以打印 "bbbbb"，但这并不影响 x 对象的行为。因为 x 是直接通过 new X() 创建的 X 类的实例，并不包含任何对 showX 方法的重写。

当调用 y.showY();（第6行）时，它会调用 Y 类中定义的 showY 方法，该方法内部又调用了成员变量 a 的 showX 方法。但是，由于这里调用的是 Y 类内部匿名 X 子类的 showX 方法，所以它会打印 "bbbbb"（第19行）。然而，这并不影响第5行 x.showX(); 的输出。

153. 阅读程序，回答问题

1): public class A {

2): public static void main(String[] args) {

3): long first=1,second=1,third; //初始时，first 和 second 都被设置为 1（第3行）。

4): System.out.print(first + " " + second + " "); //首先输出 first 和 second 的值（第4行），即 1 1。

5): for(int i = 3; i <= 6; i++) {

6): third = first + second;

7): System.out.print(third + " ");

8): first = second;

9): second = third; // 1 1 2 3 5 8

10): }

11): }

12): }

程序输出的结果是什么？

程序输出的结果是斐波那契数列的前几项，具体为：

复制
1 1 2 3 5 8

解释：

初始时，first 和 second 都被设置为 1（第3行）。

首先输出 first 和 second 的值（第4行），即 1 1。

接下来，使用 for 循环从 3 迭代到 6（第5行）。

在循环内，首先计算下一个斐波那契数 third，它是 first 和 second 的和（第6行）。

然后输出 third 的值（第7行）。

接着，更新 first 和 second 的值，以便在下次迭代中计算下一个斐波那契数（第8行和第9行）。

循环继续执行，直到 i 达到 6。

因此，输出结果为 1 1 2 3 5 8。

154. 写出下列程序完成的功能s //计算 1/1+1/2+1/3+...+1/100 的值。

public class Sum{

public static void main( String args[ ]){

double sum = 0.0 ;

for ( int i = 1 ; i <= 100 ; i + + )

sum += 1.0/(double) i ;

System.out.println( "sum="+sum );

}

155. 写出下列程序的功能。 //通过调用方法max（）求给定的三个数的最大值。

import java.io.*;

public class Class1{

public static void main( String args[] ){

int i1=1234,i2=456,i3=-987;

int MaxValue;

MaxValue=max(i1,i2,i3);

System.out.println("三个数的最大值："+MaxValue);

}

public static int max(int x,int y,int z){

int temp1,max_value;

temp1=x>y?x:y;

max_value=temp1>z?temp1:z;

return max_value;

}

156. 写出下列程序的功能

import java.io.*;

public class Class1 {

public static void main( String args[ ] ){

SubClass a = new SubClass( 10,3 );

System.out.println( a.exp( ));

}

class SuperClass {

float x;

int n;

SuperClass(float xx,int nn ) {

x = xx ;

n = nn;

}

class SubClass extends SuperClass{

SubClass(float xx , int nn) {

super( xx , nn );

}

float exp( ) {

float s = 1;

for ( int i = 1; i <= n; i++ )

s = s*x;

return s;

}

157. 阅读程序，回答问题

1): public class A {

2): public static void main(String args[]) {

3): MyInterface obj2=new B("B");

4): obj2.show();

5): }

6): }

7):

8): interface MyInterface {

9): double G=88;

10): void show();

11): }

12):

13): class B implements MyInterface {

14):

15): String str;

16): public B(String s) {

17): str=s;

18): }

19): public void show() {

20): System.out.println(str+": G="+G);

21): }

22): }

程序第8~11行定义的MyInterface是类还是接口？程序第4行输出的结果是什么？

接口，B: G = 88.0

在第3行，我们创建了一个B类的实例，并将其赋值给了一个MyInterface类型的引用obj2。这是合法的，因为B类实现了MyInterface接口。

在第4行，我们调用了obj2的show方法。由于obj2实际上是B类的一个实例，它会调用B类中实现的show方法。

在B类的show方法中（第20行），我们输出了类的成员变量str的值（在这里是"B"）和接口常量G的值（在这里是88）。因此，输出的结果是B: G=88

158. 阅读下面的程序（或程序片段），回答问题。

现有类说明如下：

class A{

int x=10;

int GetA(){

return x;

}

class B extends A{

int x=100;

int GetB(){

return x;

}

若b是类B的对象，则b.GetA()的返回值是什么？//10

在Java中，当一个类（子类）继承另一个类（父类）时，子类可以拥有与父类同名的成员变量。这种情况下，父类的变量对子类是不可见的（或者说被隐藏了），但从子类内部可以通过super关键字来访问。但是，对于方法而言，如果在子类中没有重写父类的方法，那么调用该方法时将会执行父类中的版本。

在你给出的代码片段中，类B继承了类A，并且两者都有一个名为x的实例变量和一个获取该变量的方法（GetA()和GetB()）。但是，GetA()方法在类B中并没有被重写（override），所以当我们通过类B的对象b调用GetA()方法时，实际执行的是类A中的GetA()方法。

GetA()方法返回的是类A中定义的x变量的值，即10。因此，b.GetA()的返回值是10

159. 阅读以下程序段，回答问题。

class Parent{

void printMe(){

System.out.println(“parent”);

}

class Child extends Parent{

void printMe(){

System.out.println(“child”);

}

void printAll(){

super.printMe();

this.printMe();

printMe();

}

public class Test_this{

public static void main(String args[ ]){

Child myC=new Child();

myC.printAll();

}

输出结果是什么？

输出结果将是：

parent
child
child

解释：

类Parent有一个printMe方法，它打印出"parent"。

类Child继承自Parent，并且它也定义了一个printMe方法，它打印出"child"。由于子类覆盖了父类的同名方法，所以当在子类Child的上下文中调用printMe方法时，将执行子类的方法。

类Child还有一个printAll方法，这个方法中调用了三次printMe方法，但由于它们都在子类Child的上下文中，因此它们都会调用子类的printMe方法。

super.printMe();：这里通过super关键字显式地调用了父类Parent的printMe方法，因此输出"parent"。
this.printMe();：这实际上是默认的调用方式，即在当前对象的上下文中调用方法。由于子类覆盖了父类的方法，因此这里实际上也调用了子类的printMe方法，输出"child"。
printMe();：这与this.printMe();是完全相同的，因为如果不指定对象（即没有使用super或this），则默认在当前对象的上下文中调用方法，所以再次输出"child"。

因此，当你创建Child类的一个实例并调用其printAll方法时，你将看到上述的输出结果。

160. 阅读程序，回答问题。

1): public class A {

2): public static void main(String args[]) {

3): try{

4): int x[]={1,2,3};

5): int k=Integer.parseInt(args[0]);

6): System.out.println(x[k]);

7): System.out.println("try结束！");

8): }

9): catch(ArrayIndexOutOfBoundsException e){

10): System.out.println("执行catch");

11): }

12): finally{

13): System.out.println("执行finally");

14): }

15): System.out.println("程序结束！");

16): }

17): }

若在命令行编译该程序后，键入下面的内容运行该程序：

java A 3

则程序输出的结果如何？

161. 阅读下面的程序，回答问题。

class student{

String name;

int age;

int score=88;

student(String a1,int a2,int a3){

name=a1;

age=a3;

score=a2;

}

在使用该类时,已使用下面语句生成了该类的对象:

student s1,s2;

s1=new student("张三",20,33);

s2=new student();

s1.name,s1.age,s1.score的值各是什么，s2.nae,s2.age,s2.score的值各是什么？

162. 写出下列程序的功能

import java.io.*;

public class Class1{

public static void main(String args[ ]){

int i , Max , Min ;

int a[ ] = { 12,67,8,98,23,56,124,55,99,100 };

Max = Min = a[0];

for ( i = 1 ; i < a.length; i ++ ) {

if ( a[i]<Min ) Min = a[i];

if ( a[i]>Max ) Max = a[i];

}

System.out.println( Max+" "+Min );

System.out.println( );

}

163. 阅读下面的程序，写出输出结果。

iimport java.io.*;

public class ABC{

public static void main(String args[ ]){

String C s = new StringC ("He","llo");

System.out.println(s.toString( ));

}

class StringC {

String s1;

String s2;

String C( String str1 , String str2 ){

s1 = str1;

s2 = str2;

}

public String toString( ){

return s1+s2;

}

164. 写出下列程序的功能。

public class ABC{

public static void main(String args[ ]){

int i , j ;

int a[ ] = { 12,67,8,98,23,56,124,55,99,100 };

for ( i = 0 ; i < a.length-1; i ++ ) {

int k = i;

for ( j = i ; j < a.length ; j++ )

if ( a[j]<a[k] )

k = j;

int temp =a[i];

a[i] = a[k];

a[k] = temp;

}

for ( i =0 ; i<a.length; i++ )

System.out.print(a[i]+" ");

System.out.println( );

}

165. 写出下列程序的功能。

import java.awt.Graphics;

import java.applet.Applet;

public class SumArray extends Applet{

int a[] = { 1, 3, 5, 7, 9, 10 };

int total;

public void init(){

total = 0;

for ( int i = 0; i<a.length; i++ )

total=total+a[i];

}

public void paint( Graphics g ){

g.drawString( "Total of array elements: " +total, 25, 25 );

}

166. 阅读程序，回答问题

1): import java.util.*;

2): class A {

3): public static void main(String args[]) {

4): TreeSet myTreeSet = new TreeSet();

5): myTreeSet.add("x");

6): myTreeSet.add("z");

7): myTreeSet.add("y");

8): myTreeSet.add("a");

9): myTreeSet.add("b");

10): myTreeSet.add("c");

11): Iterator myIter= myTreeSet.iterator();

12): while(myIter.hasNext())

13): System.out.print(myIter.next());

14): System.out.println();

15): }

16): }

问题：程序运行后输出的结果是什么？

167. 阅读程序，回答问题

class A {

public static void main(String[] args){

String s,s1="";

char c;

s=args[0];

for (int i=0;i<s.length();i++){

c=s.charAt(i);

if(c>='a' && c<='z'){

s1=s1+Character.toUpperCase(c);

}else{

s1=s1+Character.toLowerCase(c);

}

System.out.println(s1);

}

若在dos命令行输入：java A hELLO，则输出为（）。

168. 阅读程序，回答问题

import java.util.*;

public class LinkExample{

public static void main(String args[]){

LinkedList<String>mylist=new LinkedList<String>();

mylist.add("how");

mylist.add("are");

mylist.add("you");

mylist.add("Java");

int number=mylist.size();

System.out.println("现在链表中有"+number+"个节点");

}

程序的功能是什么？

169. 写出下列程序的功能。

public class mainthread{

public static void main(String[] args){

Thread thread = Thread.currentThread();

System.out.println("Main thread is named " + thread. getName());

}

170. 阅读程序，回答问题。

public class CompareTest{

public static void main(String[] args){

String str1 = new String("helloworld");

String str2 = new String("hello");

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

String str3 = new String("helle");

String str4 = new String("hello");

System.out.println(str3.compareTo(str4));

}

问题：程序运行后输出的结果是什么？

171. 写出下列程序的功能

import java.awt.*;

import java.applet.Applet;
public class Applet1 extends Applet{

public void paint( Graphics g ){

g.drawLine( 30,5,100,45 );

g.drawRect( 30,50,50,20 );

g.drawOval( 30,80,50,40 );

g.drawString( "They are figures!" , 30,150 );

}

172. 阅读下面的程序,回答以下问题。

import java.awt.*;

import java.applet.*;

import java.awt.event.*;

public class Applet1 extends Applet implements ActionListener {

Label aa;

TextField t1;

int i=0;

public void init(){

aa=new Label("请输入一个整数：");

add(aa);

t1=new TextField(10);

add(t1);

t1.addActionListener(this);

}

public void paint(Graphics g){

g.drawString("a="+( ++i*--i),20,60);

g.drawString("i="+(i),20,80);

}

public void actionPerformed(ActionEvent e){

i=Integer.parseInt(t1.getText()); //转化为整数

repaint();

}

若在文本域中输入6并回车，程序输出什么?

173. 阅读下面的程序，回答问题。

import java.awt.Graphics;

import java.applet.Applet;

public class BreakTest extends Applet{

public void paint( Graphics g ){

int count, xPos = 25;

for ( count = 1; count <= 10; count++ ){

if ( count == 8 )

break;

g.drawString( " " + count, xPos, 25 );

xPos += 10;

}

程序的输出结果是什么？

174. 写出下列程序的功能

import javax.swing.*;

public class abc{

public static void main(String args[]){

FirstWindow win= new FirstWindow("一个简单菜单窗口");

}

class FirstWindow extends JFrame{

FirstWindow(String s){

super(s);

setSize(160,170);

setLocation(120,120);

JMenuBar menubar=new JMenuBar();

JMenu menu=new JMenu("文件");

menubar.add(menu);

setJMenuBar(menubar);

setVisible(true);

}

175. 阅读下面的程序片断，回答以下问题。

public class JAppletExample extends JApplet implements ActionListener{

JLabel aa;

JTextField t1;

int i=0;

public void init(){

aa=new JLabel("请输入一个整数：");

add(aa);

t1=new JTextField(10);

add(t1);

t1.addActionListener(this);

}

public void paint(Graphics g){

g.drawString("a="+( ++i*--i),20,60);

g.drawString("i="+( i),20,80);

}

public void actionPerformed(ActionEvent e){

i=Integer.parseInt(t1.getText());//转化为整数

repaint();

}

问题：程序中哪个方法是ActionListener中的方法，其功能为何?

176. 阅读程序，回答问题

1): import java.io.*;

2): public class A {

3): public static void main(String[] args) {

4): try {

5): File file = new File("Test.java");

6): LineNumberReader in = new LineNumberReader(new FileReader(file));

7): String str;

8): while((str=in.readLine())!=null){

9): System.out.println(in.getLineNumber()+": "+str);

10): }

11): in.close();

12): } catch (IOException e){

13): System.out.println(e);

14): }

15): }

16): }

程序采用了什么流进行读取，第9行的方法getLineNumber()的功能是什么？

177. 阅读程序，回答问题

import java.io.*;

public class ReadLineTest{

public static void main(String[ ] args){

BufferedReader b=new BufferedReader (new InputStreamReader (System.in));

String s;

System.out.flush();

s=b.readLine();

System.out.println(s);

}

运行以上程序，若从键盘输入： Hello<回车>

则输出结果是什么？

178. 写出下列程序完成的功能。

public class Reverse{

public static void main(String args[ ]){

int i , n =10 ;

int a[ ] = new int[10];

for ( i = 0 ; i < n ; i ++ )

try {

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

a[i] = Integer.parseInt(br.readLine( )); // 输入一个整数

} catch ( IOException e ) { } ;

for ( i = n－1 ; i >= 0 ; i--)

System.out.print(a[i]+" ");

System.out.println( );
}

}

179. 写出下列程序的功能。

import java.net.*;

import java.io.*;

public class URLConnectionReader {

public static void main(String[] args) throws Exception {

URL web = new URL("http://www.swust.edu.cn");

URLConnection webc = web.openConnection();

BufferedReader in = new BufferedReader(new InputStreamReader(

webc.getInputStream()));

String inputLine;

while((inputLine = in.readLine()) != null)

System.out.println(inputLine);

in.close();

}

180. 写出下列程序的功能。

import java.io.*;

public class a{

public static void main(String args[]) throws IOException{

int i;

float f,r;

BufferedReader din = new BufferedReader(new InputStreamReader(System.in));

System.out.print("input i: ");

i = Integer.parseInt(din.readLine());

System.out.print("input f: ");

f = Float.parseFloat(din.readLine());

r = i+f;

System.out.println(i+"+"+f+"="+r);

}

四、填空题

181. 表达式1/2*3的计算结果是（）。

182. 结构化程序设计的三种基本流程控制结构是：顺序结构、循环结构和（）。

183. 在Java语言中，逻辑常量只有true 和（）两个值。

184. 以下方法fun的功能是求两参数之和，由一条语句完成，请填写出来。

int fun ( int a, int b ){ （）; }

185. Java源程序文件的扩展名为（）。

186. 在Java语言中，由／**开始，以*/结束的注释语句可以用于生成（）。

187. Java语言的类型检查机制要求对于没有返回值的方法，在其前面必须加（）进行说明。

188. 在不产生溢出的情况下左移运算相当于（）运算。

189. 算术右移一位相当于（）算术运算。

190. 多重循环是指往一个循环体内嵌入另一个完整的（）。

191. 数据类型为布尔型的保留字是（）。

192. 在对一个复杂表达式进行运算时，按照运算符的优先级次序进行，若是同级运算符，则按照其在表达式中的位置（）的顺序进行。

193. 在switch语句中，完成一个case语句块后，若没有通过break语句跳出switch语句，则会紧接着执行后面的（）语句块。

194. 可以通过（）语句将异常抛出向上级调用方法。

195. 用户定义异常是通过扩展Exception类及（）类来刨建的。

196. 使用一个对象前，必须声明并（）它。

197. 基类的公有成员在派生类中的访问权限由（）决定。

198. 创建类对象的运算符是（）。

199. 用static修饰的方法，称为静态方法。它们不是对象的方法，而是整个类的方法。静态方法只能处理用关键字（）修饰的数据。

200. 在Java程序中定义的类有两种成员：（）和成员变量。

201. 调用一个类的static方法，可以不创建该类的对象，直接通过（）作前缀来调用。

202. 在java源程序的类头中使用关键字（）声明该类实现某个接口。

203. 定义类的构造方法不能有返回值类型，其名称与（）名相同。

204. Java中，把数据和基于数据的操作封装在一起的数据类型称为（）。

205. （）方法是不能被当前类的子类重新定义的方法。

206. 方法调用Math.abs(-90)返回的结果是（）。

207. 堆栈类Stack的方法empty()的功能是判断堆栈是否为空，其返回的结果是（）类型。

208. 方法调用Math.min(-9,11)返回的结果是（）。

209. main方法的声明格式是（）。

210. 在比较两个对象的值是否相同时，可以调用（）方法。

211. 使一个类线程化的两种途径是继承Thread类和（）。

212. 线程在生命周期中要经历5种状态，分别是新建状态，可运行状态，运行状态，（）状态和终止状态。

213. 线程对象调用sleep(1000)方法，则该线程休眠（）毫秒。

214. 线程调用start()方法将启动线程，是线程从（）状态进入就绪队列排队。

215. 若在高优先级线程的run( )方法中调用sleep()方法，则该线程将让出CPU，使其他（）的线程获得CPU的使用权。

216. 组件不能独立的显示出来，必须将组件放在一定的（）中才能显示。

217. 能将显示空间分成很多层的布局管理器是（）。

218. JDialog的内容面板的默认布局是（）布局。

219. 在Swing中创建一个标识有“关闭”字样的按钮对象gb的语句为（）。

220. 在向JFrame窗口中添加组件时，不能将组件直接添加在窗口中，应该将组件添加在（）中。

221. FileInputStream是字节流；BufferedWriter是字符流；ObjectOutputStream是（）。

222. Java流类中最基本的两个类是（）和OutputStream。。

223. 所有的输出过滤流都是抽象类（）的子类。

224. 流类处理的是文件的（），而Flie类处理的是文件在磁盘上的存储。

225. 从DataInlputStream对象dis的当前位置处读取一个字符串保存在变量str中的语句是（）。

226. Applet是能够嵌入到（）文件中，并能够自浏览器中运行的Java类。

227. Java小程序的源文件名为App1.java，为运行该小程序，应将小程序嵌入网页文件中，其html的关键代码如下，请将其补充完整：

228. 用户申明一个Applet类时，该类必须继承自（）。

229. 通过实现Applet类的（）方法，可以返回关于参数定义的信息。

230. 存JApplet中添加构件是把Swing组件加入JApplet的（）中。

答案

一、单选题

1. D

2. D

3. D

4. A

5. B

6. B

7. A

8. A

9. D

10. A

11. D

12. C

13. C

14. C

15. C

16. C

17. C

18. B

19. B

20. D

21. A

22. B

23. C

24. B

25. C

26. D

27. D

28. A

29. B

30. B

31. B

32. A

33. A

34. A

35. A

36. C

37. C

38. B

39. C

40. A

41. B

42. B

43. B

44. D

45. A

46. A

47. D

48. D

49. B

50. B

51. B

52. A

53. D

54. B

55. B

56. A

57. C

58. B

59. A

60. C

61. A

62. A

63. A

64. C

65. B

66. B

67. A

68. B

69. C

70. B

71. B

72. D

73. C

74. A

75. A

76. C

77. A

78. B

79. D

80. C

81. C

82. C

83. B

84. B

85. B

86. C

87. B

88. B

89. D

90. A

91. D

92. D

93. D

94. B

95. D

96. A

97. B

98. C

99. A

100. D

二、判断题

101. ×

102. √

103. ×

104. √

105. ×

106. ×

107. √

108. ×

109. √

110. ×

111. ×

112. √

113. √

114. √

115. √

116. ×

117. ×

118. √

119. ×

120. √

121. ×

122. √

123. ×

124. √

125. √

126. √

127. ×

128. ×

129. ×

130. ×

131. √

132. √

133. √

134. √

135. √

136. √

137. ×

138. ×

139. √

140. ×

141. ×

142. ×

143. √

144. ×

145. ×

146. √

147. √

148. ×

149. √

150. √

三、阅读分析

151. x=15

152. aaaaa

153. 1 1 2 3 5 8

154. 计算 1/1+1/2+1/3+...+1/100 的值。

155. 通过调用方法max（）求给定的三个数的最大值。

156. 定义一个计算xn的类，然后用该类求103的值。

157. 接口，B: G = 88.0

158. 10

159. Parent

Child

child

160.

执行catch

执行finally

程序结束！

161. s1.name="张三", s1.age=33, s1.score=20

s2.name=null, s2.age=0, s2.score=88

162. 在数组中查找并输出最大值和最小值。

163. hello

164. 使用选择法对数组a的数据进行升序排序，然后输出排序后的结果。

165. 计算数组各元素的和。

166. abcxyz

167. Hello

168. 将字符串"how"，"are"，"you"，"Java"存储到LinkedList中，并输出链表中共有多少个节点。

169. 取得主线成的名字，并在屏幕上输出。

170. 5

-10

171. 在Applet界面中显示一些由直线段、矩形框和椭圆和文字组成的图形，其中：直线段从坐标(30,5)起到坐标(100,45)止；矩形左上角坐标为(30，50)，长为50，高为20；椭圆外接矩形左上角坐标为(30,80)，水平轴长50，垂直轴长40；文字内容为“They are figures!”，在坐标(30,150)处从左到右水平输出。

172. a=42

i=6

173. 1 2 3 4 5 6 7

174. 创建一个标题为"一个简单菜单窗口"的窗体，窗体中显示有"文件"字样的菜单。

175. actionPerformed()，当在文本域中按回车键时，该方法被调用，其功能为取文本域中的文本，转换为int型数据赋给i，通过repaint()而调用paint()方法输出结果。

176. 文件字符流，得到文件Test.java中每一行的行号。

177. Hello

178. 从标准输入(即键盘)读入10个整数存入整型数组a中，然后逆序输出这10个整数。

179. URLConnection对给定的URL资源（http://www.swust.edu.cn）进行读取，并显示在屏幕上。

180. 使用BufferedReader类从键盘接收一个整数和一个实数，计算它们的和，然后在屏幕上输出。

四、填空题

181. 0