Java程序设计基础练习题

更新时间：2024-04-23 13:26:01 阅读量：综合文库文档下载

说明：文章内容仅供预览，部分内容可能不全。下载后的文档，内容与下面显示的完全一致。下载之前请确认下面内容是否您想要的，是否完整无缺。

一、判断题

1、Java不区分大小写的语言。 (N)

2、Java的源代码中定义几个类，编译结果就生成几个以“.class”后缀的字节码文件。(Y)

3、Java的各种数据类型占用固定长度，与具体的软硬件平台环境无关。(Y) 4、Java源程序是由类定义组成的，每个程序可以定义若干个类，但只有一个类是主类。(Y)

5、Java中数组的元素只能是简单数据类型的量。(N)

6、Java的String类的对象既可以是字符串常量，也可以是字符串变量。(N) 7、一个类只能有一个父类，但一个接口可以有一个以上的父接口。(Y) 8、由继承性可知，程序中子类拥有的成员数目一定大于等于父类拥有的成员数目。(N) 9、Java语言中的数组元素下标总是从0开始，下标可以是整数或整型表达式。(Y) 10、注释的作用是使程序在执行时在屏幕上显示//之后的内容。（N）

11、Java的字符类型采用的是Unicode编码，但所占字节由具体软硬件环境决定。(N)

12、无论Java源程序包含几个类的定义，若该源程序文件以A.java命名，编译后生成的都只有一个名为A的字节码文件。（ N ） 13、Java的各种数据类型所占用的内存长度与具体软硬件环境有关。（ N） 14、与C语言不同的是，Java语言中的数组元素下标总是从1开始。（ N ） 15、在Java的方法中定义一个常量要用const关键字。（ N ） 16、异常处理中总是将可能产生异常的语句放在try块中，用catch子句去处理异常，而且一个try块之后只能对应一个catch语句。（ N ）

17、序员可以不必释放已创建的对象，因为Java有垃圾回收机制，内存回收程序可在指定的时间释放内存对象。（ N ） 18、ava系统的标准输入对象是System.in，标准输出对象有两个，分别是标准输

出System.out和标准错误输出System.err。（ Y ）

19、即使一个类中未显式定义构造函数，也会有一个缺省的构造函数，缺省的构造函数是无参的，函数体为空。（ Y ）

20、Java中%是取余运算符，要求两端操作数为整型。（ N ）

21、造函数用于创建类的实例对象，构造函数名应与类名相同，在类中必须定义

构造函数，且只能定义一个构造函数。（ N ）

22、java的类不允许多重继承，但接口支持多重继承。（ Y ） 23、谓抽象类就是包含有抽象方法的类。（ Y ） 24、java语言中的数组元素只能是基本数据类型而不能为对象类型。（ N ） 25．一个线程对象的具体操作是由run()方法的内容确定的，但是Thread类的run()方法是空的,其中没有内容;所以用户程序要么派生一个Thread的子类并在子类里重新定义run()方法,要么使一个类实现Runnable接口并书写其中run()方法的方法体。（ Y ）

26．Applet是一种特殊的Panel，它是Java Applet程序的最外层容器。（√） 27．Java程序里,创建新的类对象用关键字new，回收无用的类对象使用关键字free。（×） 28．构造函数用于创建类的实例对象，构造函数名应与类名相同，返回类型为void。（×） 29．拥有abstract方法的类是抽象类，但抽象类中可以没有abstract方法。（√）

30．Java的屏幕坐标是以像素为单位，容器的左下角被确定为坐标的起点。（×） 31．静态初始化器是在其所属的类加载内存时由系统自动调用执行。（√）

33．如果p是父类Parent的对象，而c是子类Child的对象，则语句p=c是正确的。（√）

34．abstract方法所在的类必须是abstract类。（√） 35．java异常处理中可以使用多个catch子句,此时应将高级别异常类的catch子句放在前面。 (×)

