一、判断题
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中的解释器边解释边执行。（√）
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="abcdefghi"; char chr=str.charAt(9); （×）
74.char[] chrArray={ 'a', 'b', 'c', 'd', 'e', 'f', 'g'}; char ch r=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．对象赋值实际上是同一个对象具有两个不同的名字，它们都有同一个引用值。（√）
89．对象可作方法参数，对象数组不能作方法参数。（×）
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子类创建线程的优点是可以在子类中增加新的成员变量，使线程具有某种属性，也可以在子类中新增加方法，使线程具有某种功能。但是，J ava不支持多继承，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的值为（f alse）。
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语句引入的包是（j https://www.doczj.com/doc/698542110.html,ng）。
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）、（protec ted）和（默认）成员，将其作为子类的成员，但不能继承父类的（private）成员。
10．若子类和父类不在同一个包中，则子类继承了父类中的（public）和（p rotected）成员，将其作为子类的成员，但不能继承父类的（默认）和（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 a bstract）类型的成员方法。
24．一般地，内部类又分为定义在方法体外的（成员类）和定义在方法体内的（局部类）两种。
25．静态内部类可直接通过外部类名引用，其一般格式是（new 外部类名.内部类构造方法( );）。
26．匿名类一般分为（语句匿名类）和（参数匿名）类两种。
27．面向对象的软件设计中，根据目的不同模式可分为（创建型）、（结构型）和（行为型）三种。
1．Swing的事件处理机制包括（事件源）、事件和事件监听者。
2．Java事件处理包括建立事件源、（建立事件监听器）和将事件源注册到监听器。
3．在Swing中，可以根据不同用户的习惯，设置不同的界面显示风格，Swin g提供了三种显示风格，分别是（Metal风格）风格、（Motif风格）风格和（W indows风格）风格。
4．Swing的顶层容器有（JFrame）、JApplet、JWindow和JDialog。
5．（根面板）由一个玻璃面板、一个内容面板和一个可选择的菜单条组成。
1．URL类的类包是（https://www.doczj.com/doc/698542110.html,.URL）。
2．URL.getFile()方法的作用是（获得URL实例的文件名）。
3．URL.getPort()方法的作用是（获得URL实例的端口号）。
4．Sockets技术是构建在（TCP）协议之上。
5．Datagrams技术是构建在（UDP）协议之上。
6．ServerSocket.accept()返回（Socket）对象，使服务器与客户端相连。
7．为了实现组播通信，https://www.doczj.com/doc/698542110.html,包中有相应的（MulticastSocket）类。
8．RMI的英文全称是（Remote Method Invocation，远程方法调用）。
9．启动RMIRegistry服务器的命令是（Start RMIRegistry）。
1．JDBC的基本层次结构由（Java程序）、（JDBC AP I）、（JDBC驱动程序管理器）、（驱动程序）和数据库五部分组成。
2．根据访问数据库的技术不同，JDBC驱动程序相应地分为（JDBC-ODBC Bri dge）、（JDBC-Native API Bridge）、（JDBC-Middleware）和（Pure JDBC D river）四种类型。
3．JDBC API所包含的接口和类非常多，都定义在（java.sql）包和（javax. sql）包中。
4．使用（Class.forName( )）方法加载和注册驱动程序后，由（DriverMana ger）类负责管理并跟踪JDBC驱动程序，在数据库和相应驱动程序之间建立连接。
5．（java.spl.Connection）接口负责建立与指定数据库的连接。
6．（PreparedStatement）接口的对象可以代表一个预编译的SOL语句，它是（Statement）接口的子接口。
7．（ResultSet）接口表示从数据库中返回的结果集。
三、选择题
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()
(C) abstract double d; (C) abstract final double hyperbolicCosine()
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行不能通过编译，因为只能有一个静态初始化器
(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);
}
(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);
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、编译将产生错误
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 ）
1.
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、有如下代码段:
1)
2) { if(unsaf e()){//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