面向对象原理与Java实践复习题集(2)

面向对象原理与Java实践复习题集（2）
一、单项选择题（请将所选择的答案号码填写在每小题中的圆括号内）
1、下列（D）不是面向对象程序设计方法的特点。

A．抽象B．继承C．多态D．结构化
2、下列关于Java语言特性的描述中，错误的是（ D ）。

A．支持多线程B．Java程序与平台无关C．Java程序可以直接访问Internet上的对象D．支持单继承与多继承3、编译并运行如下代码：C
public class TestIf {
public static void main(String[] args){
if(true)
if(false)
System.out.println("a");
else
System.out.println("b");
}
}
A．无法编译B．编译正常，输出字母a
C．B．编译正常，输出字母b D．编译正常，但是不会输出任何字母4、关于以下代码，说法正确的是（ D ）。

public void test(int x){
switch(x){
case 1:
case 2:
case 3:
default:
case 4:
}
}
A．变量x不具备switch表达式所需的类型
B．每个case部分必须以break语句结尾
C．default标签必须是switch语句中最后一个标签
D．代码没有任何错误
5、关于类和对象，以下说法错误的是（ C ）。

A．对象就是属性和操作相关属性的行为的集合，是类的具体化。

B．对象是系统中用来描述客观事物的一个实体，它是构成系统的一个基本单位。

C．类是各种对象的集合与抽象。

D．消息表示对象之间进行交互，以实现复杂的行为。

6、关于封装，以下说法错误的是（D ）。

A．封装是指利用抽象数据类型将数据和基于数据的操作包装起来。

B．封装是把对象的属性和动作结合成一个独立的单位，并尽可能隐蔽对象的内部细节。

C．封装使类容易使用，且更加安全，不会去破坏类内的数据。

D．封装保障了数据的完整性和系统的独立性。

7、关于多态，以下说法错误的是（ B ）。

A．多态是指在一般类中定义的属性或动作被特殊类继承之后，可以具有不同的数据类型或表现出不同的行为。

B．多态使得同一个属性或动作在一般类及其各个特殊类中具有相同的语义。

C．可通过子类对父类方法的重写（override）实现多态。

D．可通过同一类中定义同名方法即重载（overload）实现多态。

8、关于抽象类，以下说法错误的是（ D ）。

A．抽象类是指只能被继承而不能生成具体对象（即不能实例化）的类。

B．包含抽象方法的类是抽象类。

C．一个抽象类中可以有一个或多个抽象方法，但也可以没有抽象方法。

D．抽象类可以实例化，但这个实例化对象不能使用。

9、关于接口，以下说法错误的是（A ）。

A．接口用来表明一个类必须作什么，而不是规定它去如何作。

B．接口常用来指定类的协议（Protocol）。

C．接口本质上是抽象类。

D．接口中没有可以变动的数据成员（变量），只能有final类型的数据成员（常量）。

10、关于final修饰符，以下说法错误的是（ D ）。

A．如果一个类的定义很完整，不需要再创建该类的子类，则这个类称为终极类。

B．在Java中，被定义成final的类，通常是用来完成某种标准操作，具有固定作用的类。

C．终极方法是指不能被子类重写的方法。

D．final修饰变量时，那么变量的取值在整个程序中是不能改变的，亦即在整个程序中是不能被赋值的。

11、关于数组，以下说法错误的是（ A ）。

A．在使用数组之前必须要初始化。

B．数组是作为对象来处理的，所有的数组对象都有length属性，用来记录数组中元素的个数。

C．数组是作为对象来处理的，所有的数组对象都有length( )方法，用来获取数组中元素的个数。

D．使用foreach循环遍历数组时，无须获得数组和集合长度，无须根据索引来访问数组元素和集合元素，foreach循环会自动遍历数组。

12、关于二维数组，以下说法错误的是（ B ）。

A．二维数组可以静态初始化。

B．二维数组不可以动态初始化。

C．可以将一个二维数组看成是由多个一维数组组成的。

D．在有些具体的应用中，每行元素的个数不是相等的，Java允许生成具有不同长度的多维数组。

13、关于字符串，以下说法错误的是（ B ）。

A．在Java语言中，字符串是抽象的数据类型，只能使用对象表示字符串。

B．字符串类String用于创建字符串对象，并且创建的字符串的值在程序运行中可以被改变。

C．调用字符串类String的charAt(int index)方法可以获取指定位置的字符。

D．当需要改变字符串的值时，可使用StringBuffer类。

14、关于Java集合框架，以下说法错误的是（ C ）。