36．设String对象s=\运行语句System.out.println(s.concat(\后String对象s的内容为\所以语句输出为\。 (× ) 38．通过继承，父类中的保护成员在派生类中不能被直接访问。( ×) protect访问权限定义了子类，同包和本类可以访问！

39．接口中的方法一定是抽象方法，变量可以不赋初值。

40．子类继承父类后，如果出现子类的成员变量名和父类的成员变量名同名，那么子类就不继承父类的这个成员变量了。( ×) 41．Java程序是运行在Java虚拟机中的。（√）

42．接口中的方法一定是抽象方法，变量可以不赋初值。( ×)

注：在接口里面搞变量没任何意义，在接口中定义的变量实际上是（假如你定义了个 int i，相当于public static final int i,)既然被final修饰了，那么就是常量，不能改值了，继承了他就不能变了，你一改就报错，所以一定要赋值！

43．可以用new来创建一个类的实例，即\对象\。（√） 44．Java程序对计算机硬件平台的依赖性很低。（√） 45．Java中类的构造函数只能有一个。( ×)

46．Java可以用来进行多媒体及网络编程。（√） 47．类的public类型的成员变量不可以被继承。( ×) 48．子类可以继承父类所有的成员变量及成员函数。( ×) 49．Java类中不能存在同名的两个成员函数。( ×) 50．break语句可以用在循环和switch语句中。（√） 51．对象是类的一个实例。（√）

52．用abstract修饰的类必须被继承。（√） 53．类都能有多个构造方法。（√）

54．applet可以运行在浏览器中。（√）

55．用Javac编译Java源文件后得到代码叫字节码。（√）

56．continue语句用在循环结构中表示继续执行下一次循环。（√） 57．实现一个接口，则在类中一定要实现接口中的所有方法。( ×) 58．抽象类不能实例化。（√）

56．在子类的构造函数中，可以把Super()放到任何位置。

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

58．Java语言具有较好的安全性和可移植性及与平台无关等特性。（ √ ） 59.Java语言的源程序不是编译型的，而是编译解释型的。（ √ ）

60.Java Application程序中，必有一个主方法main()，该方法有没有参数都可以。（ √ ）

61.java.util.Scanner(System.in)可以接收用户从键盘输入的简单数据。（ √ ） 62.Java程序中不区分大小写字母。（ × ）

63.机器不能直接识别字节码文件，它要经过JVM中的解释器边解释边执行。（ √ ）

64.System类中的println()方法分行显示信息，而print()方法不分行显示信息。（ √ ）

65.当前路径的标识是“.”。（ √ ）

66.java命令不区分大小写，而javac命令区分大小写。（ × ）

67.printf()和 format()方法使用指定格式字符串和参数，将格式化字符串写入到PrintStream类型的输出流（System.out对象）中。（ √ ）

68.在运行字节码文件时，使用java命令，一定要给出字节码文件的扩展名.class。（ × ）

69.Java语言使用的是Unicode字符集，每个字符在内存中占8位。（ × ） 70.Java语言中不同数据类型的长度是固定的，不随机器硬件不同而改变。（ √ ）

71.所有的变量在使用前都必须进行初始化。（ × ）

72.已知byte i = (byte)127; i = i +1;这两个语句能被成功编译。（ √ ） 73.String str=\char chr=str.charAt(9); （ × ）

74.char[] chrArray={ 'a', 'b', 'c', 'd', 'e', 'f', 'g'}; char chr=chrArray[6]; （ √ ）

75. int i,j; boolean booleanValue=(i==j); （ × ）

76. int intArray[]={0,2,4,6,8}; int length=int Array.length();（ × ）

77.String str=\（ × ） 78.short shortValue=220; byte byteValue=shortValue; （ × ） 79.int[] intArray[60]; （ × ）

80.char[] str=\（ × ）

81.说明或声明数组时不分配内存大小,创建数组时分配内存大小。（ √ ） 82.强制类型转换运算符的功能是将一个表达式的类型转换为所指定的类型。（ √ ）

83．类是一种类型，也是对象的模板。（ √ ） 84．类中说明的方法可以定义在类体外。（ × ） 85．实例方法中不能引用类变量。（ × ）

86．创建对象时系统将调用适当的构造方法给对象初始化。（ √ ）

87．使用运算符new创建对象时，赋给对象的值实际上是一个引用值。（ √ ） 88．对象赋值实际上是同一个对象具有两个不同的名字，它们都有同一个引用值。（ √ ）

89．对象可作方法参数，对象数组不能作方法参数。（ × ） 90．class是定义类的惟一关键字。（ √ ）

91．Java语言会自动回收内存中的垃圾。（ √ ）

92．子类的成员变量和成员方法的数目一定大于等于父类的成员变量和成员方法的数目。（ × ）

93．抽象方法是一种只有说明而无具体实现的方法。（ √ ） 94．Java语言中，所创建的子类都应有一个父类。（ √ ）

95．调用this 或super构造方法的语句必须放在第一条语句。（ √ ） 96．一个类可以实现多个接口，接口可以实现“多重继承”。（ √ ） 97．实现接口的类不能是抽象类。（ √ ）

98．使用构造方法只能给实例成员变量赋初值。（ √ ）

99．Java 语言不允许同时继承一个类并实现一个接口。（ × ） 100．Java语言中，构造方法是不可以继承的。（ √ ）

103．Integer i = (Integer.valueOf(\（ √ ）

104．String s = (Double.valueOf(\（ √ ） 105．Integer I = Integer.parseInt(\（ √ ） 107．在集合中元素类型必须是相同的。（ √ ） 108．集合中可以包含相同的对象。（ × ）

117．捕获异常try语句后面通常跟有一个或多个catch()方法用来处理try块内生成的异常事件。（ √ ）

118．使用try-catch-finally语句只能捕获一个异常。（ × ） 119．try-catch语句不可以嵌套使用。（ × ）

120．Error类所定义的异常是无法捕获的。（ √ ）

121．IOException异常是非运行时异常，必须在程序中抛弃或捕获。（ √ ） 122．用户自定义异常类是通过继承Throwable类来创建的。（ × ）

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

126．所谓线程同步就是若干个线程都需要使用同一个synchronized修饰的方法。（ √ ）

127．使用Thread子类创建线程的优点是可以在子类中增加新的成员变量，使线程具有某种属性，也可以在子类中新增加方法，使线程具有某种功能。但是，Java不支持多继承，Thread类的子类不能再扩展其他的类。（ √ ）

128．Java虚拟机(JVM)中的线程调度器负责管理线程，调度器把线程的优先级分为10个级别，分别用Thread类中的类常量表示。每个Java线程的优先级都在常数1和10之间，即Thread.MIN_PRIORITY和Thread.MAX_PRIORITY之间。如果没有明确地设置线程的优先级别，每个线程的优先级都为常数8。（ × ）

129．当线程类所定义的run( )方法执行完毕，线程的运行就会终止。（ √ ） 130．线程的启动是通过引用其start()方法而实现的。（ √ ） 131．文件缓冲流的作用是提高文件的读/写效率。（ √ ） 132．通过File类可对文件属性进行修改。（ √ ） 133．IOException必须被捕获或抛出。（ √ ）

134．Java系统的标准输入对象是System.in，标准输出对象有两个，分别是标准输出System.out和标准错误输出System.err。（ √ ）

二、填空题

1、根据结构组成和运行环境的不同，Java程序可分为两类： Java Applet 、 Java application 。

2、类的修饰符分为 abstract 、 public 。

3、程序中定义类使用的关键字是 class ，每个类的定义由类头定义、类体定义两部分组成，其中类体部分包括属性、方法。

4、Java程序中定义接口所使用的关键字是 interface，接口中的属性都是静态变量，接口中的方法都是抽象方法。

5、 Object 是Java程序中所有类的直接或间接父类，也是类库中所有类的父类。

6、列代码后的结果是什么? int x,a=2,b=3,c=4; x=++a+b+++c++; 10 7、main方法的声明格式包括

8、构造函数_______有返回值。答案：构造函数没有返回值。

9、Java语言中的浮点型数据根据数据存储长度和数值精度的不同，进一步分为________和 __________两种具体类型。答案：float和 double两种具体类型 10、创建类对象的运算符是_______。答案：new

11、当整型变量n的值不能被13除尽时，其值为 false 的Java语言表达式是_____________ 。答案：n

12、在Java语言中，所有的数组都有一个lenght属性，这个属性存储了该数组的__________。答案：元素个数

13、定义类就是定义一种抽象的____________，它是所有具有一定共性的对象的抽象描述。答案：数据类型

14、在Java语言中，使用_____、______等技术，实现软件重用。答案：继承、多态等技术

15、表达式3/6 * 5的计算结果是________ 。答案：结果是0

16、下面是一个类的定义: public class ____________ {

int x, y;

Myclass ( int i, _______) // 构造函数 {

x=i; y=j; } }

答案：Myclass int j 17、下面是一个Java Application 的主类的定义，其功能是输出所有命令行参数。 import java.io.*; public class MyClass {

public static void main(String args[ ]) {

if( args.length !=___)

for(int i=0; i < args.length; i++) System.out.println(___________);

else System.out.println(没有命令行参数); } }

答案：0

args[i]

18、Java的复合数据类型有 : 类、数组和_______等。答案：接口

19、表达式3/6 * 5的计算结果是________ 。答案：0

20、定义初值为10的10次方的长整型变量 lvar 的语句是：__________________________。答案：long lvar=Math.pow(10,10)。

21、顺序结构、分支结构(或称选择结构)、____________是结构化程序设计的三种基本流程控制结构。答案：循环

22、以下方法 m 的功能是求两参数之积的整数部分。 int m ( float x, float y ) { __________________; }

答案：return Math.round(x),Math.round(y);

23、Java 源程序文件编译后产生的文件称为________文件,其扩展名为 ___________ 。

答案：字节码文件, .class

24、向对象方法中，类的实例称为____。答案：对象

25、java源文件中最多只能有一个____类，其他类的个数不限。答案：public 26、java中所有实现的多维数组，实际上是由一维数组构成的____。答案：数组的数组

27、下列程序的运行结果是 26 class A{ class Dog{

private String name; private int age; public int step; Dog(String s,int a) {

name=s; age=a; step=0; }

public void run(Dog fast) {

fast.step++; } }

public static void main (String args[]) {

A a=new A();

Dog d=a.new Dog(\ d.step=25; d.run(d);

System.out.println(d.step); } }

1．已知：int a =8,b=6; 则：表达式++a-b++的值为（ 3 ）。

2．已知：boolean b1=true,b2; 则：表达式! b1 && b2 ||b2的值为（ false ）。

3．已知：double x=8.5,y=5.8; 则：表达式x++>y--值为（ true ）。 4．已知：int a[ ]={2,4,6,8}; 则：表达式(a[0]+=a[1])+ ++a[2]值为（ 13 ）。

5．执行int x, a = 2, b = 3, c = 4; x = ++a + b++ + c++; 结果是（ x=10,a=3,b=4,c=5 ）。

6．Java中的显式类型转换既能（从低类型向高类型转换）也能从高类型向低类型转换，而隐式类型转换只有前者。

7．在Java中，字符串和数组是作为（对象）出现的。 8．执行下列程序代码的输出结果是（ 10,11,11 ）。

int a = 10; int i, j; i = ++a; j = a--; System.out.printf(\9．执行完boolean x=false; boolean y=true; boolean z=(x&&y)&&(!y) ; int f=z==false?1:2;

这段代码后，z与f的值分别是（ false ）和（ 1 ）。

1．类是一组具有相同（属性）和（行为）的对象的抽象。（实例）是由某个特定的类所描述的一个个具体的对象。

2．（接口）只描述系统所提供的服务，而不包含服务的实现细节。

7．构造方法的方法名与（类名）相同，若类中没有定义任何的构造方法，则运行时系统会自动为该类生成一个（默认构造）方法。

8．在方法体内定义的变量是（局部变量），其前面不能加（public），且必须（初始化）。

9．数组元素作实参时对形参变量的数据传递是（单向值传递），数组名作实参时对形参变量的数据传递是（双向引用传递）。

10．对象作方法形参时，方法实参也用对象，实现（引用）调用。 11．（ new）是一个特殊的方法，用于创建一个类的实例。

12．对象拷贝有（对象引用复制）、（浅复制）和（深复制）三种。

13．（类）方法不能直接访问其所属类的（实例）变量和（实例）方法，只可直接访问其所属类的（类）变量和（类）方法。

14．（类）变量在内存中只有一个拷贝，被该类的所有对象共享；每当创建一个实例，就会为（实例）变量分配一次内存，（实例）变量可以在内存中有多个拷贝，互不影响。

15．Java使用固定于首行的（package）语句来创建包。

16．在运行时，由java解释器自动引入，而不用import语句引入的包是（java.lang）。

17．发布Java应用程序或类库时，通常可以使用JDK中自带的（JAR）命令打包。

1．在面向对象系统中，消息分为（公有消息）和（私有消息）两类。

2．类的访问控制符有（public）和（默认default）两种，（public）类具有跨包访问性而（default）类不能被跨包访问。

3．类成员的访问控制符有（public）、（protected）、（private）和默认四种。

4．public类型的类成员可被（同一类）、同一包中的（子类与非子类）和不同包中的（子类与非子类）的代码访问引用。

5．protected类型的类成员可被（同一类）、同一包中的（子类与非子类）和不同包中的（子类）的代码访问引用。

6．default类型的类成员只能被（同一类）、同一包中的（子类与非子类）的代码访问引用。

7．private类型的类成员只能被其所在类中的代码访问引用，它只具有（类）域访问性。

8．系统规定用（this()）表示当前类的构造方法，用（super()）表示直接父类的构造方法，在构造方法中两者只能选其一，且须放在第一条语句。

9．若子类和父类在同一个包中，则子类继承父类中的（public）、（protected）和（默认）成员，将其作为子类的成员，但不能继承父类的（private）成员。

10．若子类和父类不在同一个包中，则子类继承了父类中的（public）和（protected）成员，将其作为子类的成员，但不能继承父类的（默认）和（private）成员。

11．（子类对象）直接赋值给（父类对象）时，子类对象可自动转换为父类对象，（父类对象）赋值给（子类对象）时，必须将父类对象强制转换为子类对象。

12．Java的多态性主要表现在（方法重载）、（方法覆盖）和（变量覆盖）三个方面。

13．重写后的方法不能比被重写的方法有（更严格）的访问权限，重写后的方法不能比被重写的方法产生更多的异常。

14．Java语言中，定义子类时，使用关键字（extends）来给出父类名。如果没有指出父类，则该类的默认父类为（Object类）。

15．Java语言中，重载方法的选择是在编译时进行的，系统根据（参数个数）、（参数类型）和参数顺序寻找匹配方法。

16．实现接口中的抽象方法时，必须使用（完全相同）的方法头，并且还要用（public）修饰符。

17．接口中定义的数据成员均是（常量数据成员），所有成员方法均为（抽象方法）方法，且没有（构造）方法。

18．this代表（当前对象自身）的引用，super表示的是当前对象的直接父类对象。

19．如果一个类包含一个或多个abstract方法，则它是一个（abstract）类。 20．Java不直接支持多继承，但可以通过（接口）实现多继承。类的继承具有（传递）性。

21．没有子类的类称为（最终类），不能被子类重载的方法称为（最终方法），不能改变值的量称为常量，又称为（最终变量）。

22．一个接口可以通过关键字extends来继承（多个）其他接口。

23．接口中只能包含（public static final）类型的成员变量和（public abstract）类型的成员方法。

24．一般地，内部类又分为定义在方法体外的（成员类）和定义在方法体内的（局部类）两种。

25．静态内部类可直接通过外部类名引用，其一般格式是（new 外部类名.内部类构造方法( );）。

26．匿名类一般分为（语句匿名类）和（参数匿名）类两种。

27．面向对象的软件设计中，根据目的不同模式可分为（创建型）、（结构型）和（行为型）三种。

3、选择题

1、关于被私有保护访问控制符private protected修饰的成员变量，以下说法正确的是（B ）

(A) 可以被三种类所引用：该类自身、与它在同一个包中的其他类、在其他包中的该类的子类

(B)可以被两种类访问和引用：该类本身、该类的所有子类 (C)只能被该类自身所访问和修改 (D)只能被同一个包中的类访问

2、关于被保护访问控制符protected修饰的成员变量，以下说法正确的是（A ） (A) 可以被三种类所引用：该类自身、与它在同一个包中的其他类、在其他包中的该类的子类

(B) 可以被两种类访问和引用：该类本身、该类的所有子类 (C) 只能被该类自身所访问和修改 (D) 只能被同一个包中的类访问

3、下列关于修饰符混用的说法，错误的是（ D） (A) abstract不能与final并列修饰同一个类 (B) abstract中不可以有private的成员 (C) abstract方法必须在abstract类中 (D) static方法中能处理非static的属性 4、以下标识符中哪项是不合法的 (D)

(A) BigOlLong$223 (B) _utfint (C) $12s (D) 3d 5、main方法是Java Application程序执行的入口点，关于main方法的方法头以下哪项是合法的（ B）

(A) public static void main

(B) public static void main(String[] args) (C) public static int main(String[] args) (D) public void main(String args[])

6、完以下代码int[] x = new int[5];后，以下哪项说明是正确的（A ） (A) x[4]为0 (B) x[4]未定义 (C) x[5]为0 (D) x[0]为空 7、以下代码段执行后的输出结果为（ C） int x=3; int y=8;System.out.println(y%x); (A) 0 (B) 1 (C) 2 (D) 3

8、以下哪个表达式是不合法的（ B）

(A) String x = “Sky”; int y = 5; x += y; (B) String x = “Sky”; int y = 5; if(x==y){} (C) String x = “Sky”; int y=5; x=x+y;

(D) String x = null; int y=(x!=null) && (x.length()>0)?x.length:0 9、编译运行以下程序后，关于输出结果的说明正确的是（ C）

public class Conditional{

public static void main(String args[]){ int x = 2;

System.out.println(“value is “((x<1)?2.2:2)); } }

(A) 输出结果为:value is 22.2 (B) 输出结果为：value is 2 (C) 输出结果为：value is 2.0 (C) 编译错误 10、以下声明合法的是（ B）

(A) default String s; (B) public final static native int w()

1. class StaticStuff 2. {

3. static int x=15; 4. static {x*=3;}

5. public static void main(String args[]) 6. {

7. System.out.println(“x=”+x); 8. }

9. static {x/=3;} }

(A) 4行与9行不能通过编译，因为缺少方法名和返回类型 (B) 9行不能通过编译，因为只能有一个静态初始化器 (C) 编译通过，执行结果为：x=15 (D) 编译通过，执行结果为：x=3

12、关于以下程序代码的说明正确的是（ C）

1. class HasStatic{

2. private static int x = 100;

3. public static void main(String args[]){ 4. HasStatic hs1 = new HasStatic(); 5. hs1.x++;

6. HasStatic hs2 = new HasStatic(); 7. hs2.x++;

8. hs1=new HasStatic(); 9. hs1.x++;

10. System.out.println(“x = ”+x); 11. } 12. }

(A) 5行不能通过编译，因为引用了私有静态变量 (B) 10行不能通过编译，因为x是私有静态变量 (C) 程序通过编译，输出结果为: x=103 (D) 程序通过编译，输出结果为：x=100 13、以下选项中循环结构合法的是（ C）

(A) while(int i<7){ i++;

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

}

(B) int j=3;

while(j){

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

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);

14、类Text1定义如下：(B) public class Test1{

public float aMethod(Float a, float b){} *** }

将以下哪种方法插入行 *** 是不合法的。（）

(A) public float aMethod(float a,float b,float c){} (B) public float aMethod(float c,float d){} (C) public int aMethod(int a,int b){}

(D) public float aMethod(int a,int b,int c){}

15、创建字符串s: s=new String(“xyzy”);以下哪条语句将改变s（ D） (A) s.append(“a”) (B) s.concat(s) (C) s.substring(3) (D) 以上语句都不会 16、关于以下程序段，正确的说法是（ B） String s1 = “ac”+ “def”; Strimg s2 = new String(s1); if(s1.equals(s2))

System.out.println(“==succeeded”); if(s1==s2)

System.out.println(“.equals() succeeded”); (A) 行4与行6都将执行 (B)行4执行，行6不执行 (C) 行6执行，行4不执行 (D) 行4、行6都不执行 17、关于以下代码段的说法正确的是（D ） String s = “abcde”;

StringBuffer s1 = new StringBuffer(“abcde”); if(s.equals(s1)) s1 = null;

if(s1.equals(s)) s=null;

(A) 第1行编译错误,String的构造器必须明确调用 (B) 第3行编译错误，因为s1与s2有不同的类型 (C) 编译成功，但执行时在第5行有异常抛出 (D) 编译成功，执行过程中也没有异常抛出 18、以下说法哪项是正确的（ A）

class MyListener extends MouseAdapter implements MouseListener{ public void mouseEnter(MouseEvent mev){

System.out.println(“Mouse entered.”); } }

(A) 以上代码可通过编译

(B) 不能通过编译，因为没有实现MouseListener接口中的所有方法 (C) 不能通过编译，因为类头定义不能分行

(D) 能通过编译，若组件用该类作为Mouse的监听者并且接收了mouse-exited事件，则在执行过程中会抛出异常

19、关于以下程序段的说法，正确的是（ A）

1. class MyListener implements 2. ActionListener,ItemListener{

3. public void actionPerformed(ActionEvent ae){ 4. System.out.println(“Action”);}

5. public void itemStateChanged(ItemEvent ie){ 6. System.out.println(“Item”); 7. } 8. } (A) 可通过编译

(B) 第2行产生编译错误 (C) 第3行产生编译错误 (D) 第5行产生编译错误 20、Java application中的主类需包含main方法，main方法的返回类型是什么？（ D ）

A、int B、float C、double D、void 21、有以下方法的定义，请选择该方法的返回类型（ D ）。

ReturnType method(byte x, double y)

{

return (short)x/y*2; }

A、byte B、short

C、int

D、double

22、以下哪个不是Java的关键字？（ A ） A、TRUE B、B、const C、super D、void

23、有程序如下，关于程序的描述哪个是正确的？（ A ）

public class Person{

static int a[] = new int[10];

public static void main(String a[])

{ System.out.println(arr[1]); }

}

A、编译将产生错误 C、正确，输出0

B、编译时正确，但运行时将产生错误 D、正确，输出 null

24、以下关于构造函数的描述错误的是（ A ）。 A、构造函数的返回类型只能是void型。

B、构造函数是类的一种特殊函数，它的方法名必须与类名相同。 C、构造函数的主要作用是完成对类的对象的初始化工作。 D、一般在创建新对象时，系统会自动调用构造函数。

25、有语句String s=”hello world”; ，以下操作哪个是不合法的？（ B ） A、int i=s.length(); B、s>>>=3; C、String ts=s.trim(); D、String t=s+”!”;

26、欲构造ArrayList类的一个实例，此类继承了List接口，下列哪个方法是正确的？（B）

A、ArrayList myList=new Object（） B、List myList=new ArrayList（） C、ArrayList myList=new List（）

27、指出正确的表达式（C） A、 byte=128; B、Boolean=null; C、 long l=0xfffL; D、 double=0.9239d; 28、指出下列程序运行的结果（B）

public class Example{

String str=new String(\ 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+\ Sytem.out.print(ex.ch); }

public void change(String str,char ch[]){ str=\ ch[0]='g'; } }

A、 good and abc B、good and gbc C、 test ok and abc D、test ok and gbc

29、运行下列程序, 会产生什么结果（A）

public class X extends Thread implements Runable{

public void run(){

System.out.println(\ }

public static void main(String args[]) {

Thread t=new Thread(new X()); t.start(); } }

A、第一行会产生编译错误 B、第六行会产生编译错误 C、第六行会产生运行错误 D、程序会运行和启动 30、指出下面代码那个结论是正确的？（C） public class Person{

static int arr[] = new int[10];

public static void main(String a[]) {

System.out.println(arr[1]); } }

A、编译时将产生错误； B、编译时正确，运行时将产生错误； C、输出零； D、输出空。 31、下列哪些语句关于内存回收的说明是正确的? （B） A、程序员必须创建一个线程来释放内存； B、内存回收程序负责释放无用内存 C、内存回收程序允许程序员直接释放内存 D、内存回收程序可以在指定的时间释放内存对象 32、下列代码哪几行会出错: （C）

1) public void modify() {

2) int I, j, k; 3) I = 100;

4) while ( I > 0 ) { 5) j = I * 2;

6) System.out.println (\7) k = k + 1; 8) I--; 9) } 10) }

