Java程序设计基础练习题1_动视

Java程序设计基础练习题1

2025-09-27 16:18:03 责编:小OO

点击下载本文 文档为doc格式

一、判断题

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、ava的类不允许多重继承，但接口支持多重继承。（ Y ）

23、谓抽象类就是包含有抽象方法的类。（ Y ）

24、ava语言中的数组元素只能是基本数据类型而不能为对象类型。（ 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．静态初始化器是在其所属的类加载内存时由系统自动调用执行。（√）

32．所有的鼠标事件都由MouseListener监听接口的监听者来处理。（×）

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

34．abstract方法所在的类必须是abstract类。（√）

35．java异常处理中可以使用多个catch子句,此时应将高级别异常类的catch子句放在前面。 (×)

36．设String对象s="H运行语句System.out.println(s.concat("ello!"));后String对象s的内容为"Hello!所以语句输出为"Hello!"。 (× )

37．Java有两类程序:Java Application和Java Applet,其中Java Applet程序只能在图形界面中工作,而Java Application程序只能在字符界面中工作。( ×)

38．通过继承，父类中的保护成员在派生类中不能被直接访问。( ×)

protect访问权限定义了子类，同包和本类可以访问！

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

40．子类继承父类后，如果出现子类的成员变量名和父类的成员变量名同名，那么子类就不继承父类的这个成员变量了。( ×)

overload只针对方法，不针对成员变量

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．抽象类不能实例化。（√）

54．在Swing用户界面的程序设计中，容器可以被添加到其它容器中去。（√）

55．在Java语言中，drawOval(100,100,80,80)表示绘制圆，其中（100，100）表示圆心。

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

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

58．Java语言具有较好的安全性和可移植性及与平台无关等特性。（ √ ）

59.Java语言的源程序不是编译型的，而是编译解释型的。（ √ ）

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

61.java.util.Scanner(System.in)可以接收用户从键盘输入的简单数据。（ √ ）

62.Java程序中不区分大小写字母。（ × ）

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

.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="abcdefghi"; 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="abcedf"; int length=str.length; （ × ）

78.short shortValue=220; byte byteValue=shortValue; （ × ）

79.int[] intArray[60]; （ × ）

80.char[] str="abcdefgh"; （ × ）

81.说明或声明数组时不分配内存大小,创建数组时分配内存大小。（ √ ）

82.强制类型转换运算符的功能是将一个表达式的类型转换为所指定的类型。（ √ ）

83．类是一种类型，也是对象的模板。（ √ ）

84．类中说明的方法可以定义在类体外。（ × ）

85．实例方法中不能引用类变量。（ × ）

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

87．使用运算符new创建对象时，赋给对象的值实际上是一个引用值。（ √ ）

88．对象赋值实际上是同一个对象具有两个不同的名字，它们都有同一个引用值。（ √ ）

．对象可作方法参数，对象数组不能作方法参数。（ × ）

90．class是定义类的惟一关键字。（ √ ）

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

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

93．抽象方法是一种只有说明而无具体实现的方法。（ √ ）

94．Java语言中，所创建的子类都应有一个父类。（ √ ）

95．调用this 或super构造方法的语句必须放在第一条语句。（ √ ）

96．一个类可以实现多个接口，接口可以实现“多重继承”。（ √ ）

97．实现接口的类不能是抽象类。（ √ ）

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

99．Java 语言不允许同时继承一个类并实现一个接口。（ × ）

100．Java语言中，构造方法是不可以继承的。（ √ ）

101．Map接口是自Collection接口继承而来。（ × ）

102．集合Set是通过键-值对的方式来存储对象的。（ × ）

103．Integer i = (Integer.valueOf("926")).intValue();（ √ ）

104．String s = (Double.valueOf("3.1415926")).toString(); （ √ ）

105．Integer I = Integer.parseInt("926");（ √ ）

106．Arrays类主要对数组进行操作。（ √ ）

107．在集合中元素类型必须是相同的。（ √ ）

108．集合中可以包含相同的对象。（ × ）

109．枚举接口定义了具有删除功能的方法。（ × ）