A．List接口的实现类可以存储一组不唯一（允许重复）、有序（插入顺序）的对象。

B．set接口的实现类可以存储一组唯一（不允许重复）、无序（插入顺序）的对象。

C．Collection接口的实现类可以存储一组不唯一（允许重复）、无序（插入顺序）的对象。

D．Map接口专门处理键值映射数据的存储，可以根据键实现对值的操作。

键和值要求有序（插入顺序）、唯一（不允许重复）。

15、关于GUI程序设计，以下说法错误的是（D ）。

A．Swing组件都是AWT的Container类的直接子类或间接子类。

B．每个容器都有一个默认的布局管理器。

C．当容器被创建后，可以通过特定的方法改变容器的布局管理器。

D．JPanel可以作为一个顶层容器使用。

16、关于事件处理机制，以下说法错误的是（ A ）。

A．在事件处理的过程中，主要涉及二类对象：事件、事件源。

B．不同的事件源上可能发生不同的事件。

C．同一个事件源上可能发生多种事件。

D．事件源可以把在其自身所有可能发生的事件分别授权给不同的事件处理者来处理。

17、关于事件处理，以下说法错误的是（D ）。

A．事件的处理由事件处理程序完成。

B．当事件对象生成时，AWT事件处理系统就会将这个事件对象传递给所涉及的组件，由它们的事件处理程序进行相应处理。

C．事件的授权处理模型是指不同的事件，可以交由不同类型的监听器去处理。

D．事件监听程序须定义在组件所在的类中。

18、关于异常处理机制，以下说法错误的是（ D ）。

A．Java程序的执行过程中如出现异常事件，可以生成一个异常类对象，该异常对象封装了异常事件的信息并将被提交给Java运行时系统，这个过程称为抛出（throw）异常。

B．当Java运行时系统接收到异常对象时，会寻找处理这一异常的代码并把当前异常对象交给其处理，这一过程称为捕获（catch）异常。

C．Exception类是所有异常类的父类，其子类对应了各种各样可能出现的异常事件，一般需要用户显式的声明或捕获。

D．内存溢出是一种Java异常。

Error
19、关于输入输出流，以下说法错误的是（ C ）。

A．简单地说，流（Stream）是通过一定的传播路径从源传递到目的地的字节序列。

B．所有的字节流类都是InputStream抽象类和OutputStream抽象类的子类。

C．如果想一次读取一行字符时，可使用BufferReader类。

Ed
D．随机文件访问类RandomAccessFile是一种I/O流类。

20、关于线程，以下说法错误的是（ D ）。

太难了
A．线程是程序中单个顺序的流控制，是最小的执行单位。

B．同类的多个线程共享一块内存空间和一组系统资源。

C．多线程是指在一个程序中可以定义多个线程并同时运行它们，每个线程可以执行不同的任务。

D．创建线程类一般有两种方法：一种方法是通过继承线程类Thread来创建线程类；另一种方法是建立一个Runnable接口的子类来创建线程。

] 线程本身并不是程序，而是一个程序内部的顺序控制流，它自己本身并不能运行，必须在程序中运行，所以选项A错误。

对于进程而言，每个进程都有自己独立的一块内存空间、一组系统资源。

而线程不同于进程，多个线程共享一块内存空间和一组系统资源，所有选项B错误。

多线程指在一个程序中可以定义多个线程并同时运行它们，每个线程可以执行不同的任务，即在同一个程序中多行语句同时执行，而不是多次启动一个程序，所以选项D错误。

多线程是针对一个程序而言的，代表着一个程序内部可以同时执行的线程个数。

只有选项C叙述正确。