A、 line 4 B、 line 6 C、 line 7 D、 line 8

33、Java application中的主类需包含main方法，main方法的返回类型是什么？（ D ）

A、int B、float C、double D、void 34、以下标识符中哪项是不合法的( A ) A、const B、$double C、hello BigMeaninglessName

、

35、在Java中，一个类可同时定义许多同名的方法，这些方法的形式参数个数、类型或顺序各不相同，传回的值也可以不相同。这种面向对象程序的特性称为（ C ）。

A、隐藏 B、覆盖 C、重载 D、Java不支持此特性 36、以下关于构造函数的描述错误的是（）。 A、构造函数的返回类型只能是void型。

B、构造函数是类的一种特殊函数，它的方法名必须与类名相同。 C、构造函数的主要作用是完成对类的对象的初始化工作。 D、一般在创建新对象时，系统会自动调用构造函数。 37、以下关于继承的叙述正确的是（ A ）。 A、在Java中类只允许单一继承 B、在Java中一个类只能实现一个接口

C、在Java中一个类不能同时继承一个类和实现一个接口 D、在Java中接口只允许单一继承

38、有以下方法的定义，请选择该方法的返回类型（ D ）。

ReturnType method(byte x, double y) {

return (short)x/y*2; } A、byte B、short C、int D、double 39、有以下程序片段，下列哪个选项不能插入到行1。（ D ）