110．容器是用来组织其他界面成分和元素的单元，它不能嵌套其他容器。（ × ）

111．一个容器中可以混合使用多种布局策略。（ × ）

112．在Swing用户界面的程序设计中，容器可以被添加到其他容器中去。（ √ ）

113．使用BorderLayout布局管理器时，GUI组件可以按任何顺序添加到面板上。（ √ ）

114．在使用BorderLayout时，最多可以放入五个组件。（ √ ）

115．每个事件类对应一个事件接口，每一个接口都有相对应的适配器。（ × ）

116．Java中，并非每个事件类都只对应一个事件。（ √ ）

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

118．使用try-catch-finally语句只能捕获一个异常。（ × ）

119．try-catch语句不可以嵌套使用。（ × ）

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

121．IOException异常是非运行时异常，必须在程序中抛弃或捕获。（ √ ）

122．用户自定义异常类是通过继承Throwable类来创建的。（ × ）

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

124．一个Java多线程的程序不论在什么计算机上运行，其结果始终是一样的。（ × ）

125．Java线程有五种不同的状态，这五种状态中的任何两种状态之间都可以相互转换。（ × ）

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。（ √ ）

135．对象串行化机制是指将程序中对象的状态转化为一个字节流，存储在文件中。（ √ ）

136．Serializable接口是个空接口，它只是一个表示对象可以串行化的特殊标记。（ √ ）

二、填空题

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%13

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("Tom",3);

　　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("%d,%d,%d", a, i, j);

9．执行完boolean x=false; boolean y=true; boolean z=(x&&y)&&(!y) ; int f=z==false?1:2;

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

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

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

3．模型应具有（抽象性）、（可理解性）、（精确性）、（确定性）和廉价性等基本特性。

4．UML定义了（用例图）、（静态图）、（交互图）、行为图和实现图五类模型图。

5．在UML类图中分别用（ + ）、（ # ）、（ ~ ）和（ - ）表示属性与方法的公有、保护、默认和私有访问控制权限。

6．在UML中，类之间主要有（关联）、（依赖）、（聚集）、（泛化）和实现五种关系。

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．面向对象的软件设计中，根据目的不同模式可分为（创建型）、（结构型）和（行为型）三种。

1．Swing的事件处理机制包括（事件源）、事件和事件监听者。

2．Java事件处理包括建立事件源、（建立事件）和将事件源注册到。

3．在Swing中，可以根据不同用户的习惯，设置不同的界面显示风格，Swing提供了三种显示风格，分别是（Metal风格）风格、（ Motif风格）风格和（Windows风格）风格。

4．Swing的顶层容器有（JFrame）、JApplet、JWindow和JDialog。

5．（根面板）由一个玻璃面板、一个内容面板和一个可选择的菜单条组成。

1．URL类的类包是（java.net.URL）。

2．URL.getFile()方法的作用是（获得URL实例的文件名）。

3．URL.getPort()方法的作用是（获得URL实例的端口号）。

4．Sockets技术是构建在（ TCP ）协议之上。

5．Datagrams技术是构建在（ UDP ）协议之上。

6．ServerSocket.accept()返回（ Socket ）对象，使服务器与客户端相连。

7．为了实现组播通信，java.net包中有相应的（ MulticastSocket ）类。

8．RMI的英文全称是（ Remote Method Invocation，远程方法调用）。

9．启动RMIRegistry服务器的命令是（ Start RMIRegistry ）。

1．JDBC的基本层次结构由（Java程序）、（ JDBC API）、（JDBC驱动程序管理器）、（驱动程序）和数据库五部分组成。

2．根据访问数据库的技术不同，JDBC驱动程序相应地分为（JDBC-ODBC Bridge）、（JDBC-Native API Bridge）、（ JDBC-Middleware）和（Pure JDBC Driver）四种类型。

3．JDBC API所包含的接口和类非常多，都定义在（java.sql）包和（javax.sql）包中。

4．使用（Class.forName( )）方法加载和注册驱动程序后，由（DriverManager）类负责管理并跟踪JDBC驱动程序，在数据库和相应驱动程序之间建立连接。