21、关于下面的代码，哪些结论是正确的？
class J_SuperClass {
J_SuperClass( ) {
}
}
class J_SubClass extends J_SuperClass {
}
BD
(A) 类J_SubClass的构造方法具有public属性
(B) 类J_SubClass的构造方法不含参数
(C) 类J_SubClass的构造方法包含调用this( )
(D) 类J_SubClass的构造方法包含调用super( )
22、下面哪些选项的语句置于指定的位置会导致程序输出“sub”？D
class J_Base {
}
class J_SubClass extends J_Base {
public String mb_getString( ) {
return(“Sub”);
}
}
class J_Test {
public static void main(String[] args) {
J_Base app = new J_SubClass( );
// 选项语句插入的位置
}
}
(A) System.out.println(app.mb_getString( ));
(B) System.out.println((J_Base)app.mb_getString( ));
(D) System.out.println(((J_SubClass)app).mb_getString( ));
23、下面哪些选项的语句置于指定的位置会导致程序输出“sub”？AD
class J_Base {
public String mb_getString( ) {
return(“Base”);
}
}
class J_SubClass extends J_Base {
public String mb_getString( ) {
return(“Sub”);
}
}
class J_Test {
public static void main(String[] args) {
J_Base app = new J_SubClass( );
// 选项语句插入的位置
}
}
(A) System.out.println(app.mb_getString( ));
(B) System.out.println((J_Base)app.mb_getString( ));
(C) System.out.println((J_SubClass)app.mb_getString( ));
(D) System.out.println(((J_SubClass)app).mb_getString( ));
24、下面哪些选项的语句置于指定的位置会导致程序输出“Base”？无
class J_Base {
public String mb_getString( ) {
return(“Base”);
}
}
class J_SubClass extends J_Base {
public String mb_getString( ) {
return(“Sub”);
}
}
class J_Test {
public static void main(String[] args) {
J_Base app = new J_SubClass( );
// 选项语句插入的位置
}
}
(A) System.out.println(super().mb_getString( ));
(B) System.out.println((J_Base)app.mb_getString());
(C) System.out.println((J_Base)app.mb_getString());
25、将各选项的程序片段插入到下面程序片段的指定位置，结果会产生编译错误的有哪些？Bcd
public class J_Test {
public long mb_sum(long a, long b) {
return a + b;
}
// 选项语句插入的位置
}
(A) public int mb_sum(int a, int b) { return a + b; }
(B) public int mb_sum(long a, long b) { return a + b; }
(C) abstract int mb_sum( );
(D) private long mb_sum(long a, long b) { return a + b; }
26、假设在Java源程序文件“MyClass.java”中只含有一个类，而且这个类必须能够被位于一个庞大的软件系统中的所有Java类访问到，那么下面哪些声明有可能是符合要求的类声明？D
(A) private class MyClass extends Object
(B) public class myclass extends Object
(C) public class MyClass
(D) public class MyClass extends Object
27、下面的程序输出是什么？
class J_Class {
static int m_data = 0;
}
class J_Test {
public static void main(String[] args) {
J_Class a = new J_Calss();
J_Class b = new J_Calss();
a.m_data = 1;
b.m_data = 2;
System.out.println(a.m_data);
}
}
(A) 0 (B) 1 (C) 2 (D) 上面的程序含有编译错误
28、关于下面的程序，哪些结论是正确的？
public class J_Test {
public static void main(String[] args) {
int[] a =new int[5];
a.length =10;
System.out.println(a.length);
}
}
(A) 程序可以通过编译并正常运行，结果输出“10”
(B) 程序可以通过编译并正常运行，结果输出“5”
(C) 程序无法通过编译
(D) 程序可以通过编译，但无法正常运行
29、假设已经定义了变量“String s = “String”;”，则下面哪些语句可以通过编译？
(A) int a = s.length( ); (B) int b = s.length; (C) char c = s[3]; (D) s += 3;
30、已知定义了两个变量
String s1 = “ja”;
String s2 = “va”;
下面哪些变量与字符串直接量“java”指向同一个实例对象？
(A) String a = “ja” + “va”;(B) String b = new String(“java”);
(C) String c = “java”.toString( );(D) String d = s1 + s2;
31、下面的程序输出是什么？
class J_StringBuffer {
static void mb_operate(StringBuffer x, StringBuffer y) {
x.append(y);
y = new StringBuffer(“AB”);
}
public static void main(String[] args) {
StringBuffer a = new StringBuffer(“A”);
StringBuffer a = new StringBuffer(“B”);
mb_operate(a, b);
System.out.println(a + “.” + b);
}
}
(A) A.B (B) A.A (C) AB.AB (D) AB.B
32、下面哪些方法定义置于指定位置不会产生编译错误？
class J_SuperClass {
public void mb_method(int i) {
}
}
public class J_Test extends J_SuperClass {
//选项方法定义插入位置
public static void main(String[] args) {
}
}
(A) void mb_method(int i) throws Exception { }
(B) void mb_method(long i) throws Exception { }
(C) void mb_method(long i) { }
(D) public void mb_method(int i) throws Exception { }
33、下面哪些语句不含编译错误？
(A) File f = new File(“/”, “run.bat”);
(B) DataInputStream f = new DataInputStream(System.in);
(C) OutputStreamWriter f = new OutputStreamWriter(System.out);
(D) RandomAccessFile f = new RandomAccessFile(“data.txt”);
34、用“new FileOutputStream(“data.txt”,true)”创建一个FileOutputStream实例对象，则下面哪些说法是正确的？
(A) 如果文件“data.txt”存在，则将抛出IOException异常
(B) 如果文件“data.txt”不存在，则将抛出IOException异常
(C) 如果文件“data.txt”存在，则将覆盖掉文件中已有的内容
(D) 如果文件“data.txt”存在，则将在文件的末尾开始添加新内容。