2.public class Interesting{ 3.//do sth 4. }

A、import java.awt.*; B、package mypackage; C、class OtherClass{ }

D、public class MyClass{ }

40、以下哪项是接口的正确定义？（ B ） A、 interface B

{ void print() { } ;}

B、 abstract interface B

{ void print() ;}

C、 abstract interface B extends A1,A2 //A1、A2为已定义的接口

{ abstract void print(){ };}

D、 interface B

{ void print();}

41、下面哪个函数是public void aMethod(){...}的重载函数？（ D ） A、void aMethod( ){...} B、public int aMethod(){...} C、public void aMethod ( ){...} D、public int aMethod ( int m){...}

42、A派生出子类B ，B派生出子类C，并且在Java源代码中有如下声明：

（1）A a0=new A(); （2）A a1 =new B(); （3）A a2=new C();

问以下哪个说法是正确的？（） A、只有第（1）行能通过编译

B、第（1）、（2）行能通过编译，但第3行编译出错

C、第（1）、（2）、（3）行能通过编译，但第2、3行运行时出错 D、第（1）行、第（2）行和第（3）行的声明都是正确的

43、假设A类有如下定义，设a是A类的一个实例，下列语句调用哪个是错误的？（ D ）

class A { int i;

static String s; void method1() { }

static void method2() { } }

A、System.out.println(a.i)； B、a.method1(); C、A.method1();

D、A.method2()

44、有如下代码段:

2) { if(unsafe()){//do something?} 3) else if(safe()){//do the other?} 4) }

其中，方法unsafe() 将抛出IOException, 请问可将以下哪项填入第1行？（ D ）

A、 public IOException methodName() B、

public void methodName()

C、public void methodName() throw IOException D、public void methodName() throws IOException 45、下列语句序列执行后，k 的值是( )。 int m=3, n=6, k=0;

while( (m++) < ( -- n) ) ++k;

A) 0 B) 1 C) 2 D) 3 答案：B