5．（java.spl.Connection）接口负责建立与指定数据库的连接。

6．（PreparedStatement）接口的对象可以代表一个预编译的SOL语句，它是（Statement）接口的子接口。

7．（ResultSet）接口表示从数据库中返回的结果集。

三、选择题

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

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

(B)可以被两种类访问和引用：该类本身、该类的所有子类

(C)只能被该类自身所访问和修改

(D)只能被同一个包中的类访问

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

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

(B) 可以被两种类访问和引用：该类本身、该类的所有子类

(D) 只能被同一个包中的类访问

3、下列关于修饰符混用的说法，错误的是（ D）

(A) abstract不能与final并列修饰同一个类

(B) abstract中不可以有private的成员

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

(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){}

(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

10、以下声明合法的是（ B）

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

11、关于以下application的说明，正确的是（ C）

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行不能通过编译，因为只能有一个静态初始化器

(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是私有静态变量

(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){}

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

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不执行

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有不同的类型

(D) 编译成功，执行过程中也没有异常抛出

18、以下说法哪项是正确的（ A）

class MyListener extends MouseAdapter implements MouseListener{

public void mouseEnter(MouseEvent mev){

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

}

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

(B) 不能通过编译，因为没有实现MouseListener接口中的所有方法

(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行产生编译错误

(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、编译将产生错误 B、编译时正确，但运行时将产生错误

C、正确，输出0 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("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 ");

　　　　Sytem.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

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

public class X extends Thread implements Runable{

　public void run(){

System.out.println("this is run()");

　}

　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 (" The value of j is " + j );

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 D、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

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

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

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

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（"condition 1"）;

} catch （ArrayIndexOutOfBoundsException e）

{

System.out.println（"condition 2"）;

} catch（Exception e）

{

System.out.println（"condition 3"）;

} finally

{

System.out.println（"finally"）;

}

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

四、程序阅读

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 { 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 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] int temp =a[i];

a[i] = a[k];

a[k] = temp;

}

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

System.out.println( );

}

11、以下程序，写出输出结果 Animal Cat 。

class Animal {

Animal() {

System.out.print ("Animal "); }

}

public

class Cat extends Animal {

Cat() {

System.out.print ("Cat "); }

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 ("cool

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="hello";

String s2=new String("hello");

if(s1==s2){

System.out.println("s1==s2");

}else{

System.out.println("s1!=s2");}

}

以下程序的运行结果。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 ("hello

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 { c=s.charAt(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("no1");

s[1]=new String("no2");

Vector v = new Vector();

for(int i = 0; i <2; i++)

v.addElement(s[i]);

v.insertElementAt(new String("no3"),2);

Enumeration e = v.elements();

while(e.hasMoreElements())

System.out.print(e.nextElement()+" ");

System.out.println();

v.removeElement("no2" );

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("x=" + x);

System.out.println("st.y=" + st.y);

st=new StaticTest();

System.out.println("st.y=" + st.y);

}

static { x++;}

}

x=2

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

}

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

5.0

Caught negative

class MyException extends Exception{

public String toString( ){ return "negative"; }

}

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("Caught "+e); }

}

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 System.out.print(a[i]+" ");

System.out.println( );

}

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; jif(x[j]>x[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; iSystem.out.print(b[i] +" ");

System.out.println( );

}

排序前的数据序列:

42 99 5 63 95 36 2 69 200 96

排序后的数据序列:

2 5 36 42 63 69 95 96 99 200

问题：如果将方法Sort( )中的一对注释符（/* */）去掉，程序输出的结果是什么?

26、请写下程序的输出结果：

public class Test52

{

String str1=Hello, Java world! \;

String str2=Hello, students! ;

public static void main(String args[])

{

System.out.print(str1);

System.out.println(str2);

}

输出结果：Hello, Java world! Hello, students!

27、请写下程序的输出结果：

public class T2_4 {

public static void main(String[] args)

{

int i,j;

char c='*';

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

{

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

System.out.print("* ");

System.out.println();

}

输出结果：

* *

* * *

* * * *

* * * * *

28、请写下程序的输出结果：

x>y==false

z>w==true

public class ex2_2

{

public static void main (String args[ ] )

{

int x , y ;

byte b = 6;

float z = 1.234f ;

double w = 1.23;

boolean flag;

x = 12 ;

y = 300;

flag=x>y;

System.out.println("x>y=="+flag);

flag=z>w;

System.out.println("z>w=="+flag);

}

五、编程题

1、编写一个完整的Java Application 程序。包含接口ShapeArea，MyRectangle类及Test类，具体要求如下：

⑴接口ShapeArea：

double getArea()：求一个形状的面积

double getPerimeter ()：求一个形状的周长

⑵类 MyRectangle：

实现ShapeArea接口，另有以下属性和方法：

1属性

width： double类型，表示矩形的长

height： double类型，表示矩形的高

2方法

MyRectangle(double w, double h)：构造函数

toString()方法：输出矩形的描述信息，如“width=1.0,height=2.0, perimeter=6.0, area=2.0”

⑶Test类作为主类要完成测试功能

1生成MyRectangle对象

② 调用对象的toString方法，输出对象的描述信息

2、编写一个完整的Java Application 程序，包括ShapeArea接口、MyTriangle类、Test类，具体要求如下：

⑴接口ShapeArea：

double getArea()：求一个形状的面积

double getPerimeter ()：求一个形状的周长

⑵类MyTriangle：

实现ShapeArea接口，另有以下属性和方法：

1属性

x,y,z: double型，表示三角形的三条边

s: 周长的1/2（注：求三角形面积公式为，s=(x+y+z)/2 ，开方可用Math.sqrt(double)方法）

2方法

MyTriangle(double x, double y, double z)：构造函数，给三条边和s赋初值。

toString()：输出矩形的描述信息，如“three sides:3.0,4.0,5.0,perimeter=12.0,area=6.0”

⑶Test类作为主类要完成测试功能

2生成MyTriangle对象

② 调用对象的toString方法，输出对象的描述信息

五、问答题：

1、Java的接口和C++的虚类的相同和不同处。

　　由于Java不支持多继承，而有可能某个类或对象要使用分别在几个类或对象里面的方法或属性，现有的单继承机制就不能满足要求。与继承相比，接口有更高的灵活性，因为接口中没有任何实现代码。当一个类实现了接口以后，该类要实现接口里面所有的方法和属性，并且接口里面的属性在默认状态下面都是 public static，所有方法默认情况下是public.一个类可以实现多个接口。

2、垃圾回收的优点和原理。并考虑2种回收机制。

　　Java语言中一个显著的特点就是引入了垃圾回收机制，使c++程序员最头疼的内存管理的问题迎刃而解，它使得Java程序员在编写程序的时候不再需要考虑内存管理。由于有个垃圾回收机制，Java中的对象不再有“作用域”的概念，只有对象的引用才有“作用域”。垃圾回收可以有效的防止内存泄露，有效的使用可以使用的内存。垃圾回收器通常是作为一个单独的低级别的线程运行，不可预知的情况下对内存堆中已经死亡的或者长时间没有使用的对象进行清楚和回收，程序员不能实时的调用垃圾回收器对某个对象或所有对象进行垃圾回收。回收机制有分代复制垃圾回收和标记垃圾回收，增量垃圾回收。

3、谈谈final， finally， finalize的区别。

　　final－修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为final的方法也同样只能使用，不能重载。

　　finally－再异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的 catch 子句就会执行，然后控制就会进入 finally 块（如果有的话）。

　　finalize－方法名。Java 技术允许使用 finalize（）方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖 finalize（）方法以整理系统资源或者执行其他清理工作。finalize（）方法是在垃圾收集器删除对象之前对这个对象调用的。

4、数组有没有length（）这个方法？ String有没有length（）这个方法？举例说明使用方法？

　　数组没有length（）这个方法，有length的属性。

　　String有有length（）这个方法。

5、Java中的异常处理机制的简单原理和应用。

　　当JAVA程序违反了JAVA的语义规则时，JAVA虚拟机就会将发生的错误表示为一个异常。违反语义规则包括2种情况。一种是JAVA类库内置的语义检查。例如数组下标越界，会引发IndexOutOfBoundsException；访问null的对象时会引发 NullPointerException.另一种情况就是JAVA允许程序员扩展这种语义检查，程序员可以创建自己的异常，并自由选择在何时用 throw关键字引发异常。所有的异常都是java.lang.Thowable的子类。

6、请说出你所知道的线程同步的方法。

　　wait（）：使一个线程处于等待状态，并且释放所持有的对象的lock.

　　sleep（）：使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException异常。

　　notify（）：唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且不是按优先级。

　　Allnotity（）：唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。

7、String s = new String("xyz");创建了几个String Object?

答案：两个对象，一个是“xyx”,一个是指向“xyx”的引用对象s。

8、Math.round(11.5)等於多少? Math.round(-11.5)等於多少?

答案： Math.round(11.5)返回（long）12，Math.round(-11.5)返回（long）-11;

9、short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错?

　　答案：short s1 = 1; s1 = s1 + 1;有错，s1是short型，s1+1是int型,不能显式转化为short型。可修改为s1 =(short)(s1 + 1) 。short s1 = 1; s1 += 1正确。

10、数组有没有length()这个方法? String有没有length()这个方法？

　　答案：数组没有length()这个方法，有length的属性。

　　 String有有length()这个方法。

11、Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型?

　　答案：方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型。

12、error和exception有什么区别?

　　答案：error 表示恢复不是不可能但很困难的情况下的一种严重问题。比如说内存溢出。不可能指望程序能处理这样的情况。

　　 exception 表示一种设计或实现问题。也就是说，它表示如果程序运行正常，从不会发生的情况。

13、abstract class和interface有什么区别?

　　答案：声明方法的存在而不去实现它的类被叫做抽象类（abstract class），它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。不能创建abstract 类的实例。然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。不能有抽象构造函数或抽象静态方法。Abstract 类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类为。取而代之，在子类中实现该方法。知道其行为的其它类可以在类中实现这些方法。

　　接口（interface）是抽象类的变体。在接口中，所有方法都是抽象的。多继承性可通过实现这样的接口而获得。接口中的所有方法都是抽象的，没有一个有程序体。接口只可以定义static final成员变量。接口的实现与子类相似，除了该实现类不能从接口定义中继承行为。当类实现特殊接口时，它定义（即将程序体给予）所有这种接口的方法。然后，它可以在实现了该接口的类的任何对象上调用接口的方法。由于有抽象类，它允许使用接口名作为引用变量的类型。通常的动态联编将生效。引用可以转换到接口类型或从接口类型转换，instanceof 运算符可以用来决定某对象的类是否实现了接口。

14、接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承实体类(concrete class)?

　　答案：接口可以继承接口。抽象类可以实现(implements)接口，抽象类是否可继承实体类，但前提是实体类必须有明确的构造函数。

15、构造器Constructor是否可被override?

答案：构造器Constructor不能被继承，因此不能重写Overriding，但可以被重载Overloading。

16、是否可以继承String类?

　　答案：String类是final类故不可以继承。

16、try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，在return前还是后?

　　答案：会执行，在return前执行。

18、JAVA语言如何进行异常处理，关键字：throws,throw,try,catch,finally分别代表什么意义？在try块中可以抛出异常吗？

答案：Java通过面向对象的方法进行异常处理，把各种不同的异常进行分类，并提供了良好的接口。在Java中，每个异常都是一个对象，它是Throwable类或其它子类的实例。当一个方法出现异常后便抛出一个异常对象，该对象中包含有异常信息，调用这个对象的方法可以捕获到这个异常并进行处理。Java的异常处理是通过5个关键词来实现的：try、catch、throw、throws和finally。一般情况下是用try来执行一段程序，如果出现异常，系统会抛出（throws）一个异常，这时候你可以通过它的类型来捕捉（catch）它，或最后（finally）由缺省处理器来处理。

用try来指定一块预防所有"异常"的程序。紧跟在try程序后面，应包含一个catch子句来指定你想要捕捉的"异常"的类型。

throw语句用来明确地抛出一个"异常"。

throws用来标明一个成员函数可能抛出的各种"异常"。

Finally为确保一段代码不管发生什么"异常"都被执行一段代码。

可以在一个成员函数调用的外面写一个try语句，在这个成员函数内部写另一个try语句保护其他代码。每当遇到一个try语句，"异常"的框架就放到堆栈上面，直到所有的try语句都完成。如果下一级的try语句没有对某种"异常"进行处理，堆栈就会展开，直到遇到有处理这种"异常"的try语句。

19、一个".java"源文件中是否可以包括多个类（不是内部类）？有什么？

答案：可以。必须只有一个类名与文件名相同。

29、java中实现多态的机制是什么？

答案：方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。

21、静态变量和实例变量的区别

答案：static i = 10; //常量 class A a; a.i =10;//可变

22、JAVA语言如何进行异常处理，关键字：throws,throw,try,catch,finally分别代表什么意义？在try块中可以抛出异常吗？

　　用try来指定一块预防所有"异常"的程序。紧跟在try程序后面，应包含一个catch子句来指定你想要捕捉的"异常"的类型。

　　throw语句用来明确地抛出一个"异常"。

　　throws用来标明一个成员函数可能抛出的各种"异常"。

　　Finally为确保一段代码不管发生什么"异常"都被执行一段代码。

23、java中实现多态的机制是什么？

24、作用域public,private,protected,以及不写时的区别

　　答案：区别如下：

　　作用域当前类同一package 子孙类其他package

　　public √ √ √ √

　　protected √ √ √ ×

　　friendly √ √ × ×

　　private √ × × ×

　　不写时默认为friendly

25、abstract class和interface有什么区别

26、用最有效率的方法算出2乘以8等於几

　　答案：2 << 3

27、float型float f=3.4是否正确?

答案：不正确。精度不准确,应该用强制类型转换，如下所示：float f=(float)3.4; float f = 3.4f;

28、STRING与STRINGBUFFER的区别。

　　答案：STRING的长度是不可变的，STRINGBUFFER的长度是可变的。如果你对字符串中的内容经常进行操作，特别是内容要修改时，那么使用StringBuffer，如果最后需要String，那么使用StringBuffer的toString()方法

29、面向对象的特征有哪些方面

　　答案：主要有以下四方面：

　　（1）.抽象：抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。

　　（2）.继承：继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。

　　（3）.封装：封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。

　　（4）. 多态性：多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。

30、String是最基本的数据类型吗

　　答案：不是，基本数据类型包括byte、int、char、long、float、double、boolean和short。

　　java.lang.String类是final类型的，因此不可以继承这个类、不能修改这个类。为了提高效率节省空间，我们应该用StringBuffer类

31、JAVA代码查错

abstract class Name {

private String name;

public abstract boolean isStupidName(String name) {}

}

答案：错。abstract method必须以分号结尾，且不带花括号。

32、JAVA代码查错

abstract class Something {

private abstract String doSomething ();

}

答案：错。abstract的methods不能以private修饰。abstract的methods就是让子类implement(实现)具体细节的，不可以用private把abstract method封锁起来呢? (同理，abstract method前不能加final)。

33、JAVA代码查错

public class Something {

public int addOne(final int x) {

return ++x;

}

答案：错。int x被修饰成final，意味着x不能在addOne method中被修改。

34、JAVA代码查错

class Something {

final int i;

public void doSomething() {

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

}

答案：错。final int i是个final的instant variable (实例变量，或叫成员变量)。final的instant variable没有default value，必须在constructor (构造函数)结束之前被赋予一个明确的值。可以修改为"final int i = 0;"。

35、JAVA代码查错

public class Something {

public static void main(String[] args) {

Something s = new Something();

System.out.println("s.doSomething() returns " + doSomething());

}

public String doSomething() {

return "Do something ...";

}

答案：错。看上去在main里call doSomething没有什么问题，毕竟两个methods都在同一个class里。但仔细看，main是static的。static method不能直接call non-static methods。可改成"System.out.println("s.doSomething() returns " + s.doSomething());"。同理，static method不能访问non-static instant variable。下载本文

显示全文

全部频道