35、下面哪些选项的语句置于指定的位置时，会使得程序在控制台窗口中输出鼠标在程序运行窗口中的横坐标数值？
public class J_Test extends JFrame {
public static void main(String[] args) {
J_Test app = new J_Test( );
app.addMouseListener( new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
// 选项语句插入的位置
}
});
app.setSize(250,220);
app.setVisible(true);
}
}
(A) System.out.println(e.x);(B) System.out.println(e.getX());
(C) System.out.println(e.getPoint().x);(D) System.out.println(e.getPoint().getX());
36、关于下面程序，哪些结论是正确的？
public class J_Test extends Thread {
static String m_data = “Data: ”;
public void mb_method(String s) {
s = s + “ = ”;
start();
}
public void run( ) {
for (int i = 0; i<4; i++) {
m_data = m_data + i + “,”;
}
}
public static void main(String[] args) {
J_Test t = new J_Test();
t.mb_method(m_data);
System.out.println(m_data);
}
}
(A) 运行结果可能输出：“Data: =”(B) 运行结果可能输出：“Data: =0,1,2,3,”
(C) 运行结果可能输出：“Data: ”(D) 运行结果可能输出：“Data: 0,1,2,3,”
37、下面哪些方法是类.InetAddress的静态方法，可以根据主机名创建该类的实例对象？
(A) getHostName (B) getByName
(C) getHostAddress (D) getInetAddress
38、下面哪些结论是正确的？
(A) 类.DatagramSocket是类.Socket的子类，所以.DatagramSocket 的实例对象实际上也是.Socket的实例对象
(B) 类.Socket是类.DatagramSocket的子类，所以.Socket的实例对象实际上也是.DatagramSocket的实例对象
(C) 类.DatagramSocket的成员方法receive( ) 和send( )可以接收与发送由类.DatagramPacket封装的数据包
(D) 类.DatagramSocket的成员方法receive( ) 和send( )可以直接接收与发送字符串实例对象
39、下面哪些方法可以用来建立数据库连接？
(A) java.sql.DriverManager的方法getConnection( )
(B) java.sql.DataSource的方法getConnection( )
(C) java.sql.DataSource的方法connection( )
(D) java.sql.Driver的方法getConnection( )
40、下列哪些方法是java.sql.ResultSet的方法并且有可能改变结果集当前行？
(A) boolean absolute(int row) throws SQLException
(B) void beforeFirst( ) throws SQLException
(C) int getRow( ) throws SQLException
(D) boolean previous( ) throws SQLException
二、判断题（请在每小题后面的括号内填上“√”或“×”）
1、Java程序的跨平台主要是指字节码文件可以在任何具有Java虚拟机的计算机或者电子设备上运行。

√
2、变量的声明格式是：[各种限定符] dataType variablename [=value]; 声明一个变量的同时也就指明了变量的作用域。

√
3、Java中除boolean类型外，其余基本的数据类型都有其对应的类（称为封装类wrapper class）。

×
4、if语句使用布尔表达式或布尔值作为分支条件来进行分支控制；而switch语句则用于对多个值进行匹配，从而实现分支控制。

√
5、循环结构中，break语句跳出当前的循环，执行循环结构后面的语句，而continue语句则是终止当前一轮的循环，直接进入下一轮循环。

√
6、在Java语言中，所有使用类定义的变量都是引用变量，它们将引用到类的对象。

√
7、抽象是指去掉被研究对象中与当前无关的部分，或暂时不用考虑的部件，仅求取当前需求有直接影响的因素——即实质内容。

√
8、封装的原则在软件上的反映是：要求使对象以外的部分不能随意存取对象的内部数据（属性），从而有效的避免了外部错误对它的“交叉感染”，使软件错误能够局部化，大大减少查错和排错的难度。

√
9、方法用来规定对类数据的操作，实现类的内部功能，是类与外界（其它类）交互的窗口。

√
10、类必须通过实例化生成对象才能使用。

×
11、类成员是指用static修饰的变量和方法。

不专属于任何一个具体的对象，是所有对象共有的。

√
12、可以将没有任何抽象方法的类声明为abstract，避免由这个类直接创建任何的对象。

√
13、在用final修饰变量时，可以先不给出该变量的值而在以后赋，但一量赋值则不能再改变该变量的值。