46、设 i、j 为int型变量名，a 为int型数组名，以下选项中，正确的赋值语句是( )。

A) i = i + 2 B) a[0] = 7; C) i++ - --j; D) a(0) = 66; 答案：B

47、Java语言的类间的继承关系是( )。

A) 多重的 B) 单重的 C) 线程的 D) 不能继承答案：B

48、设有定义 int i = 6 ;，则执行以下语句后，i 的值为( )i += i - 1;

A) 10 B) 121 C) 11 D) 100 答案：C

49、下列选项中，用于在定义子类时声明父类名的关键字是( )A）interface B) package C) extends D) class 答案：C

50、若已定义 byte[ ] x= {11,22,33,-66} ;

其中0≤k≤3，则对x数组元素错误的引用是( )。 A) x[5-3] B) x[k] C) x[k+5] D) x[0] 答案：C

51、下列语句序列执行后，ch1 的值是( )。 char ch1='A',ch2='W'; if(ch1 + 2 < ch2 ) ++ch1; A) ‘A' B) ‘B' C) ‘C' D) B 答案：B

52、下列语句序列执行后，i 的值是( )。 int i=8, j=16;

if( i-1 > j ) i--; else j--; A) 15 B) 16 C) 7 D) 8 答案：A

53、下列语句序列执行后，k 的值是( )。 int i=10, j=18, k=30; switch( j - i ) { case 8 : k++; case 9 : k+=2; case 10: k+=3; default : k/=j; }

A) 31 B) 32 C) 2 D) 33 答案：A

54下面语句执行后，i 的值是( )。

for( int i=0, j=1; j < 5; j+=3 ) i=i+j; A) 4 B) 5 C) 6 D) 7

。。

答案：B

55、设有定义 float x=3.5f, y=4.6f, z=5.7f；则以下的表达式中，值为true的是( )。

A) x > y || x > z B) x != y

C) z > ( y + x ) D) x < y & ! ( x < z ) 答案：B

56、下列语句序列执行后，i的值是( )。 int i=16;

do { i/=2; } while( i > 3 ); A) 16 B) 8 C) 4 D) 2 答案：D

57、以下由 for 语句构成的循环执行的次数是( )。 for ( int i = 0; true ; i++) ; A) 有语法错，不能执行 B) 无限次 C) 执行1次 D) 一次也不执行答案：B

58、定义类头时能使用的修饰符是( )。

A) private B) static C) abstract D) protected 答案：C

59、设int 型变量 a、b，float 型变量 x、y，char 型变量 ch 均已正确定义并赋值，

正确的switch语句是( )。

A) switch (x + y) B) switch ( ch + 1 ) { ...... } { ...... } C) switch ch D) switch ( a + b ); { ...... } { ...... } 答案：D

60、下列最终属性 i 的定义中，正确的是( )。 A) static final int i=100; B) final int i=1.2; C) final i='w'; D) final char i; 答案：A

61、下列类定义中，不正确的是( )。 A) class x { .... }

B) class x extends y { .... }

C) static class x implements y1,y2 { .... } D) public class x extends Applet { .... } 答案：C

62、设 x、 y为已定义的类名，下列声明x类的对象x1的语句中正确的是( )。 A) static x x1; B) public x x1=new x(int 123); C) y x1; D) x x1=x( ); 答案：B

63、设 i、j、k 为类 x 中定义的 int 型变量名，下列类 x 的构造函数中不正确的是( )。

A) x( int m){ ... } B) void x( int m){ ... }

C) x( int m, int n){ ... } D) x( int h,int m,int n){ ... } 答案：B

64、下列方法定义中，正确的是( )。

A) int x( ){ char ch='a'; return (int)ch; } B) void x( ){ ...return true; } C) int x( ){ ...return true; } D) int x( int a, b){ return a+b; } 答案：A

65、用于定义类成员的访问控制权的一组关键字是( )。 A) class, float, double, public B) float, boolean, int, long C) char, extends, float, double D) public, private, protected 答案：D

66、不能构成循环的语句是( )。

A) for 语句 B) while 语句 C) switch 语句 D) do__while 语句答案：C

67、函数重载是指 ()

A.两个或两个以上的函数取相同的函数名，但形参的个数或类型不同

B.两个以上的函数取相同的名字和具有相同的参数个数，但形参的类型可以不同 C.两个以上的函数名字不同，但形参的个数或类型相同

D.两个以上的函数取相同的函数名，并且函数的返回类型相同 68、指出下列程序运行的结果( ) 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′; } }

A.good and abc B.good and gbc

C.test ok and abc D.test ok and gbc 答案：B

69、构造方法何时被调用( )

A.类定义时 B.创建对象时

C.调用对象方法时 D.使用对象的变量时答案：B

70、在异常处理中，如释放资源、关闭文件、关闭数据库等由( )来完成。 A.try子句 B.catch子句 C.finally子句 D.throw子句答案：C

71、运行下列程序的结果是( ) abstract class MineBase{

abstract void amethod(); static int i; }

public class Mine extends MineBase {

public static void main(String argv［］){

int［］ ar=new int［5］;

for(i=0;i System.out.println(ar［i］); } }

A.打印5个0 B.编译出错，数组ar［］必须初始化

C.编译出错，Mine应声明为abstract D.出现IndexOutOfBoundes的例外答案：C

72、在Java中，不属于整数类型变量的是( ) A.double B.long C.int D.byte 答案：A

73、Java虚拟机的执行过程有多个特点，下列哪个特点不属于JVM执行特点( ) A.多线程 B.动态连接 C.异常处理 D.异步处理答案：D

74、当方法遇到异常又不知如何处理时，下列哪种说法是正确的( ) A.捕获异常 B.抛出异常 C.声明异常 D.嵌套异常答案：B

75、Java程序的执行过程中用到一套JDK工具，其中java.exe是指( ) A.Java文档生成器 B.Java解释器 C.Java编译器 D.Java类分解器答案：B

76、Java变量中，以下不属于复合类型的数据类型是( ) A.类 B.字符型 C.数组型 D.接口答案：B

77、11.在Java中，负责对字节代码解释执行的是____。 A、垃圾回收器 B、虚拟机 C、编译器 D、多线程机制答案：B

78、下列叙述中,正确的是____。

A、Java语言的标识符是区分大小写的 B、源文件名与public类名可以不相同 C、源文件名其扩展名为.jar D、源文件中public类的数目不限答案：A

79、下列属于合法的Java标识符是____。

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

80、在 Java 中，表示换行符的转义字符是____。 A、\\n B、\\f C、'n' D、\\dd 答案：A

81、在 Java 中，由Java编译器自动导入，而无需在程序中用import导入的包是____。

A、java.applet B、java.awt C、java.util D、java.lang 答案：D

82、在 Java 中，用 package 语句说明一个包时，该包的层次结构必须是____。 A、与文件的结构相同 B、与文件目录的层次相同 C、与文件类型相同 D、与文件大小相同答案：B

83、下列构造方法的调用方式中，正确的是____。 A、按照一般方法调用 B、由用户直接调用 C、只能通过 new 自动调用 D、被系统调用答案：C

84、.int 型 public 成员变量 MAX_LENGTH，该值保持为常数100，则定义这个变量的语句是____。

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

C、public const int MAX_LENGTH=100 D、public final int MAX_LENGTH=100 答案：D

85、下列关于线程优先级的说法中，正确的是____。

A、线程的优先级是不能改变的 B、线程的优先级是在创建线程时设置的 C、在创建线程后的任何时候都可以设置 D、B 和 C 答案：C

86、下列代码中，将引起一个编译错误的行是____。

1)public class Test{ 2) int m,n;

3) public Test(){}

4) public Test(int a){m=a;}

5) public static void main(String args[]){ 6) Test t1,t2; 7) int j,k; 8) j=0;k=0;

9) t1=new Test(); 10) t2=new Test(j,k); 11) } 12) }

A、第3行 B、第5行 C、第6行 D、第10行答案：D

87、下列的哪个赋值语句是正确的？

A．char a=12; B．int a=12.0; C．int a=12.0f; D．int a=（int）12.0; 答案：D

88、下列的哪个赋值语句是不正确的？ A．float f = 11.1; B．double d = 5.3E12; C．float d = 3.14f ; D．double f=11.1E10f; 答案：A

89、下列哪个修饰符可以使在一个类中定义的成员变量只能被同一包中的类访问？

A．private B．无修饰符 C．public D．protected 答案：B

90、给出下列代码，如何使成员变量m 被方法fun（）直接访问？ class Test {

private int m;

public static void fun（） {

...

} }

A．将private int m 改为protected int m B．将private int m 改为 public int m

C．将private int m 改为 static int m D．将private int m 改为 int m 答案：C

91、已知有下列类的说明，则下列哪个语句是正确的？ public class Test {

private float f = 1.0f; int m = 12; static int n=1;

public static void main（String arg［］） {

Test t = new Test（）;

} }

A．t.f； B．this.n； C．Test.m； D．Test.f；答案：A