×
14、在Java异常处理程序中，finally块中的代码总能被执行，即使异常处理代码中执行了System.exit(1)语句。

×
15、对于BufferReader缓冲字符流对象，如果到达流的结尾，将返回null，而不是String。

×
16、对象的串行化(Serialization)的目的是为Java的运行环境提供一组特性，其主要任务是写出对象实例变量的数值。

√
17、串行化只能保存对象的非静态成员变量，不能保存任何的成员方法和静态的成员变量。

而且串行化保存的只是变量的值，对于变量的任何修饰符，都不能保存。

√
18、PreparedStatement对象实例中可以包含用“?”代替的多个待定义参数，这些参数将在该语句对象被提交数据库系统执行之前，利用setXXX( )方法进行设置。

√
19、实现了Runnable接口的对象可以作为线程对象使用。

√
20、调用线程的yield()方法可使得当前线程暂停执行，等待调用该方法的线程对象的线程结束后再继续执行当前线程。

×
21、下面程序输出数字0。

（√）
public class J_Test extends Thread {
static int m_data;
m_data = 0;
public static void main(String[] args) {
System.out.println(m_data);
}
}
22、运行下面程序将在控制台窗口中输出a。

（×）
public class J_Test extends Thread {
public J_Test() {
char c = 'a';
}
public static void main(String[] args) {
System.out.println(c);
}
}
23、下面的程序将输出“Creating Rock 2”。

（√）
class J_Rock {
J_Rock(int i) {
System.out.println("Creating Rock " + i);
}
}
class J_SubRock extends J_Rock{
}
class J_RockApplication {
public static void main(String[] args) {
new J_Rock(2);
}
}
24、设在一个Java包a中含有源程序文件J_Data.java，其内容如下：
package a;
public interface J_Data {
double PI = 3.141592653589793;
}
在另一个包中含有源程序文件J_Test.java，其内容如下：
import a.*;
public class J_Test {
public static void main(String[] args) {
System.out.println((int)J_Data.PI);
}
}
假设类路径设置及源文件所在的路径都是正确的，则上面的程序可以正确进行编译与运行，最终可以输出3。

（×）
25、对于数组int[][] t = {{1,2,3},{4,5,6}}来说，t.length等于3，t[0].length等于2。

（×）
26、假设文件“a.txt”的长度为100字节，那么当正常运行下面语句
OutputStream f = new FileOutputStream(new File(“a.txt”)); //管你等会写不写，先把你文件清空再说。

之后，文件“a.txt”的长度为0字节。

（√）
27、假设文本文件“test.txt”存在，那么下面的程序可以正常运行，并且运行的结果是将文件“test.txt”的内容显示在控制台窗口中。

（）
public class J_Test {
public static void main(String[] args) {
int b;
FileInputStream f = new FileInputStream("test.txt");
for(; (b = f.read()) != -1; ) {
System.out.println();//啥都没，输出个积极
}
System.out.println();
f.close();
}
}
28、java.io.PrintStream具有自动强制输出（flush）功能，即当输出回车换行符时，在缓存中的数据就会全部自动写入指定的文件或输出在控制台窗口中。

（√）
29、在Java中，类java.io.File虽然不直接处理文件内容，但可以通过类java.io.File达到改变当前路径的目的。

（√）
30、标签（JLabel）内显示的内容一般是不可更改的，即标签一旦创建并设置内容，其内容便不可以更改。

（×）
31、采用事件适配器比采用事件监听器的执行效率要高，因为采用事件适配器可以只处理所
需处理的事件。

（×）
32、接口java.awt.event.MouseWheekListener所对应的事件适配器是java.awt.event.MouseWheelAdapter。

（×）
33、要启动一个线程需要调用ng.Thread的方法start( )。

在运行完方法start( )之后，该线程就处于就绪态。