92、在oneMethod（）方法运行正常的情况下，程序段将输出什么? public void test（） {

try { oneMethod（）;

System.out.println（\）;

} catch （ArrayIndexOutOfBoundsException e） {

System.out.println（\）; } catch（Exception e） {

System.out.println（\）; } finally {

System.out.println（\）; } }

A．condition 1 B．condition 2 C．condition 3 D．condition 1 finally 答案：D

93、下列常见的系统定义的异常中，哪个是输入、输出异常? A．ClassNotFoundException B．IOException

C．FileNotFoundException D．UnknownHostException 答案：B

94、下列方法中哪个是执行线程的方法？

A．run（） B．start（） C．sleep（） D．suspend（）答案：A

95、下列哪个选项的java源文件代码片段是不正确的？ A．package testpackage;

public class Test{ } B．import java.io.*;

package testpackage; public class Test{ } C．import java.io.*;

class Person{ }

public class Test{ } D．import java.io.*;

import java.awt.*; public class Test{ } 答案：Bjava

11）下列哪个选项是合法的标识符？ A．123 B．_name C．class D．1first

（12）下列哪个选项是Java调试器，如果编译器返回程序代码的错误，可以用它对程序进行调试？ A．java.exe B．javadoc.exe C．jdb.exe

D．javaprof.exe

（13）下列的哪个选项可以正确用以表示八进制值8？ A．0x8 B．0x10 C．08 D．010

（14）下列的哪个赋值语句是不正确的？ A．float f = 11.1; B．double d = 5.3E12; C．float d = 3.14f ; D．double f=11.1E10f;

（15）下列的哪个赋值语句是正确的？ A．char a=12; B．int a=12.0;

C．int a=12.0f;

D．int a=（int）12.0;

（16）给出下列的代码，哪行在编译时可能会有错误？ ① public void modify（）{ ② int i, j, k; ③ i = 100;

④ while （ i > 0 ）{ ⑤ j = i * 2;

⑥ System.out.println （\）; ⑦ k = k + 1; ⑧ } ⑨ }

A．line 4 B．line 6 C．line 7 D．line 8

（17）下列关于继承的哪项叙述是正确的？ A．在java中允许多重继承

B．在java中一个类只能实现一个接口

C．在java中一个类不能同时继承一个类和实现一个接口 D．java的单一继承使代码更可靠

（18）下列哪个修饰符可以使在一个类中定义的成员变量只能被同一包中的类访问？

A．private B．无修饰符 C．public D．protected

（19）给出下列代码，如何使成员变量m 被方法fun（）直接访问？ class Test {

private int m;

public static void fun（） { ... } }

A．将private int m 改为protected int m B．将private int m 改为 public int m C．将private int m 改为 static int m D．将private int m 改为 int m

（20）已知有下列类的说明，则下列哪个语句是正确的？ public class Test {

private float f = 1.0f; int m = 12;

static int n=1;

public static void main（String arg［］） {

Test t = new Test（）; } }

A．t.f； B．this.n； C．Test.m； D．Test.f；

（21）给出下列代码，则数组初始化中哪项是不正确的？ byte［］ array1,array2［］; byte array3［］［］; byte ［］［］ array4; A．array2 = array1 B．array2=array3 C．array2=array4 D．array3=array4

（22）下列代码的执行结果是 public class Test {

public int aMethod（） {

static int i=0; i++;

System.out.println（i）; }

public static void main（String args［］） {

Test test = new Test（）; test.aMethod（）; } }

A．编译错误 B．0 C．1

D．运行成功，但不输出

（23）下列关于内部类的说法不正确的是

A．内部类的类名只能在定义它的类或程序段中或在表达式内部匿名使用 B．内部类可以使用它所在类的静态成员变量和实例成员变量 C．内部类不可以用abstract修饰符定义为抽象类

D．内部类可作为其他类的成员，而且可访问它所在类的成员（24）顺序执行下列程序语句后，则b的值是

String a=\

String b=a.substring（0,2）; A．Hello B．hello C．Hel D．null

（25）在oneMethod（）方法运行正常的情况下，程序段将输出什么? public void test（） {

try { oneMethod（）;

System.out.println（\）; } catch （ArrayIndexOutOfBoundsException e） {

System.out.println（\）; } catch（Exception e） {

System.out.println（\）; } finally {

System.out.println（\）; } }

A．condition 1 B．condition 2 C．condition 3 D．condition 1 finally

（26）下列常见的系统定义的异常中，哪个是输入、输出异常? A．ClassNotFoundException B．IOException

C．FileNotFoundException D．UnknownHostException

（27）下列哪个不是nio包的新特点？ A．内存映射技术 B．文件锁定 C．字符及编码

D．阻塞I/O

（28）下列哪个选项是正确计算42度（角度）的余弦值？ A．double d=Math.cos（42）; B．double d=Math.cosine（42）;

C．double d=Math.cos（Math.toRadians（42））; D．double d=Math.cos（Math.toDegrees（42））; （29）下列InputStream类中哪个方法可以用于关闭流？ A．skip（） B．close（） C．mark（） D．reset（）

（30）下列方法中哪个是执行线程的方法？ A．run（） B．start（） C．sleep（） D．suspend（）

（33）在Applet的关键方法中，下列哪个方法是关闭浏览器以释放Applet占用的所有资源？ A．init（） B．start（） C．paint（） D．destroy（）

（35）下列哪个选项的java源文件代码片段是不正确的？ A．package testpackage; public class Test{ } B．import java.io.*; package testpackage; public class Test{ } C．import java.io.*; class Person{ } public class Test{ } D．import java.io.*; import java.awt.*; public class Test{ }

四、程序阅读