（√）
34、当执行到同步语句“synchronized (引用表达式）”的语句块时，引用类型表达式所指向的对象就会被锁住，不允许其他线程对其进行访问，即当前的线程独占该对象。

（对）35、.ServerSocket的方法accept( )会暂时中止程序的运行，而使程序处于监听来自客户端连接的状态，直到有客户端与该服务器端建立起连接。

（√）
36、在编写基于TCP的网络程序时，在服务器端的Socket实际上就是类.ServerSocket 的实例对象。

（√）
37、语句“java.sql.Statement s = new java.sql.Statement( );”创建了java.sql.Statement的实例对象。

然后通过java.sql.Statement的方法execute( )执行SQL(Structured Query Language，结构查询语言)语句。

（√）
38、每个java.sql.Statement实例对象只能对应一个java.sql.ResultSet实例对象，所以如果执行SQL语句返回多个结果，一般需要分多次取得返回结果。

（√）
39、计算机语言的数组一般从0开始，但java.sql.ResultSet的方法getDouble()、getString()和getInt()对列的计数却是从1开始。

（√）
40、调用java.sql.ResultSet的方法next()的结果是将当前位置移动到下一列。

如果下一列为空，则将产生一个java.sql.SQLException异常。

（×）
三、填空题（请在每小题后空白处答题）
1、阅读以下程序：
public class TestIf {
public static void main(String[] args){
int temp = 0;
for(int i=0; i<100; i++){
temp++;
}
System.out.println("temp = " + temp);
int x = 0;
temp = 0;
for(int i=0; i<100; i++){
x = (temp++);
}
System.out.println("tempx = " + x);
}
}
程序编译运行的结果是：
temp = 100
tempx = 99 //先赋值后++所以少1
2、阅读下列程序段：
int x=5,y=10,r=5;
switch(x+y){
case 15: r += x;
case 20: r -= y;
case 25: r *= x/y;
default: r += r;
}
程序段执行后，r的值是：
//没加break，全部执行，按顺序，包括default
3、阅读以下程序：
public class Test {
int n1,n2;
public void swap(Test n){
int n0;
n0 = n.n1;
n.n1 = n.n2;
n.n2 = n0;
}
public static void main(String[] args){
int n1=1,n2=10;
Test numbers = new Test();
numbers.n1 = 5;
numbers.n2 = 20;
numbers.swap(numbers);
System.out.println(numbers.n1);
System.out.println(numbers.n2);
}
}
程序编译运行的结果是：
20
5
4、阅读以下程序：
public class FatherClass {
public FatherClass(){
System.out.println("FatherClass Create");
}
}
public class ChildClass extends FatherClass { public ChildClass(){
System.out.println("ChildClass Create");
}
public static void main(String[] args){
FatherClass fc = new FatherClass();
ChildClass cc = new ChildClass();
}
}
程序编译运行的结果是：
FatherClass Create
FatherClass Create
ChildClass Create
5、阅读以下程序：
public class FatherClass {
public FatherClass(){
System.out.println("FatherClass Create");
}
public void speak(){
System.out.println("I am FatherClasste");
}
}
public class ChildClass extends FatherClass { public ChildClass(){
System.out.println("ChildClass Create");
}
public void speak(){
System.out.println("I am ChildClass");
}
public static void main(String[] args){
FatherClass fc = new ChildClass();
fc.speak();
}
}
程序编译运行的结果是：
FatherClass Create ChClass Create
I am child.
6、阅读以下代码：
int[] score = {1,2,3,4,5};
int temp = score[0];
for(int index=1; index<5; index++){
if(score[index]<temp){
temp = score[index];
}
}
System.out.println(temp);
代码运行的结果是：
1
7、阅读以下代码：：
List list = new ArrayList();
list.add("Hello");
list.add("Learn");
list.add("Hello");
list.add("Welcome");
Set set = new HashSet();
set.addAll(list);
System.out.println(set.size());
代码运行的结果是：
3
8、阅读以下程序：
public class ExceptionOrder {
public static void main(String args[]) {
System.out.println("1");
try {
System.out.println("2");
if (true)
throw new InstanceException();// 抛出用户定义的异常System.out.println("3");
} catch (InstanceException e) // 捕获该异常
{
System.out.println("4");
}
System.out.println("5");
}
}
class InstanceException extends Exception {
public InstanceException() {
super();
}
}
程序编译运行的结果是：
1
2
4
5
9、阅读以下程序：
public class ReadSource {
public static void main(String[] arguments) {
try {
FileReader file = new FileReader("ReadSource.java");
BufferedReader buff = new BufferedReader(file);
boolean eof = false;
while (!eof) {
String line = buff.readLine();
if (line == null)
eof = true;
else
System.out.println(line);
}
buff.close();
} catch (IOException e) {
System.out.println("Error -- " + e.toString());
}
}
}
程序的功能是：
将ReadSource.java内容逐行打印
10、阅读以下程序：
public class Test {
public static void main(String[] args) {
Pmcraven pm1 = new Pmcraven("one");
pm1.run();
Pmcraven pm2 = new Pmcraven("two");
pm2.run();
}
}
public class Pmcraven extends Thread {
private String sTname = "";
Pmcraven(String s){
sTname = s;
}
public void run(){
for(int i=0; i<2; i++){
try{
sleep(1000);
}catch(InterruptedException e){
}
yield();
System.out.println(sTname);
}
}
}
程序编译运行的结果是：
one
one
two
two
11、运行下面程序，会输出J_SuperClassJ_SuperClass。

class J_SuperClass {
J_SuperClass(){
System.out.print("J_SuperClass");
}
}
class J_SubClass extends J_SuperClass {
void J_SubClass(){
System.out.print("J_SubClass");
}
}
public class J_Test {
public static void main(String[] args) {
new J_SubClass();
new J_SuperClass();
}
}
12、语句“J_Example a = new J_Example( );”定义了变量a。

想释放变量a所指向的实例对象的内存空间，请写出相应的一条或多条语句：a=null; 。

13、请写出下面程序的输出结果：14 。

class J_SuperClass {
int m_data;
J_SuperClass(){
mb_add(1);
}
public void mb_add(int i) {
m_data += i;
}
public void mb_print() {
System.out.println(m_data);
}
}
class J_SubClass extends J_SuperClass {
J_SubClass(){
mb_add(2);
}
public void mb_add(int i) {
m_data += i*2;
}
}
public class J_Test {
public static void mb_method(J_SuperClass a) {
a.mb_add(4);
a.mb_print();
}
public static void main(String[] args) {
mb_method(new J_SubClass());
}
}
14、下面程序的输出是12 。

class J_Test {
public static void main(String[] args) {
String[] s = {"1", "2"};
mb_swap(s[0],s[1]);
System.out.println(s[0] + s[1]);
}
static void mb_swap(String s0, String s1) {
String t = s0;
s0 = s1;
s1 = t;
}
}
15、下面程序的运行结果是123412345678null。

class J_Test {
public static String m_s;
public static void main(String[] args) {
String s1 = "1234";
String s2 = s1;
s2 += "5678";
s1.concat("5678");
System.out.println(s1 + s2 + m_s);
}
}
16、下面程序输出13423。

public class J_Test {
public static void mb_method(int i){
try {
if(i == 1)
throw new Exception();
System.out.print("1");
}catch(Exception e) {
System.out.print("2");
return;
}
finally {
System.out.print("3");
}
System.out.print("4");
}
public static void main(String[] args) {
mb_method(0);
mb_method(1);
}
}
17、请填写下面程序的输出结果： 2 。

public class J_Test {
public static void main(String[] args) throws Exception {
java.io.RandomAccessFile f = new RandomAccessFile("a.txt", "rw");
f.writeBoolean(true);
f.writeBoolean(false);
for(int i=1; i<10; i++)
f.writeInt(i);
f.seek(6);
System.out.println(f.readInt());
f.close();
}
}
18、下面程序的运行结果是捕捉到一个一般异常。

public static void main(Sring args[]){
try{
int a=1 , b=0 ;
System.out.println(a/=b) ;
}catch(Exception e){
System.out.println( “捕捉到一个一般异常”) ;
}catch(ArithmeticException e){
System.out.println( “捕捉到一个算术异常”) ;
}
}
19、下面程序的运行结果是 1 2 3 4 5 2 4 6 8 10 。

class UseBreakIdentifier{
public static void main(String[] args){
int i,j,product;
iLoop:
for(i=1;i<=9;i++){
for(j=1;j<=9;j++){
product=i*j;
if(j==6) continue iLoop;;
if(i==3) break iLoop;
if(product>=10) System.out.print(product+" ");
else System.out.print(product+" ");
}
System.out.println();
}
}
}
20、下面程序的运行结果是
I am A
make a request for A in B
I am B
I am A
Hello in B。

class A{
String s="I am A";
A(){System.out.println(s);}
A(String s){
this();
System.out.println(s+" in A");
}
}
class B extends A{
String s="I am B";
B(){
this("make a request for A");
System.out.println(s);
}
B(String s){
System.out.println(s+" in B");}
public static void main(String[] args){
B obj=new B();
B b=new B("Hello ");
}
}
四、程序填空题（请将答案按注释要求填写在带下划线的空行上）
1、根据注释要求完成划线处的代码。

// 从键盘输入一个整数，是奇数时显示。

import java.io.*;
class Odd {
public static void main(String[] args)throws IOException{
Scanner sc = new Scanner (___________________);
String str;
System.out.println("请输入一个整数:");
int num = sc. ___________________;
if(___________________)
System.out.println(num+"是一个奇数！");//打印奇数，偶数不打印}
}
class Odd {
public static void main(String[] args){
Scanner sc = new Scanner (System.in);
String str;
System.out.println("请输入一个整数:");
int num = sc.nextInt();
if(num%2 == 1)
System.out.println(num+"是一个奇数！");//打印奇数，偶数不打印}
}
2、根据注释要求完成划线处的代码。

// 1）定义一个抽象类Shape和一个求取面积的抽象方法getArea()
_________
public abstract class Shape {
Abstract doubl getArea();
}
__________________________________________________
__________________________________________________
// 2）定义类Shape的一个子类：矩形类Rectangle
class Rectangle extends Shape{
_________________________________________
//将矩形的边长作为属性
_____double side1;__
double _side2;__________________________________________ __________________________________________________
//写出以矩形的边长为参数的构造方法
public Rectangle(double s1, double s2){
side1= s1;
side2=s2;
}
__________________________________________________
__________________________________________________
__________________________________________________
//并重写求取面积的方法
@Override
double getArea() {
return side1*side2;
}
__________________________________________________
__________________________________________________
}__________________________________________________
public abstract class Shape {
Abstract doubl getArea();
}
class Rectangle extends Shape{
double side1;__
double side2;
public Rectangle(double s1, double s2){
side1= s1;
side2=s2;
}
double getArea() {
return side1*side2;
}
}
3、从键盘上以行的形式输入字符串，然后将它存入文本文件text1.txt中，以输入字符串“/end”时结束。

阅读下面代码段，根据注释要求补充、完成划线处的代码。

public class CreateTextFile {
public static void main(String[] arguments) {
try {
InputStreamReader readString = new InputStreamReader(__________________);
BufferedReader buff = new BufferedReader(__________________);
FileWriter file = new FileWriter(__________________);
String line = buff. __________________;// 从键盘读一行
do {
file.write(__________________);// 写入文件，加换行符
line = buff. __________________;// 从键盘读
} while (__________________);// 如果读的是“/end”，结束读
buff.close();// 关闭
file.close();// 关闭
} catch (IOException e) {
System.out.println("Error: " + e.toString());
}
}
}
try {
InputStreamReader readString = new InputStreamReader(System.in);
BufferedReader buff = new BufferedReader(readString);
FileWriter file = new FileWriter("text1.txt");
String line = buff.readLine();// 从键盘读一行
do {
file.write(line + "\r\n");// 写入文件，加换行符
line = buff.readLine();// 从键盘读
} while (!line.equals("/end"));// 如果读的是“/end”，结束读
buff.close();// 关闭
file.close();// 关闭
} catch (IOException e) {
System.out.println("Error: " + e.toString());
}
4、下面程序利用专用JDBC驱动程序连接MySQL数据库，并获得数据库属性信息。

所采用的JDBC驱动程序名为“com.mysql.jdbc.Driver”。

请根据注释要求补充、完成划线处的代码。

public class GetDBAbout {
public static void main(String args[]){
//指定MySQL JDBC驱动程序
//指定JDBC驱动程序和数据源的位置。

格式：jdbc:子协议:数据源。

其中，服务器域名为本地服务器，数据库名为student，用户名与密码均为root
String url =
//连接url指定数据库
Connection conn =
//创建DatabaseMetaData数据库元数据接口对象以获得所连接数据库属性信息
DatabaseMetaData dbmd =
// （代码略）
//关闭数据库连接
}
}
public class GetDBAbout {
public static void main(String args[]) throws Exception{
//指定MySQL JDBC驱动程序
Class.forName("com.mysql.jdbc.Driver");
//指定JDBC驱动程序和数据源的位置。

格式：jdbc:子协议:数据源。

其中，服务
器域名为本地服务器，数据库名为student，用户名与密码均为root
String url = "jdbc:mysql://localhost:3306/student";
//连接url指定数据库
Connection conn = DriverManager.getConnection(url, "root", "root");
//创建DatabaseMetaData数据库元数据接口对象以获得所连接数据库属性信息
DatabaseMetaData dbmd = conn.getMetaData();
// （代码略）
//关闭数据库连接
conn.close();
}
}
5、在E盘根目录下创建文件夹mydir，再在dir中创建文件test.txt，然后在键盘上输入一个
字符串并将该字符串存入test.txt中。

import java.io.*;
public class FileIODemo {
public static void main(String[] args) {
// 创建相应的File对象
File dir = new File("e:\\mydir");
File file = new File();
// 创建文件夹mydir
dir.
try {
// 创建文件test.txt
file.
InputStreamReader isr = new InputStreamReader();
BufferedReader br = new BufferedReader();
FileWriter fw = new FileWriter();
PrintWriter pw = new PrintWriter();
String s = br. ;
while(!s.equals("")){
// 将该字符串存入test.txt中
pw.
s = br.
}
// ......
}
import java.io.*;。