1、阅读以下程序，输出结果为。(21) class D{

public static void main(String args[]){

int d=21;

Dec dec=new Dec( ); dec.decrement(d);

System.out.println(d); }

classs Dec{

public void decrement(int decMe){ decMe = decMe － 1; } }

2、以下程序的输出结果为。(结果为: Boy) public class Short{

public static void main(String args[ ]) { StringBuffer s = new StringBuffer(“Boy”);

if((s.length( )<3)&& (s.append(“男孩”) . equals(“False”))); System.out.println(“结果为: ”+s); } }

3、以下程序段的输出结果为。(Message four) int x=0,y=4, z=5; if ( x>2){

if (y<5){

System.out.println(“Message one”); }

else {

System.out.println(“Message two”); } }

else if(z>5){

System.out.println(“Message three”); }

else {

System.out.println(“Message four”); }

4、以下程序段的输出结果为。(two.three.) int j=2;

switch ( j ) {

case 2:

System.out.print(“two.”); case 2+1 :

System.out.println(“three.”); break; default:

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

}

5、以下程序段的输出结果为。(int) class Cruncher{

void crunch( int i ){

System.out.println(“int”); }

void crunch(String s){

System.out.println(“String”); }

public static void main(String args[ ]){

Cruncher crun=new Cruncher ( ); char ch=’p’; crun.crunch(ch); } }

6、阅读以下程序，写出输出结果。(99) class Q6{

public static void main(String args[ ]){

Holder h=new Holder( ); h.held=100; h.bump(h);

System.out.println(h.held); } }

class Holder{

public int held;

public void bump(Holder theHolder){

theHolder.held - -; } }

7、阅读以下程序，请写出输出结果。(true) public class EqualsMethod {

public static void main(String[] args) {

Integer n1 = new Integer(47); Integer n2 = new Integer(47);

System.out.println(n1.equals(n2)); } }

8、阅读以下程序： class Exp1 {

public static void main(String[] args) {

String s,s1=\

char c;

s=args[0];

for (int i=0;i

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

s1=s1+Character.toUpperCase(c); }else{

s1=s1+Character.toLowerCase(c); }

}

System.out.println(s1);

}

若在dos命令行输入：java Exp1 cHINA，则输出China 。

9、阅读以下程序： import java.io.*;

public class AboutFile{

public static void main(String[ ] args)throws IOException{ BufferedReader b=new BufferedReader

(new InputStreamReader(System.in));

String s;

System.out.flush(); s=b.readLine();

System.out.println(“String is:”+s); } }

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

则输出结果为 String is： java 。 10、程序段的输出结果为。 public class C {

public static void main(String args[ ]){ int i , j ;

int a[ ] = { 5,1,3,9,7}; for ( i = 0 ; i < a.length-1; i ++ ) {

int k = i; for ( j = i ; j < a.length ; j++ ) if ( a[j]

为

System.out.println( ); } }

11、以下程序，写出输出结果 Animal Cat 。 class Animal { Animal() {

System.out.print (\}

public class Cat extends Animal { Cat() {

System.out.print (\

public static void main(String[] args) { Cat kitty= new Cat(); } } 12、阅读以下程序，输出结果为 1 。import java.io.*; public class ATest{

public static void main(String args[]) { SubClass sb = new SubClass( ); System.out.println(sb.funOfMod( )); } }

class SuperClass{

int a = 10 , b = -3 ; }

class SubClass extends SuperClass{ int funOfMod( ) { return a%b; } } 13、以下程序段的输出结果为 int, int class Cruncher{

void crunch( int i ){

System.out.print(“int”); }

void crunch(String s){

System.out.print(“String”); }

public static void main(String args[ ]){

Cruncher crun=new Cruncher ( ); char ch=’h’; int i=12;

crun.crunch(ch);//应该是返回ASCII码的值 System.out.print(“,”); crun.crunch(i);}

}

。

14、阅读以下程序，输出结果为 cooljava 。 import java.io.*;

public class TestString

{ public static void main(String args[ ])

{ StringC s = new StringC (\ System.out.println(s); } }

class StringC { String s1; String s2;

StringC( String str1 , String str2 ) { s1 = str1; s2 = str2; } public String toString( ) { return s1+s2;} } 15、写出以下程序的运行结果为 s1!=s2 。 class StringTest1 { public static void main(String[] args)

{

String s1=\

String s2=new String(\ if(s1==s2){

System.out.println(\ }else{

System.out.println(\ } }

以下程序的运行结果。false false 16、

public class EqualOrNot

{ public static void main(String[] args)

{ B b1=new B(5); B b2=new B(5);

System.out.println(b1==b2);

System.out.println(b1.equals(b2)); } }

class B { int x;

B( int y){ x=y; } } 17、写出以下程序的运行结果。hello world import java.io.*;

public class TestString

{ public static void main(String args[ ])

{ StringC s = new StringC (\ System.out.println(s); } }

class StringC { String s1; String s2;

StringC( String str1 , String str2 ) { s1 = str1; s2 = str2; } public String toString( ) { return s1+s2;} } 18、写出以下程序的功能。 class Test

{ public static void main(String[] args) { String s; char c;

int upper,lower; upper=lower=0; s=args[0];

for (int i=0;i

if(c>='a' && c<='z') lower++;

if(c>='A' && c<='Z') upper++; System.out.println(upper+”,”+lower); } }

写出以下程序的运行结果。

no1 no2 no3

19、 no1 no3

import java.util.*; public class Vec{

public static void main(String[] args) { String[] s; s=new String[2];

s[0]=new String(\ s[1]=new String(\ Vector v = new Vector();

for(int i = 0; i <2; i++) v.addElement(s[i]);

v.insertElementAt(new String(\ Enumeration e = v.elements(); while(e.hasMoreElements())

System.out.print(e.nextElement()+\

}

System.out.println(); v.removeElement(\

for(int i = 0; i < v.size() ; i++)

System.out.print(v.elementAt(i) +\ System.out.println(); } } 20、写出以下程序的运行结果。 class StaticTest {

static int x=1; int y;

StaticTest() { y++; }

public static void main(String args[ ]){ StaticTest st=new StaticTest(); System.out.println(\

System.out.println(\ st=new StaticTest();

System.out.println(\ }

static { x++;} }

x=2 st.y=1 st.y=1

21、阅读以下程序，写出输出结果。 class First{

public First(){ aMethod(); }

public void aMethod(){

System.out.println(“in First class”);} }

public class Second extends First{

public Second(){ aMethod(); } public void aMethod(){

System.out.println(“in Second class”);}

public static void main(String[ ] args){ new Second( ); } } 22、写出以下程序的运行结果。 public class A {

public static void main(String[ ] args) { System.out.println( test(15,26,4) ); }

{ { static int test(int x, int y, int z) return test( x, test(y,z) ); } static int test(int x,int y) if(x>y) return x; else return y; }

} 26 23、写出以下程序的运行结果。

5.0

Caught negative

class MyException extends Exception{

public String toString( ){ return \}

public class ExceptionDemo{

public static void mySqrt(int a) throws MyException { if( a<0 ) throw new MyException(); System.out.println(Math.sqrt(a)); }

public static void main( String args[] ){ try{ mySqrt(25 ); mySqrt(-5 ); }

catch( MyException e ){ System.out.println(\ } } 24、写出以下程序的功能。5 4 3 2 1 public class TestArray

{ public static void main(String args[ ]){ int i , j ;

int a[ ] = {1,3,2,5,4}; 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

25、下面是一个排序的程序: import java.io.*;

public class Test56_Sort {

public static void main(String args[ ]) {

int[] a={42,99,5,63,95,36,2,69,200,96}; System.out.println(排序前的数据序列:); ShowArray(a); Sort(a);

System.out.println(排序后的数据序列:); ShowArray(a); }

public static void Sort(int[] x) {

int w;

for(int i=1; i

for(int j=0; jx[j+1])

{ w=x[j]; x[j]=x[j+1]; x[j+1]=w; } /* if(i==1||i==2) ShowArray(x); if(i==2) break; */ } }

public static void ShowArray(int b[]) {

for(int i=0; i